10-继承&抽象类

1. 继承

1.1 继承的实现

继承的概念
- 继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法
实现继承的格式
- 继承通过extends实现
- 格式：class 子类 extends 父类 { }
- 举例：class Dog extends Animal { }
继承带来的好处
- 继承可以让类与类之间产生子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。

示例代码

public class Fu {
  public void show() {
      System.out.println("show方法被调用");
  }
}
public class Zi extends Fu {
  public void method() {
      System.out.println("method方法被调用");
  }
}
public class Demo {
  public static void main(String[] args) {
      //创建对象，调用方法
      Fu f = new Fu();
      f.show();

      Zi z = new Zi();
      z.method();
      z.show();
  }
}

1.2 继承的好处和弊端

继承好处
- 提高了代码的复用性(多个类相同的成员可以放到同一个类中)
- 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
继承弊端
- 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
继承的应用场景：
- 使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承
- is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类
- 避免为了使用类的某个功能而去继承该类。

1.3. Java中继承的特点

Java中继承的特点
1. Java中类只支持单继承，不支持多继承。避免多继承产生的调用不明确。
  - 错误范例：class A extends B, C { }
2. Java中类支持多层继承

多层继承示例代码：

public class Granddad {

  public void drink() {
      System.out.println("爷爷爱喝酒");
  }

}

public class Father extends Granddad {

  public void smoke() {
      System.out.println("爸爸爱抽烟");
  }

}

public class Mother {

  public void dance() {
      System.out.println("妈妈爱跳舞");
  }

}
public class Son extends Father {
// 此时，Son类中就同时拥有drink方法以及smoke方法
}

2. 继承中的成员访问特点

2.1 继承中变量的访问特点

在子类方法中访问一个变量，采用的是就近原则。

子类局部范围找
子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)

示例代码

class Fu {
  int num = 10;
}
class Zi extends Fu {
  int num = 20;
  public void show(){
      int num = 30;
      System.out.println(num);
  }
}
public class Demo1 {
  public static void main(String[] args) {
      Zi z = new Zi();
      z.show(); // 输出show方法中的局部变量30
  }
}

2.2 super

this&super关键字：
- this：代表本类对象的引用
- super：代表父类存储空间的标识(可以理解为父类对象引用)
this和super的使用分别
- 成员变量：
- this.成员变量 - 访问本类成员变量
- super.成员变量 - 访问父类成员变量
- 成员方法：
- this.成员方法 - 访问本类成员方法
- super.成员方法 - 访问父类成员方法
构造方法：
- this(参数) - 根据参数的匹配访问本类构造方法
- super(参数) - 根据参数的匹配访问父类构造方法

2.3 继承中构造方法的访问特点

注意：子类中所有的构造方法默认都会访问父类中无参的构造方法

子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()

问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

1. 通过使用super关键字去显示的调用父类的带参构造方法
2. 子类通过this去调用本类的其他构造方法,本类其他构造方法再通过super去调用父类的带参的构造方法

注意: this(…)super(…) 必须放在构造方法的第一行有效语句，并且二者不能共存

继承中，构造方法是不存在继承的概念的。但是可以使用super关键字访问父类的构造；而且也必须去访问，因为要保证父类的数据优先初始化。

2.4 继承中成员方法的访问特点

通过子类对象访问一个方法

子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)

2.5 super内存图

对象在堆内存中，会单独存在一块super区域，用来存放父类的数据

file

2.6 方法重写

1、方法重写概念
- 子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
2、方法重写的应用场景
- 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
3、Override注解
- 用来检测当前的方法，是否是重写的方法，起到【校验】的作用

2.7 方法重写的注意事项

方法重写的注意事项

私有方法不能被重写(父类私有成员子类是不能继承的)
子类方法访问权限不能更低(public > 默认 > 私有)
静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法

示例代码

public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }

    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}

public class Zi extends Fu {

