Java面向对象——继承、super、this

简介: Java面向对象——继承、super、this

文章目录


继承的定义以及基本使用

成员变量重名

局部变量

方法重写

对象实例过程以及super关键字


继承的定义以及基本使用


定义:


子类能够继承父类的共有属性和方法;

20190829233304914.png


特点:


Java中只支持单继承,私有方法不能被继承


实现继承的类被称为子类(也叫派生类),被继承的类被称为父类(也叫基类)

Java的继承通过extends关键字实现


先写一个父类Animals类:


定义两个私有属性 name和age 然后给出共有的set和get接口 以及一个共有的say()方法;

package m10d28;
public class Animals {
  private String name;
  private int age;
  public String getName() {
  return name;
  }
  public void setName(String name) {
  this.name = name;
  }
  public int getAge() {
  return age;
  }
  public void setAge(int age) {
  this.age = age;
  }
  public void speak(){
  System.out.println("我是一只动物,我叫"+this.getName()+",我的年龄是"+this.getAge());
  }
}


再写一个子类Dog类,通过extends关键字 继承Animal类:


实际上把父类Animal的共有方法get set以及say()方法都继承了;

package m10d28;
public class Dog extends Animals{
  public static void main(String[] args) {
  Dog dog=new Dog();
  dog.setName("dog");
  dog.setAge(2);
  dog.speak();
  }
}


输出结果:

我是一只动物,我叫dog,我的年龄是2


成员变量重名


在父子类的继承关系当中,如果成员变量重名,则创建子类对象时,访问有两种方式:


直接通过子类对象访问成员变量:


等号左边是谁,就优先用谁,没有则向上找。


间接通过成员方法访问成员变量:


该方法属于谁,就优先用谁,没有则向上找。

public class Demo01ExtendsField {
    public static void main(String[] args) {
        Fu fu = new Fu(); // 创建父类对象
        System.out.println(fu.numFu); // 只能使用父类的东西,没有任何子类内容
        System.out.println("===========");
        Zi zi = new Zi();
        System.out.println(zi.numFu); // 10
        System.out.println(zi.numZi); // 20
        System.out.println("===========");
        // 等号左边是谁,就优先用谁
        System.out.println(zi.num); // 优先子类,200
//        System.out.println(zi.abc); // 到处都没有,编译报错!
        System.out.println("===========");
        // 这个方法是子类的,优先用子类的,没有再向上找
        zi.methodZi(); // 200
        // 这个方法是在父类当中定义的,
        zi.methodFu(); // 100
    }
}


局部变量


局部变量: 直接写成员变量名


本类的成员变量: this.成员变量名


父类的成员变量: super.成员变量名

public class Zi extends Fu {
   int num = 20;
    public void method() {
        int num = 30;
        System.out.println(num); // 30,局部变量
        System.out.println(this.num); // 20,本类的成员变量
        System.out.println(super.num); // 10,父类的成员变量
    }
}


方法重写


定义:所谓方法的重写 我们可以在子类中根据实际要求把父类的方法重写;

20190829233304914.png

在父子类的继承关系当中,创建子类对象,访问成员方法的规则:


创建的对象是谁,就优先用谁,如果没有则向上找。


注意事项:


无论是成员方法还是成员变量,如果没有都是向上找父类,绝对不会向下找子类的。


重写(Override)


概念:在继承关系当中,方法的名称一样,参数列表也一样。


重写(Override):方法的名称一样,参数列表【也一样】。覆盖、覆写。


重载(Overload):方法的名称一样,参数列表【不一样】。


方法的覆盖重写特点:创建的是子类对象,则优先用子类方法。

package m10d28;
public class Cat extends Animals{
  public void speak(){
  System.out.println("我是一只猫,我重写了父类的方法,我叫"+this.getName()+",我的年龄是"+this.getAge());
  }
  public static void main(String[] args) {
  Cat dog=new Cat();
  dog.setName("Cat");
  dog.setAge(2);
  dog.speak();
  }
}


注意:


重写的方法里面的this.getName()和this.getAge()不能更改为this.name和this.age


因为Cat对象里继承不到父类的私有字段;


输出结果:

我是一只猫,我重写了父类的方法,我叫Cat,我的年龄是2


方法覆盖重写的注意事项:


必须保证父子类之间方法的名称相同,参数列表也相同。


@Override:写在方法前面,用来检测是不是有效的正确覆盖重写。


这个注解就算不写,只要满足要求,也是正确的方法覆盖重写。


子类方法的返回值必须【小于等于】父类方法的返回值范围。


小扩展提示:java.lang.Object类是所有类的公共最高父类(祖宗类),java.lang.String就是Object的子类。


子类方法的权限必须【大于等于】父类方法的权限修饰符。


小扩展提示:public > protected > (default) > private


备注:(default)不是关键字default,而是什么都不写,留空。


继承关系中,父子类构造方法的访问特点:


子类构造方法当中有一个默认隐含的“super()”调用,所以一定是先调用的父类构造,后执行的子类构造。


子类构造可以通过super关键字来调用父类重载构造。


super的父类构造调用,必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。


总结:


子类必须调用父类构造方法,不写则赠送super();写了则用写的指定的super调用,super只能有一个,还必须是第一个。


对象实例过程以及super关键字


对象实例化先实例化调用父类构造方法,再调用子类实例化构造方法;


[super与this的内存图]


super关键字主要是调用父类方法或者属性;

20190829233200637.png

super关键字的用法有三种:


在子类的成员方法中,访问父类的成员变量。


在子类的成员方法中,访问父类的成员方法。


