第二章面向对象之继承与抽象

英语单词学习

‎inher‎itanc‎e [ɪnˈherɪtəns] 继承

Extend [ɪnˈherɪtəns] 使伸长; 扩大

Super [ˈsuːpə(r)]

Override [ˌəʊvəˈraɪd] 重写

Overload 重载

Constructor 构造函数

Abstract [ˈæbstrækt] 抽象的

Graduate [ˈɡrædʒuət] 毕业生

继承的概述

什么是继承？

面向对象软件技术当中的一个概念，与多态、封装共为面向对象的三个基本特征。

继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。

继承的特性

子类继承父类，子类可以拥有父类的所有属性（非私有的属性）和（非私有的）方法；
子类可以拥有自己的属性和方法，对父类进行了扩展；
子类也可以实现父类的方法；
java的继承是单继承，一个只能有一个父类（extends）。
注意：继承中，new 创建子类对象的时候是先创建父类对象，先取父类的属性进入内存待下一步使用
缺点：提供了类与类之间耦合，代码之间联系非常紧密，代码独立性比较差，以后修改或替换不容易

1、继承的格式

在继承的关系中“子类就是一个父类”。也就是说，子类可以被当做父亲看待。
例如：父类是员工子类是讲师，那么“讲师就是一个员工” 关系：is(是） - a（一个）

l 定义父类的格式：（一个普通类的定义）

public class 父类名称{

}

l 定义子类的格式：

public class 子类名称 extends 父类名称{

}

第一步：com.ch02.obtk01.Employee(父类)

* 定义一个父类：员工
*/
public class Employee {

    public void method(){
        System.out.println("Employee方法执行！");
    }
}

第二步：定义一个子类Teacher

* 讲师类：员工的子类
*/
public class Teacher extends Employee{
}

第三步：com.ch02.obtk01.Demo01Extends

/**
*
* 在继承的关系中“子类就是一个父类”。也就是说，子类可以被当做父亲看待。
* 例如：父类是员工子类是讲师，那么“讲师就是一个员工” 关系：is(是） - a（一个）
*
* 定义父类的格式：（一个普通类的定义）
* public class 父类名称{
*
* }
* 定义子类的格式：
* public class 子类名称 extends 父类名称{
*
* }
*
*/
public class Demo01Extends {
    public static void main(String[] args){
        Teacher teacher = new Teacher();
        teacher.method();
        System.out.println("===========teacher==============");
        Assistant assistant = new Assistant();
        assistant.method();
        System.out.println("============assistant=============");
    }
}

2、继承中成员变量的访问特点

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

直接通过子类对象访问成员变量：
等号左边是谁，就优先用谁，没有则向上找。
间接通过成员方法访问成员变量
该方法属于谁，就优先用谁，没有则向上找

第一步：定义父类

public class Fu {
    int numFu = 10;
    int num = 100;
    public void methodFu(){
        //使用的是本类当中的，不会向下找子类
        System.out.println("父类中的num:"+num);
    }
}

第二步：定义子类

public class Zi extends Fu{
    int numZi = 20;
    int num = 200;
    public void methodZi(){
        //因为本类当中有num，所以这里用的是本类的num
        System.out.println("子类中的num:"+num);
    }
}

第三步：测试类

/**
* @author fly
* @date 2019-10-30 14:59:43
*在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：
*
* 直接通过子类对象访问成员变量：
*       等号左边是谁，就优先用谁，没有则向上找。
* 间接通过成员方法访问成员变量
*       该方法属于谁，就优先用谁，没有则向上找
*/
public class DemoExtendsField {
    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);//到处都没有，编译会报错
        //这个方法是子类的，优先用子类的，没有再向上找
        zi.methodZi(); //200
        //这个方法是在父类当中定义的，
        zi.methodFu();//100
    }
}

3、区分子类方法中重名的三种变量

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

第一步：创建父类

public class Fu {
    int num = 10;//父类成员变量类中方法外
    public void fuMethod(){
        System.out.println("我是爸爸成员方法.....");
    }

}

第二步：创建子类

public class Zi extends Fu {
    int num = 20; //成员变量

    public void method(){
        int num = 30;   //局部变量
        //获取局部变量   30
        System.out.println(num);
        //获取本类的成员变量 20
        System.out.println(this.num);
        //获取父类的成员变量 10
        System.out.println(super.num);
       // super.fuMethod();//获取父类的成员方法
        //super.yeMethod();
    }
}

