Java_面向对象之继承、抽象类

Java_面向对象之继承、抽象类

1.继承主要解决的问题：共性抽取
2.继承关系当中的特点：

• 子类可以拥有父类的“内容”
• 子类可以拥有自己的专属内容

3.格式

• 定义父类的格式：

public class 父类名称{
        //、、、、
}

• 定义子类的格式：

public class 子类名称 extends 父类名称{
        //、、、
}

• 代码实践：

//父类
public class Employee{

    //定义成员方法
    public void method(){
        System.out.println("父类的方法");
    }
}

//子类
public class Teacher extends Employee{
    
}

public class test{
    public static void main(String[] args){
        //创建子类对象来调用父类里面的方法
        Teacher teacher=new Teacher();
        teacher.method();
    }
}

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

• 直接通过子类对象访问成员变量：创建的对象是谁，就优先用谁
• 间接通过成员方法访问成员变量：方法属于谁，优先用谁

//父类
public class Employee{

    int num=100;
    // 定义成员方法
    public void methodEm(){
        System.out.println(num);
    }
}

//子类
public class Teacher extends Employee{
    int num=300;
    public void methodTe(){
        System.out.println(num);
    }
}

public class test{
    public static void main(String[] args){
        //创建对象
        Teacher te=new Teacher();

        //直接通过子类对象访问成员变量
        System.out.println(te.num);//300
        System.out.println("===================");

        //间接通过成员方法访问成员变量
        te.methodEm();//100
        System.out.println("===================");
        te.methodTe();//300
    }
}

5.区分子类方法中重名的三种变量

• 局部变量：直接写成员变量名
• 子类中的成员变量：this.成员变量名
• 父类中的成员变量：super.成员变量名

//父类
public class Employee{
    //父类中的成员变量
    int num=12;
}

//子类
public class Teacher extends Employee{
    //子类中的成员变量
    int num=23;

    public void method(){
        //局部变量
        int num=90;
        
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);

    }
}

public class test{
    public static void main(String[] args){
        Teacher teacher=new Teacher();
        teacher.method();
    }
}

6.继承中成员方法重名的访问特点：创建的对象是谁，就优先用谁

//父类
public class Employee{

    //定义成员方法
    public void method(){
        System.out.println("父类的重名方法");
    }
}

//子类
public class Teacher extends Employee{
    //定义成员方法
    public void method(){
        System.out.println("子类的重名方法");
    }
}

public class test{
    public static void main(String[] args){
        Teacher teacher=new Teacher();
        teacher.method();//子类的重名方法
    }
}

7.继承中方法的覆盖重写

• 覆盖重写：方法的名称一样，参数列表也一样
• 重载：方法的名称一样，参数列表不一样
• 方法的覆盖重写特点：创建的是子类对象，则优先使用子类方法
• 方法覆盖重写的注意事项：

（1）必须保证父子类之间方法的名称相同，参数列表也相同
（2）用@override（写在方法前面）来检测是否是正确的覆盖重写
（3）子类方法的返回值必须小于等于父类方法的返回值范围
（4）子类方法的权限必须大于等于父类方法的权限修饰符；public>protected>(default)>private；default不是关键字，而是什么都不写，留空

8.父子类构造方法的访问特点

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

//父类
public class Fu {
    public Fu(){
        System.out.println("父类构造方法");

    }
}

//子类
public class Zi extends Fu{
    public Zi(){
        // super(); 隐藏
        System.out.println("子类构造方法");
    }
}

public class DemoMethod {
    public static void main(String[] args){
        Zi zi=new  Zi();
    }
}
// 父类构造方法
// 子类构造方法

• 子类构造可以通过super关键字来调用父类重载构造
• super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调用多次super构造

9.super关键字的三种用法

• 在子类的成员方法中，访问父类的成员变量
• 在子类的成员方法中，访问父类的成员方法
• 在子类的构造方法中，访问父类的构造方法

//父类
public class Fu {
    int num=10;//成员变量

    public Fu(){//构造方法
        System.out.println("父");
    }

    public void method(){//成员方法
        System.out.println("A");
    }
}

//子类
public class Zi extends Fu{
    int num=20;
    public void methodZi(){
        System.out.println(super.num);//在子类的成员方法中，访问父类的成员变量
        System.out.println(num);
        System.out.println("========================");
    }

    public void method(){
        super.method();//在子类的成员方法中，访问父类的成员方法
        System.out.println("子");
    }

    public  Zi(){
        super();//在子类的构造方法中，访问父类的构造方法
        System.out.println("子");
        System.out.println("========================");
    }
}

public class DemoMethod {
    public static void main(String[] args){
        Zi zi=new  Zi();
        zi.methodZi();
        zi.method();
    }
}

10.this关键字的三种用法

• 在本类的成员方法中，访问本类的成员变量
• 在本类的成员方法中，访问本类的另一个成员方法
• 在本类的成员方法中，访问本类的另一个构造方法

（1）this(…)调用必须是构造方法的第一个语句，唯一一个
（2）super和this两种构造，不能同时使用

//子类
public class Zi extends Fu{
   int num=20;

   public void show(){
       int num=90;
       System.out.println(num);//局部变量
       System.out.println(this.num);//本类的成员变量
       System.out.println(super.num);//父类的成员变量
       System.out.println("========================");
   }

   public void methodA(){
    System.out.println("AAA");
   }

   public void methodB(){
    this.methodA();//本类的另一个成员方法
    System.out.println("BBB");
    System.out.println("========================");
}

    public Zi(){
        // super();
        this(123);//访问本类的另一个构造方法
    }

    public Zi(int num){

    }
}

11.super与this关键字图解

12.Java继承的三个特点

• 单继承（一个类的直接父类只能有唯一一个）
• 多级继承
• 一个子类的直接父类是唯一的，但是一个父类可以拥有很多个子类

13.抽象方法和抽象类的格式

• 抽象方法：加上abstract关键字，然后去掉大括号，直接分号结束
• 抽象类：在class之前加上abstract即可

//抽象类
public abstract class Animal {

    //普通成员方法
    public void eat(){

    }

    //抽象方法
    public abstract void method();
}

14.抽象类和抽象方法的使用

• 不能直接创建new抽象类对象
• 必须用一个子类来继承抽象父类
• 子类必须覆盖重写抽象父类当中的所有的抽象方法（子类去掉abstract关键字，然后补上方法体大括号）
• 创建子类对象进行使用

//父类
//抽象类
public abstract class Animal {
    //抽象方法
    public abstract void method();
}

//子类
public class Cat extends Animal {//必须用一个子类来继承抽象父类
    
    public void method(){//子类必须覆盖重写抽象父类当中的所有的抽象方法
        System.out.println("猫吃鱼");
    }
}

public class Main {
    public static void main(String[] args){
        // Animal animal=new Animal();//不能直接创建new抽象类对象

        Cat cat=new Cat();
        cat.method();
    }
}

14.抽象类和抽象方法的注意事项

• 可以存在没有抽象方法的抽象类