在子类的构造方法中,访问父类的构造方法。


super关键字用来访问父类内容,而this关键字用来访问本类内容。用法也有三种:


在本类的成员方法中,访问本类的成员变量。


在本类的成员方法中,访问本类的另一个成员方法。


在本类的构造方法中,访问本类的另一个构造方法。


在第三种用法当中要注意:


A. this(…)调用也必须是构造方法的第一个语句,唯一一个。


B. super和this两种构造调用,不能同时使用。


我们先来看看父类和子类的构造方法是如何调用的,顺序是怎样的:


我们先在父类Animals中添加父类无参构造方法和父类有参构造方法:

//添加无参构造方法
  public Animals(){
  System.out.println("父类无参构造方法!");
  }
  //添加有参构造方法
  public Animals(String name, int age) {
  System.out.println("父类有参构造方法!");
  this.name = name;
  this.age = age;
  }

 

在子类Cat中添加子类无参构造方法:

public Cat(){
  System.out.println("子类无参构造方法!");
  }


输出结果为:

父类无参构造方法!
子类无参构造方法!
我是一只猫,我重写了父类的方法,我叫Cat,我的年龄是2


程序是先调用父类的无参构造方法,再调用子类的无参构造方法!


super关键字的引用:


现在再来看看,如果在子类中用构造方法进行实例化的时候,在子类有参构造方法中


运用this.name或者this.getName()来调用父类私有属性会怎样?

2019082919585753.png


由上图可知,如果直接在子类有参构造方法中运用this.name或者this.getName()等都是会报错的!


因为name和age在父类中都是private类型的,子类是没有访问权限的!


那么,如何在子类有参构造方法中调用父类的属性和方法呢?


这时,super()关键字就可以派上用场了;前面说过:


super关键主要是调用父类方法或者属性;


在Cat子类中添加有参构造方法,并且实例化:

package m10d28;
public class Cat extends Animals{
  public void speak(){
  System.out.println("我是一只猫,我重写了父类的方法,我叫"+this.getName()+",我的年龄是"+this.getAge());
  }
  public Cat(){
  System.out.println("子类无参构造方法!");
  }
  public Cat(String name,int age){
  super(name,age);
  System.out.println("子类有参构造方法!");
  }
  public static void main(String[] args) {
  Cat dog=new Cat("Cat",3);
  dog.speak();
  }
}


输出结果:

父类有参构造方法!
子类有参构造方法!
我是一只猫,我重写了父类的方法,我叫Cat,我的年龄是3


这是由子类有参构造方法进行实例化的,而且用super关键字就可以调用父类私有属性和方法!


当然,可能有人会想,我直接调用父类有参构造方法不就行了;


但是偶尔子类也有自己独特的属性,这时也需要父类的属性一起:

package m10d28;
public class Cat extends Animals{
  public Cat(){
  System.out.println("子类无参构造方法!");
  }
  //给Cat添加一个独特的属性sex
  private String sex;
  public String getSex() {
  return sex;
  }
  public void setSex(String sex) {
  this.sex = sex;
  }
  public Cat(String name,int age,String sex){
  super(name,age);
  this.sex=sex;
  System.out.println("子类有参构造方法!");
  }
  public void speak(){
  System.out.println("我是一只猫,我重写了父类的方法,我叫"+this.getName()+
    ",我的年龄是"+this.getAge()+",我的性别是"+this.sex);
  }
  public static void main(String[] args) {
  Cat dog=new Cat("Cat",5,"雌性");
  dog.speak();
  }
}


父类有参构造方法!
子类有参构造方法!
我是一只猫,我重写了父类的方法,我叫Cat,我的年龄是5,我的性别是雌性



目录
相关文章
|
22天前
|
Java 关系型数据库 数据库
面向对象设计原则在Java中的实现与案例分析
【10月更文挑战第25天】本文通过Java语言的具体实现和案例分析,详细介绍了面向对象设计的五大核心原则:单一职责原则、开闭原则、里氏替换原则、接口隔离原则和依赖倒置原则。这些原则帮助开发者构建更加灵活、可维护和可扩展的系统,不仅适用于Java,也适用于其他面向对象编程语言。
14 2
|
27天前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
19 3
|
27天前
|
Java
在Java多线程编程中,实现Runnable接口通常优于继承Thread类
【10月更文挑战第20天】在Java多线程编程中,实现Runnable接口通常优于继承Thread类。原因包括:1) Java只支持单继承,实现接口不受此限制;2) Runnable接口便于代码复用和线程池管理;3) 分离任务与线程,提高灵活性。因此,实现Runnable接口是更佳选择。
35 2
|
27天前
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析:线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景,帮助读者更好地理解和掌握多线程编程技术,为复杂任务的高效处理奠定基础。
28 2
|
27天前
|
Java 开发者
Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点,重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
33 1
|
1月前
|
Java 测试技术 编译器
Java零基础-继承详解!
【10月更文挑战第4天】Java零基础教学篇,手把手实践教学!
39 2
|
1月前
|
Java 编译器
在Java中,关于final、static关键字与方法的重写和继承【易错点】
在Java中,关于final、static关键字与方法的重写和继承【易错点】
23 5
|
1月前
|
Java 测试技术 编译器
Java零基础-继承详解!
【10月更文挑战第6天】Java零基础教学篇,手把手实践教学!
25 0
|
1月前
|
存储 Java 程序员
Java基础-面向对象
Java基础-面向对象
17 0
|
6月前
|
Java
【JAVA学习之路 | 基础篇】super关键字
【JAVA学习之路 | 基础篇】super关键字
下一篇
无影云桌面