第三步： Demo01Test

/**
* @author fly
* @date 2019-10-30 16:14:52
* 局部变量直接写成员变量名
* 本类的成员变量： this.成员变量名
* 父类的成员变量： super.成员变量名
*/
public class Demo01Test {
    public static void main(String[] args){
        Zi zi = new Zi();
        zi.method();
    }
}

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

在父子类的的继承关系中，创建子类对象，访问成员方法的规则：
创建的对象是谁，就优先用谁，如果没有则向上找。

注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类

第一步：创建父类

public class Fu {
    public void method(){
        System.out.println("Fu方法执行了");
    }
    public void methodFu(){
        System.out.println("methodFu方法执行了");
    }
}

第二步：创建子类

public class Zi extends Fu {
    @Override
    public void method(){
        System.out.println("Zi方法执行了");
    }
    public void methodZi(){
        System.out.println("methodFu方法执行了");
    }
}

第三步：DemoTest

/*
* 在父子类的的继承关系中，创建子类对象，访问成员方法的规则：
* 创建的对象是谁，就优先用谁，如果没有则向上找。
*
* 注意事项：
* 无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类
*
* 重写（Override)
* 概念：在继承关系中，方法的名称一样，参数列表也一样。

* 重写（override)：方法的名称一样，参数列表【也一样】覆盖、覆写
* 重载（overload):方法的名称一样，参数列表【不一样】
*
* 方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。
*
*
*/
public class DemoTest {
    public static void main(String[] arg){
        Zi zi = new Zi();
        //创建的是new了子类的对象，所以优先用子类方法
        zi.method();
    }

}

5、继承中方法的覆盖重写_概念与特点

* 重写（Override)
* 概念：在继承关系中，方法的名称一样，参数列表也一样。

*
* 重写（override)：方法的名称一样，参数列表【也一样】覆盖、覆写
* 重载（overload):方法的名称一样，参数列表【不一样】
*
* 方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。

重写特点简单记忆法：修饰符（子大父小）、返回值（子小父大）、方法名（相同）、参数列表（相同）

6、继承中方法的覆盖重写_注意事项

object类

object类是所有java类的根基类，如果在类中没有extends显示的去继承类，默认就继承object类。
创建的任何一个对象都可以使用object提供的方法。
java为什么要设计每个类都继承object类？（因为object类提供了所有类公用的各种方法。）

继承中方法覆盖重写（override)的注意事项：
1、必须保证父子类之间方法的名称相同，参数列相同。
@Override 重写注解写在方法前面，用来检测是不是有效的正确覆盖重写
这个注解就算不写，只要满足要求，也是正确的方法覆盖重写
@Override建议写上

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

小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），
java.lang.String就是Object的子类

3、子类方法的权限（修饰符）必须【大于等于】父类方法的权限修饰符

小扩展提示：public > protected > default > private
default 不是关键字default 而是什么都不写，留空

第一步：父类

public class Fu {
    int age;//默认就是default ====friendly
      Object method(){
        String name = "Object";
        System.out.println("我是爸爸");
        return null;
    }
}

第二步：子类

public class Zi extends Fu{
    @Override   //重写
    public Integer method(){

        System.out.println("我是儿子");
        return null;
    }
}

第三步:创建测试类

/**
* @author fly
* @date 2019-10-31 14:29:43
* 重写（Override)
* * 概念：在继承关系中，方法的名称一样，参数列表也一样。
*
* 继承中方法覆盖重写（override)的注意事项：
* 1、必须保证父子类之间方法的名称相同，参数列相同。
* @Override 重写注解写在方法前面，用来检测是不是有效的正确覆盖重写
* 这个注解就算不写，只要满足要求，也是正确的方法覆盖重写
*             @Override建议写上
*
* 2、子类方法的返回值必须【小于等于】父类方法的返回值范围：返回值：子类小父类大
* 小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），
* java.lang.String就是Object的子类
*
* 3、子类方法的权限必须【大于等于】父类方法的权限修饰符修饰符子类大父类小
*小扩展提示：public > protected > default > private
* default 不是关键字default 而是什么都不写，留空
*/
public class DemoOverride {
    public static void main(String[] args){
    }
}

7、继承中方法的覆盖重写_应用场景

什么情况下我们使用方法重写override?

第一步：老款手机