    /* 编译【出错】，子类不能重写父类私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }

    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }

    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

2.8 权限修饰符

file

2.9 static

static 关键字是一个修饰符，表示静态的。用来声明同一类对象的共享资源。

static修饰的成员特点：

1、随着类的加载而加载，优先于对象存在。静态成员也只初始化一次。

2、被static修饰的成员属于类，被类的所有对象所共享。所以，类名.调用静态成员

下面从static的使用场景分别解释：

1、静态成员变量

public class Student {
    // 静态成员变量
    public static String schoolName;

    // 非静态成员变量
    private String name;
    private int age;
}

static 关键字修饰成员变量，这样的成员变量称为静态成员变量，或类变量。

静态成员变量是属于类的，也就是说，该成员变量并不属于某个对象，即使有多个该类的对象实例，静态成员变量也只有一个。只要静态成员变量所在的类被加载，这个静态成员变量就会被分配内存空间。

因此，访问静态成员变量时，通常采用“类名 . 静态变量名”的方式，当然，也可以通过“对象名 . 静态变量名”的方式，但是不建议。

2、静态成员方法

public class Student {
    public static String schoolName;

    // 静态成员方法
    public static String getSchoolName() {
        return Student.schoolName;
    }
}

与静态成员变量类似，静态成员方法是类方法，它属于类本身而不属于某个对象。

因此静态成员方法不需要创建对象就可以被调用，而非静态成员方法则需要通过对象来调用。

注意：

在静态成员方法中不能使用 this、super 关键字，也不能调用非静态成员方法，同时不能引用非静态成员变量。

3、静态代码块

public class Student {
    public static String schoolName;

    // 静态代码块
    static {
        Student.schoolName = "海牛小学";
    }
}

static 代码块又称为静态代码块。它是在类中独立于成员方法的代码块。

静态代码块不需要程序主动调用，随着类的加载而执行，因此在静态代码块中通常可以做一些初始化工作。

4、静态内部类（后续课程中讲解）

在 Java 中还支持用 static 修饰的内部类，称为静态内部类。

3.抽象类

3.1抽象类的概述

当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！

3.2抽象类的特点

抽象类和抽象方法必须使用 abstract 关键字修饰

//抽象类的定义
public abstract class 类名 {}

//抽象方法的定义
public abstract void eat();

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类不能实例化
抽象类可以有构造方法
抽象类的子类

要么重写抽象类中的所有抽象方法

要么是抽象类

3.3抽象类的案例

案例需求

定义猫类(Cat)和狗类(Dog)

猫类成员方法：eat（猫吃鱼）drink（喝水…）

狗类成员方法：eat（狗吃肉）drink（喝水…）
实现步骤
1. 猫类和狗类中存在共性内容，应向上抽取出一个动物类（Animal）
2. 父类Animal中，无法将 eat 方法具体实现描述清楚，所以定义为抽象方法
3. 抽象方法需要存活在抽象类中，将Animal定义为抽象类
4. 让 Cat 和 Dog 分别继承 Animal，重写eat方法
5. 测试类中创建 Cat 和 Dog 对象，调用方法测试

代码实现

动物类

public abstract class Animal {
  public void drink(){
      System.out.println("喝水");
  }

  public Animal(){}
// 抽象方法
  public abstract void eat();
}

猫类

public class Cat extends Animal {
  @Override
  public void eat() {
      System.out.println("猫吃鱼");
  }
}

狗类

public class Dog extends Animal {
  @Override
  public void eat() {
      System.out.println("狗吃肉");
  }
}

测试类

public static void main(String[] args) {
  Dog d = new Dog();
  d.eat();
  d.drink();

  Cat c = new Cat();
  c.drink();
  c.eat();

  //Animal a = new Animal();
  //a.eat();
}

3.5 final

fianl关键字的作用
- final代表最终的意思，可以修饰成员方法，成员变量，类
final修饰类、方法、变量的效果
- fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
- final修饰方法：该方法不能被重写
- final修饰变量：表明该变量是一个常量，不能再次赋值
- 变量是基本类型,不能改变的是值
- 变量是引用类型,不能改变的是地址值,但地址里面的内容是可以改变的
- 举例
```
public static void main(String[] args){
  final Student s = new Student(23);
    s = new Student(24);  // 错误
s.setAge(24);  // 正确
}
```

4.代码块

4.1代码块概述

在Java中，使用 { } 括起来的代码被称为代码块

4.2代码块分类

局部代码块

位置: 方法中定义
作用: 限定变量的生命周期，及早释放，提高内存利用率
示例代码

public class Test {
    /*
        局部代码块
            位置：方法中定义
            作用：限定变量的生命周期，及早释放，提高内存利用率
     */
    public static void main(String[] args) {
        {
            int a = 10;
            System.out.println(a);
        }

       // System.out.println(a);
    }
}

构造代码块

位置: 类中方法外定义
特点: 每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行
作用: 将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性
示例代码

public class Test {
    /*
        构造代码块:
            位置：类中方法外定义
            特点：每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行
            作用：将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性
     */
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student(10);
    }
}

class Student {

    {
        System.out.println("好好学习");
    }

    public Student(){
        System.out.println("空参数构造方法");
    }

    public Student(int a){
        System.out.println("带参数构造方法...........");
    }
}

静态代码块

位置: 类中方法外定义
特点: 需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
作用: 在类加载的时候做一些数据初始化的操作
示例代码

public class Test {
    /*
        静态代码块:
            位置：类中方法外定义
            特点：需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
            作用：在类加载的时候做一些数据初始化的操作
     */
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person(10);
    }
}

class Person {
    static {
        System.out.println("我是静态代码块, 我执行了");
    }

    public Person(){
        System.out.println("我是Person类的空参数构造方法");
    }

    public Person(int a){
        System.out.println("我是Person类的带...........参数构造方法");
    }
}

1. 继承

1.1 继承的实现

1.2 继承的好处和弊端

1.3. Java中继承的特点

2. 继承中的成员访问特点

2.1 继承中变量的访问特点

2.2 super

2.3 继承中构造方法的访问特点

2.4 继承中成员方法的访问特点

2.5 super内存图

2.6 方法重写

2.7 方法重写的注意事项

2.8 权限修饰符

2.9 static

3.抽象类

3.1抽象类的概述

3.2抽象类的特点

3.3抽象类的案例

3.5 final

4.代码块

4.1代码块概述

4.2代码块分类

作者：阿布都的都

阿布都的都的其他话题

分类下其他主题

随机推荐话题

10-继承&抽象类

1. 继承

1.1 继承的实现

1.2 继承的好处和弊端

1.3. Java中继承的特点

2. 继承中的成员访问特点

2.1 继承中变量的访问特点

2.2 super

2.3 继承中构造方法的访问特点

2.4 继承中成员方法的访问特点

2.5 super内存图

2.6 方法重写

2.7 方法重写的注意事项

2.8 权限修饰符

2.9 static

3.抽象类

3.1抽象类的概述

3.2抽象类的特点

3.3抽象类的案例

3.5 final

4.代码块

4.1代码块概述

4.2代码块分类

添加附言

作者：阿布都的都

阿布都的都 的其他话题

分类下其他主题

随机推荐话题

阿布都的都的其他话题