你想要的继承知识点都在这里

继承

文章目录

• 继承
• • • 什么是继承
    • 子类与父类中不存在成员变量同名的情况
    • 子类与父类中存在成员变量同名的情况
  • super
  • • • super的三种用法
    • this与super有什么区别？
  • 访问修饰限定符
  • • • protected
  • 继承的方式
  • • 多层继承实例
  • final 的用法
  • 继承与组合

OOP语言主要的三大特征：继承 封装 多态

package com.bit.demo1;

 class Animal {
    String name;

     public void eat() {
         System.out.println(this.name + "  Animal eat");
     }
}

class Cat  {
    String name;

    public void eat() {
        System.out.println(this.name + "  Cat eat");
    }
    String colour;
}

public class TestDemo {

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "dawanzi";
        cat.eat();
    }
}

上面这段代码就有点啰嗦，因为两个类里面都有name字段 和 eat方法

于是，就可以使用继承

什么是继承

继承就是进行共性提取，实现代码的复用，从而使代码更加简洁

语法格式：class 子类 extends 父类{

}

class Animal {
    String name;

     public void eat() {
         System.out.println(this.name+"正在吃饭");
     }
    
}

class Cat  extends Animal{
    //此时Cat继承了Animal，Cat是子类，Animal是父类
    //子类也叫派生类  父类也叫超类   基类
    /*String name;

    public void eat() {
        System.out.println(this.name + "  Cat eat");

    }*/
    String colour;
}

public class TestDemo {

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "dawanzi";
        cat.eat();
    }
}

子类继承了父类的什么？

事实上，子类继承了父类除构造方法以外的所有属性

注意：在Java里面使用 extends 只能继承一个父类（单继承）

class Animal {
    String name;
     public void eat() {
         System.out.println(this.name + "  Animal eat");
     }

     private void sleep(){
         System.out.println(this.name + "  Animal sleep");
     }
}

class Cat  extends Animal{
    /*String name;

    public void eat() {
        System.out.println(this.name + "  Cat eat");

    }*/
    
    int colour;
}

public class TestDemo {

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "dawanzi";
        cat.eat();
        cat.sleep();//err，要是将sleep方法改为public，Cat也是可以继承的的，但是sleep是prvate，只能在Animal这个类里面进行访问，所以会报错
    }
}

子类与父类中不存在成员变量同名的情况

class  Base{
    public int  a=1;
    public int b=2;

}
class More extends Base{
    int c=3;
    int d=4;
    public void func(){
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}
public class test {
    public static void main(String[] args) {
        More more = new More();
        more.func();
    }
}

子类与父类中存在成员变量同名的情况

class  Base{
    public int a=1;
    public int b=2;

}
class More extends Base{
    int a=3;
    
    public void func(){
        System.out.println(a);//3
        System.out.println(b);//2
    }
   // public void func(){
   //     System.out.println(this.a);
   //     System.out.println("访问父类的a"+super.a);
   //     System.out.println(b);
   // }
}
public class test {
    public static void main(String[] args) {
        More more = new More();
        more.func();
    }
}
//当子类与父类存在同名的变量名时，会优先调用子类1中的变量
//要是想要访问父类的a就要使用super关键字

super

super指的是子类从父类继承过来的空间的地址

super的三种用法

super.data;

super.funnc();

super.构造方法；

class  Base{
    public int a=1;
    public int b=2;

    public void func1() {
        System.out.println("Base1：");
    }

    public void func2() {
        System.out.println("Base2:");
    }
}
class More extends Base{
    int a=3;

    public void func1(int val) {
        System.out.println("More1:" + val);
    }

    public void func2() {
        System.out.println("More2:");
    }

    public void func(){
        func1();
        func1(10);
        func2();
        //super.func2();就是调用父类的方法
    }
}
public class test {
    public static void main(String[] args) {
        More more = new More();
        more.func();
    }
}
//结果就是Base1：
//Base1：
//More1:10
//More2:

注意：

1、Base的func1和More里面的func1构成了重载，这也说明了 重载不一定要在同一个类里面

2、当方法名一样时，还是优先调用子类自己的方法

3、要调用父类的方法还是直接super.func();

4、super和this都依赖于对象，所以都不能存在于static修饰的方法里面

5、super只能在子类构造方法中出现一次，并且不能与this一起出现

class Animal {
    String name;
    int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println(this.name +"正在吃饭");
    }

}

class Cat  extends Animal{

    String colour;

    public Cat(String name, int age,String colour) {
        super(name, age);//super要放到第一行，先帮助完成父类的构造方法
        //只要光标放在报错的地方，按alt+enter就会自动创建了父类成员变量的super
        this.colour = colour;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", colour='" + colour + '\'' +
                '}';
    }
}

public class Test {

        public static void main(String[] args) {
            Cat cat = new Cat("小乖",12,"yellow");//使用构造方法完成初始化
            System.out.println(cat);//直接调用toString
        }

}