public class Phone {
    //打电话
    public void call(){
        System.out.println("打电话");
    }
    //发短信
    public void send(){
        System.out.println("发短信");
    }
    //来电显示
    public void show(){
        System.out.println("显示号码");
    }
    //到点报时
    public void alarm(){
        System.out.println("到点报时");
    }
}

第二步：新款手机

public class NewPhone extends Phone {
    //来电显示
    public void show(){
        //System.out.println("显示号码");
        super.show();//把父类的show()方法拿过来重复利用
        //自己子类再来添加更多内容
        System.out.println("显示头像");
        System.out.println("显示姓名");
        System.out.println("显示号码归属地");
    }
    //子类可以有自己的方法设置闹钟
    public void setAlarm(){
        System.out.println("设置闹钟");
    }
}

第三步：测试功能

public class DemoTest {
    public static void main(String[] args) {
        //展示老款手机的功能
        Phone phone = new Phone();
        phone.call();
        phone.send();
        phone.show();
        phone.alarm();
        System.out.println("===============");

        //展示新款手机的功能
        NewPhone newPhone = new NewPhone();
        newPhone.call();
        newPhone.send();
        newPhone.setAlarm();
        newPhone.show();

    }
}

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

* 继承关系中，父子类构造方法的访问特点：
* 1、子类构造方法当中有一个默认隐含的“super()"调用，所以一定是先调用父类构造，
* 后执行子类构造。
*2、子类构造可以通过super关键字来调用父类重载构造
* 3、super的父类构造调用，必须是子类构造方法的第一个语句，不能是一个子类
* 构造调用多次super构造。

第一步：父类

public class Fu {
    public Fu(){

        System.out.println("父类的构造方法");
    }
    public Fu(String str){
        System.out.println("父类的有参构造方法"+str);
    }

}

第二步：子类

public class Zi extends Fu{
    public Zi(){
        super();//默认调用super();
       //super("t167");
        System.out.println("子类的构造函数");

    }
}

第三步：测试类

/**
* @author fly
* @date 2019-10-31 16:34:37
* 继承关系中，父子类构造方法的访问特点：
* 1、子类构造方法当中有一个默认隐含的“super()"调用，所以一定是先调用父类构造，
*    后执行子类构造。
*2、子类构造可以通过super关键字来调用父类重载构造
* 3、super的父类构造调用，必须是子类构造方法的第一个语句，不能是一个子类
*   构造调用多次super构造。
*/
public class Demo01Constructor {
    public static void main(String[] args) {
        Zi zi = new Zi();//先打印父类再打印子类
    }
}

9、super关键字的三种用法

在java类中，使用super关键字来表示引用父类的属性和方法，或者调用父类的构造器
this表示当前对象，super表示父类对象
  super关键字的三种用法：
      1、在子类的成员方法中，访问父类的成员变量 super.属性
      2、在子类的成员方法中，访问父类的成员方法 super.方法（）
      3、在子类的构造方法中，访问父类的构造方法   super(可选参数)

第一步：父类

public class Fu {
    int num = 10;

    public void method(){
        System.out.println("父类的方法");
    }
}

第二步：子类

/**
* @author fly
* @date 2019-10-31 17:19:27
*
* super关键字的三种用法：
* 1、在子类的成员方法中，访问父类的成员变量
* 2、在子类的成员方法中，访问父类的成员方法
* 3、在子类的构造方法中，访问父类的构造方法
*/
public class Zi extends Fu {
    int num = 20;

    public Zi(){
        super();
    }
    public void methodZi(){
        System.out.println(super.num);//父类中的num
    }
    public void method(){
        //访问父类中的method
        super.method();
    }
}

10_this关键字的三种用法 ch02.com.obtk_09

* super关键字用来访问父类内容，而this关键字用来访问本类内容。用法有三种
*
* 1、在本类的成员方法中，访问本类的成员变量
* 2、在本类的成员方法中，访问本类的另一个成员方法 this.method()
* 3、在本类的构造方法中，访问本类的另一个构造方法。 This(3)
*在第三种用法当中要注意：
* A，this(...)调用也必须是构造方法的第一个语句，唯一一个。
* B，super()和this()两种构造调用，不能同时使用

创建父类

public class Fu {
int num = 30;
}

创建子类

/**
* @author fly
* @date 2019-11-04 14:11:42
*
* super关键字用来访问父类内容，而this关键字用来访问本类内容。用法有三种
*
* 1、在本类的成员方法中，访问本类的成员变量
* 2、在本类的成员方法中，访问本类的另一个成员方法
* 3、在本类的构造方法中，访问本类的另一个构造方法。
*在第三种用法当中要注意：
* A，this(...)调用也必须是构造方法的第一个语句，唯一一个。
* B，super和this两种构造调用，不能同时使用
*
* 构造方法：类名方法名相同，没有返回值，连void都没有
*
*
*/
public class Zi extends Fu {
    int num = 20; //成员变量

   public Zi(){
       //super(); 这一行不再赠送
       this(3,2);//本类的无参构造，调用本类的有参构造方法
       //this(3)//错误写法
       System.out.println("zi");

      // this(2);

   }
   public Zi(int n){

   }
   public Zi(int n,int m){
   }

    public void showNum(){
        int num = 10;//局部变量
        System.out.println(num);//局部变量
        System.out.println(this.num);//本类中的成员变量
        System.out.println(super.num);//父类中的成员变量
    }
    public void methodA(){
        System.out.println("AAA");
    }
    public void methodB(){
        methodA();//调用methodA方法
        System.out.println("BBB");
    }
}

11、JAVA继承的三个特点

抽象的概念

1_抽象的概念

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

2_抽象方法和抽象类的格式

* 抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
* 抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可
*
* 如何使用抽象类和抽象方法
* 1、不能直接创建new抽象类对象
* 2、必须用一个子类来继承抽象父类
* 3、子类必须覆盖重写抽象父类当中所有的抽象方法。
* 覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号

创建类：ch02.com.obtk_10.Animal

/**
* @author fly
* @date 2019-11-04 15:11:33
*
* 抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
* 抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可
*
* 如何使用抽象类和抽象方法
* 1、不能直接创建new抽象类对象
* 2、必须用一个子类来继承抽象父类
* 3、子类必须覆盖重写抽象父类当中所有的抽象方法。
*   覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号
*/
public abstract class Animal {
    //这是一个抽象的方法，代表吃东西，但具体吃什么（大括号的内容）不确定
    public abstract void eat();

    //成员方法
    public void normalMethod(){

    }
}

创建类：ch02.com.obtk_10.Animal