this与super有什么区别？

this的特点：当前对象的引用

1.this(); //调用本类其他的构造方法

2.this.data(); // 访问当前类中的属性

3.this.func(); //调用本类的其他的成员方法

super ：父类对象的引用（必须放到第一行）

1、super(); //调用父类的构造方法

2、super.data(); //访问父类的属性

3、super.func(); //访问父类的成员方法

相同点：

1、都是Java的关键字

2、都只能在非静态方法中使用，用来访问非静态的成员变量和方法，不能出现在static修饰的方法

不同点：

1、this是当前对象的引用，super表示子类从父类中继承的空间的地址

2、在非静态的方法中，this用来访问本类的方法和属性，super是用来访问父类继承下来的方法和属性

3、构造方法中一定会有super（……）的调用，用户不写编译器也会增加，而this（……）不写就没有

小总结：要想使用继承，要想看看父类有没有构造方法，要是没有，就加上extends配合super直接用，要是有构造方法，就用super（……），先帮助父类完成构造方法，再完成子类自己的构造方法

class Animal {
    String name;
    int age;
    static {
        System.out.println("Animal的静态代码块");
    }
    {
        System.out.println("Animal的实例代码块");
    }
    public Animal() {
        System.out.println("Animmal的无参数构造方法");
    }
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void eat() {
        System.out.println(this.name +"正在吃饭");
    }

}

class Cat  extends Animal{

    String colour;
    static {
        System.out.println("Cat的静态代码块");
    }
    {
        System.out.println("Cat的实例代码块");
    }

    public Cat() {
        System.out.println("Cat的无参数构造方法");
    }
    
    public Cat(String name, int age,String colour) {
        super(name, age);
        this.colour = colour;
    }
    public class Test {

    public static void main(String[] args) {
        Cat cat = new Cat();//实例化对象
    	}
    }
    
//Animal的静态代码块
//Cat的静态代码块
//Animal的实例代码块
//Animmal的无参数构造方法
//Cat的实例代码块
//Cat的无参数构造方法

代码运行的顺序是：

父类和子类的静态代码块

父类的实例代码块和构造方法

子类的实例代码块和构造方法

在上面临的代码的基础上，修改main函数为

public static void main(String[] args) {
    Cat cat = new Cat();
    System.out.println("=======================");
    Cat cat1 = new Cat();
}
//输出结果就是
//Animal的静态代码块
//Cat的静态代码块
//Animal的实例代码块
//Animmal的无参数构造方法
//Cat的实例代码块
//Cat的无参数构造方法
//=======================
//Animal的实例代码块
//Animmal的无参数构造方法
//Cat的实例代码块
//Cat的无参数构造方法

在此说明了静态的创建在方法区，只会创建一次

访问修饰限定符

private只能在同一个包的同一个类里面调用

default —>包访问权限 只能在同一个包里面访问

public不进行限制，在不在同一个包，在不在同一个类里面都行

protected

protected叫做受保护的，主要体现在封装上

protected在同一个包的同一个类或者不同的类里面都能访问，在不同的包的子类中也能访问

继承的方式

多层继承实例

class Animal {
    protected String  name;
    public Animal(String name){  //没有返回值说明是构造方法
        this.name = name;
        System.out.println("Animal ");
    }
     public void eat() {
         System.out.println(this.name + "  Animal eat");
     }

     private void sleep(){
         System.out.println(this.name + "  Animal sleep");
     }
}

class Cat  extends Animal{
    public Cat(String name) {
        super(name);
        System.out.println(this.name+"Cat");
    }
}

class ChineseGardenCat extends Cat {

    public ChineseGardenCat(String name) {   //直接alt+enter生成
        super(name);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        ChineseGardenCat chineseGardenCat = new ChineseGardenCat("hhaha");//一层一层往父类上面调
    }
}

但是，多层继承不能无限继承下去，可以使用final来使类不能被继承

final 的用法

final int SIZE=10；//final修饰变量
final class B extends   A  {  //final修饰类，使类不能被继承了
    
}
//final还可以修饰方法

继承与组合

继承是is-a的关系，比如狗是一种动物

组合是has-a 或者 a part of 的关系，比如发动机 玻璃 坐垫都是汽车的一部分

组合就是将一个类的实例作为另一个类的字段

School就包含了Student和Teacher的变量，学生和老师都是学校的一部分，这就是一个组合

// 轮胎类
class Tire{
// ...
}
// 发动机类
class Engine{
// ...
}
// 车载系统类
class VehicleSystem{
// ...
}
class Car{
	private Tire tire; // 可以复用轮胎中的属性和方法
	private Engine engine; // 可以复用发动机中的属性和方法
	private VehicleSystem vs; // 可以复用车载系统中的属性和方法 
// 这就是组合
}
class Benz extend Car{
// 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
}

其实，更加建议使用组合，因为它更加灵活，更简单，更高效