* 按：alt+enter idea提醒
*/
public class Cat extends Animal{
    @Override   //检测是否重写不报错，是重写方法
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

创建类：ch02.com.obtk_10.DemoMain

public class DemoMain {
    public static void main(String[] args){
      // Animal animal = new Animal(); 错误写法，不能直接创建抽象类对象
        Cat cat = new Cat();
        cat.eat();
    }
}

3_抽象方法和抽象类的使用(在上一个animal案例上继续)

创建类：ch02.com.obtk_10.DemoMain

ch02.com.obtk_10.Cat

public class Cat extends Animal{
    @Override   //检测是否重写不报错，是重写方法
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

DemoMain

4、抽象方法和抽象类的注意事项

关于抽象类的使用，以下为语法要注意的细节，无需死记硬背。

1、抽象类不能创建对象，如果创建，编译无法通过而报错，只能创建其非抽象子类的对象。

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

2、 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

理解：子类的构造方法中，有默认的super(),需要访问父类构造方法。

3、 抽象类中，不一定包含抽象方法，但是有抽象方法的类必须是抽象类。

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类的对象，通常用于某些特殊的类结构设计。

4、 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则编译无法通过而报错。除非该子类也是抽象类。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法，那么创建对象后，调用抽象的方法，没有意义。

第二点案例演示：抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

public abstract class Fu {
    public Fu(){
        System.out.println("抽象父类的构造方法执行了");
    }
    public abstract void eat();
}

/**
* @author fly
* @date 2019-11-04 16:52:32
* 2、抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
*      理解：子类的构造方法中，有默认的super(),需要访问父类构造方法。
*/
public class Zi extends Fu {
    public Zi(){
        super();//：子类的构造方法中，有默认的super(),需要访问父类构造方法。
        System.out.println("子类构造方法执行了");
    }
    @Override
    public void eat() {
        System.out.println("等待下课。。。。吃肉");
    }
}

第三点案例抽象类中，不一定包含抽象方法，但是有抽象方法的类必须是抽象类。

5、 * 第三点案例
* 一个抽象类不一定含有抽象方法
* 只要保证抽象方法所在的类是抽象类即可
*
* 这样没有抽象方法的抽象类，也不能直接创建对象，
* 在一些特殊场景下有用途：设计模式中的适配器
*/
public abstract class MyAbStract {

}

第四点案例抽象类的子类，必须重写抽象父类中所有的抽象方法，否则编译无法通过而报错。除非该子类也是抽象类。

package ch02.com.obtk_12. Animal

//最高的抽象父类 eat
public abstract class Animal {
public abstract void eat();
public abstract void sleep();//void 没有返回值
}

* 汪星人 alter+enter
*/
public abstract class Dog extends Animal{
    //这个不是抽象方法
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
/*
    @Override
    public void sleep() {

    }*/
}

public class DogGolden extends Dog {   //实现的肯定是抽象方法
    @Override
    public void sleep() {
        System.out.println("叭着睡，打呼呼呼。。。。。");
    }
}

public class Dog2Ha extends Dog {
    @Override
    public void sleep() {
        System.out.println("我是哈巴狗嘿嘿嘿。。。。");
    }
}

DemoMain

*
* 4、抽象类的子类，必须重写抽象父类中所有的抽象方法，否则编译无法通过而报错。除非该子类也是抽象类。
* 理解：假设不重写所有抽象方法，则类中可能包含抽象方法，那么创建对象后，调用抽象的方法，没有意义。
*/
public class DemoMain {
    public static void main(String[] arg){
     //   Animal animal = new Animal() ;//错误的写法
     //   Dog dog = new Dog();错误，这是抽象类

        Dog2Ha ha = new Dog2Ha();//这是普通的类，可以直接new对象堆内存
        ha.eat();
        ha.sleep();
        System.out.println("================");

        DogGolden golden = new DogGolden();
        golden.eat();
        golden.sleep();
    }
}

⑥ toString方法

父类的toString方法就将内存地址转化为类名+hashcode码
重写toString 优先调用子类的toString
java默认规定，如果你输出的对象的变量，默认调用toString，将内存地址转化为字符串输出
java输出内容的时候，输出的：变量.属性、变量.行为，默认不会执行toString

⑦ final关键字

final的本意：不可更改、衡量。
final修饰变量：final int K = 10; 变量的值就不能更改，此刻K变成一个常量。
final修饰类：表示当前类是最终类，当前类不能再做修改或者扩展，当前类不能被任何子类继承。
final修饰方法：代表当前方法不能被修改，该方法不能被重写。

posted @ 2021-04-29 22:07 丰斤豆阅读(102) 评论(0) 收藏举报

刷新页面返回顶部

丰斤豆

第二章 面向对象之继承与抽象

英语单词学习

什么是继承？

继承的特性

1、继承的格式

第一步：com.ch02.obtk01.Employee(父类)

第二步：定义一个子类Teacher

第三步：com.ch02.obtk01.Demo01Extends

2、继承中成员变量的访问特点

第一步：定义父类

第二步：定义子类

第三步：测试类

3、区分子类方法中重名的三种变量

第一步：创建父类

第二步：创建子类

第三步： Demo01Test

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

第一步：创建父类

第二步：创建子类

第三步：DemoTest

5、继承中方法的覆盖重写_概念与特点

6、继承中方法的覆盖重写_注意事项

object类

第一步：父类

第二步：子类

第三步:创建测试类

7、继承中方法的覆盖重写_应用场景

第一步：老款手机

第二步：新款手机

第三步：测试功能

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

第一步：父类

第二步：子类

第三步：测试类

9、super关键字的三种用法

第一步：父类

第二步：子类

10_this关键字的三种用法 ch02.com.obtk_09

创建父类

创建子类

11、JAVA继承的三个特点

抽象的概念

1_抽象的概念

2_抽象方法和抽象类的格式

创建类：ch02.com.obtk_10.Animal

创建类：ch02.com.obtk_10.Animal

创建类：ch02.com.obtk_10.DemoMain

3_抽象方法和抽象类的使用(在上一个animal案例上继续)

创建类：ch02.com.obtk_10.DemoMain

ch02.com.obtk_10.Cat

DemoMain

4、抽象方法和抽象类的注意事项

第二点案例演示：抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

第三点案例 抽象类中，不一定包含抽象方法，但是有抽象方法的类必须是抽象类。

第四点案例抽象类的子类，必须重写抽象父类中所有的抽象方法，否则编译无法通过而报错。除非该子类也是抽象类。

DemoMain

⑥ toString方法

⑦ final关键字

公告

第二章面向对象之继承与抽象

第三点案例抽象类中，不一定包含抽象方法，但是有抽象方法的类必须是抽象类。