0
点赞
收藏
分享

微信扫一扫

java_继承、super、this、抽象类的使用

琛彤麻麻 2022-04-06 阅读 69
java父类子类构造方法


1. 继承

1.1 概述

由来多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要 继承那一个类即可。如图所示：

java_继承、super、this、抽象类的使用_子类

​定义​

  • 继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接 访问父类中的非私有的属性和行为。

好处

  1. 提高代码的复用性。
  2. 类与类之间产生了关系，是多态的前提

1.2 继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 {
     ... 
   }
   
  class 子类 extends 父类 {
      ... 
    }

​继承演示，代码如下​

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

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

}

// 定义了员工的另一个子类：助教
public class Assistant extends Employee {
    
}


// 定义了一个员工的子类：讲师
public class Teacher extends Employee {

}


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

定义父类的格式：（一个普通的类定义）
public class 父类名称 {
    // ...
}

定义子类的格式：
public class 子类名称 extends 父类名称 {
    // ...
}
 */
 //测试类
public class Demo01Extends {

    public static void main(String[] args) {
        // 创建了一个子类对象
        Teacher teacher = new Teacher();
        // Teacher类当中虽然什么都没写，但是会继承来自父类的method方法。
        teacher.method(); //方法执行！

        // 创建另一个子类助教的对象
        Assistant assistant = new Assistant();
        assistant.method(); //方法执行！
    }

}

1.3 继承后的特点——成员变量

当类之间产生了关系后，其中各类中的成员变量，又产生了哪些影响呢？

​成员变量不重名​

如果子类父类中出现​不重名​的成员变量，这时的访问是​没有影响的​。

​成员变量重名​

如果子类父类中出现​重名​的成员变量，这时的访问是​有影响的​。

代码如下：

/**
 * 父类
 */
public class Fu {

    int numFu = 10;

    int num = 100;

    public void methodFu() {
        // 使用的是本类当中的，不会向下找子类的
        System.out.println(num);
    }

}

/**
 * 子类
 */
public class Zi extends Fu {

    int numZi = 20;

    int num = 200;

    public void methodZi() {
        // 因为本类当中有num，所以这里用的是本类的num
        System.out.println(num);
    }

}


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

直接通过子类对象访问成员变量：
    等号左边是谁，就优先用谁，没有则向上找。
间接通过成员方法访问成员变量：
    该方法属于谁，就优先用谁，没有则向上找。
 */
 //测试类
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
    }

}

1.4 继承后的特点——成员方法

当类之间产生了关系，其中各类中的成员方法，又产生了哪些影响呢？

​成员方法不重名​

如果子类父类中出现​不重名​的成员方法，这时的调用是​没有影响的​。对象调用方法时，会先在子类中查找有没有对 应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

​成员方法重名——重写(Override)​

如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做​方法重写​ (Override)。

  • ​方法重写​：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。​声明不变，重新实现​。

代码如下：

/**
 * 父类
 */
public class Fu {

    public void methodFu() {
        System.out.println("父类方法执行！");
    }

    public void method() {
        System.out.println("父类重名方法执行！");
    }

}

/**
 * 子类继承父类
 */
public class Zi extends Fu {

    public void methodZi() {
        System.out.println("子类方法执行！");
    }

    public void method() {
        System.out.println("子类重名方法执行！");
    }

}



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

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

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

重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（Overload）：方法的名称一样，参数列表【不一样】。

方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。
 */
public class Demo01ExtendsMethod {

    public static void main(String[] args) {
            Zi zi = new Zi();
            
            //成员方法不重名
            zi.methodFu();//父类方法执行！（因为继承原因，子类没有的方法，只要父类有子类就可以调用）
            zi.methodZi();//子类方法执行！
            
            //成员方法重名
            // 创建的是new了子类对象，所以优先用子类方法
            zi.method();//子类重名方法执行！（子类方法名称和父类方法名称一样，就会使用到重写）
        }

}

​重写的应用​

java_继承、super、this、抽象类的使用_父类_02

子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从 而进行扩展增强。比如新的手机增加来电显示头像的功能，代码如下：

/**
 * 本来的老款手机（父类）
 */
public class Phone {

    public void call() {
        System.out.println("打电话");
    }

    public void send() {
        System.out.println("发短信");
    }

    public void show() {
        System.out.println("显示号码");
    }

}

/**
 * 定义一个新手机，使用老手机作为父类（子类）
 */
public class NewPhone extends Phone {

    @Override
    public void show() {
        super.show(); // 把父类的show方法拿过来重复利用
        // 自己子类再来添加更多内容
        System.out.println("显示姓名");
        System.out.println("显示头像");
    }
}

/**
 * 测试类
 */
public class Demo01Phone {

    public static void main(String[] args) {
        //老手机的功能
        Phone phone = new Phone();
        phone.call(); //打电话
        phone.send();//发短信
        phone.show();//显示号码
        System.out.println("==========");

        //新手机的功能
        NewPhone newPhone = new NewPhone();
        newPhone.call();//打电话
        newPhone.send();//发短信
        newPhone.show();//显示号码，显示姓名，显示头像
    }

}

小贴士：这里重写时，用到super.父类成员方法，表示调用父类的成员方法。

​注意事项​：

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

  1. 必须保证父子类之间方法的名称相同，参数列表也相同。@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

  2. 子类方法的返回值必须【小于等于】父类方法的返回值范围。小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。

  3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。小扩展提示：public > protected > (default) > private
    备注：(default)不是关键字default，而是什么都不写，留空。

1.5 继承后的特点——构造方法

当类之间产生了关系，其中各类中的构造方法，又产生了哪些影响呢？

首先我们要回忆两个事情，构造方法的定义格式和作用。

  1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
  2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构 造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。代 码如下
/**
 * 父类
 */
public class Fu {

    public Fu() {
        System.out.println("父类无参构造");
    }

    public Fu(int num) {
        System.out.println("父类有参构造！");
    }

}

/**
 * 子类
 */
public class Zi extends Fu {

    public Zi() {
        super(); // 在调用父类无参构造方法
//        super(20); // 在调用父类重载的构造方法
        System.out.println("子类构造方法！");
    }

    public void method() {
//        super(); // 错误写法！只有子类构造方法，才能调用父类构造方法。
    }

}


/*
继承关系中，父子类构造方法的访问特点：

1. 子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。
2. 子类构造可以通过super关键字来调用父类重载构造。
3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
总结：
子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是第一个。
 */
public class Demo01Constructor {

    public static void main(String[] args) {
        /*我只要创建子类对象，无参构造就会被调用，
         又因为子类无参里面有super()所以又调用了父类的无参构造
         并且super必须在构造的第一行*/
        Zi zi = new Zi(); 
        
        //结果打印：
        // 父类无参构造
        //子类构造方法！
    }

}

1.6 super和this

父类空间优先于子类对象产生 在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空 间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构 造方法调用时，一定先调用父类的构造方法。

理解图解如下

java_继承、super、this、抽象类的使用_子类_03

​super和this的含义​

  • super ：代表父类的存储空间标识(可以理解为父亲的引用)。
  • this ：代表当前对象的引用(谁调用就代表谁)。

​super和this的用法​

  1. 访问成员
this.成员变量 ‐‐ 本类的
   super.成员变量 ‐‐ 父类的
  1. 访问成员方法
this.成员方法名() ‐‐ 本类的 
  super.成员方法名() ‐‐ 父类的
  1. 访问构造方法
this(...) ‐‐ 本类的构造方法 
  super(...) ‐‐ 父类的构造方法


子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。 super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。


super 用法演示，代码如下：

/**
 * 父类
 */
public class Fu {

    int num = 10;
    
    public Fu() {
        System.out.println("父类的构造");
    }
    
    public void method() {
        System.out.println("父类方法");
    }

}

/*
super关键字的用法有三种：
1. 在子类的成员方法中，访问父类的成员变量。
2. 在子类的成员方法中，访问父类的成员方法。
3. 在子类的构造方法中，访问父类的构造方法。
 */
public class Zi extends Fu {

    int num = 20;
    
    //访问父类构造方法
    public Zi() {
        super();
    }

    public void methodZi() {
        //访问 父类中的num成员变量
        System.out.println(super.num); 
    }

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

}

/**
 * 测试类
 */
public class Demo01 {
    public static void main(String[] args) {
        Zi z=new Zi();//打印：父类的构造

        //调用子类的方法打印父类的num
        z.methodZi();//10
        
        //调用子类的method方法
        z.method();//打印  父类方法  子类方法

    }
}

super 用法演示，代码如下：

/**
*父类
*/
public class Fu {

    int num = 30;

}


/*
super关键字用来访问父类内容，而this关键字用来访问本类内容。用法也有三种：

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3. 在本类的构造方法中，访问本类的另一个构造方法。
在第三种用法当中要注意：
A. this(...)调用也必须是构造方法的第一个语句，唯一一个。
B. super和this两种构造调用，不能同时使用。
 */
public class Zi extends Fu {

    int num = 20;

    public Zi() {
//        super(); // 这一行不再赠送
        this(123); // 本类的无参构造，调用本类的有参构造
//        this(1, 2); // 错误写法！
    }

    public Zi(int n) {
        this(1, 2);
    }

    public Zi(int n, int m) {
        System.out.println("访问子类构造");
    }

    public void showNum() {
        int num = 10;
        System.out.println(num); // 局部变量 10
        System.out.println(this.num); // 本类中的成员变量 20
        System.out.println(super.num); // 父类中的成员变量 30
    }

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

    public void methodB() {
        this.methodA();
        System.out.println("BBB");
    }

}


/**
 * 测试类
 */
public class Demo01 {
    public static void main(String[] args) {
        //访问构造方法
        Zi z=new Zi();
        //打印：访问子类构造

        //访问成员
        z.showNum();
        //打印：
        //        10
        //        20
        //        30


        //访问成员方法
        z.methodB();
        //打印：
        // AAA
        //BBB

    }
}

1.7 继承的特点

java_继承、super、this、抽象类的使用_java_04

  1. Java只支持单继承，不支持多继承。
//一个类只能有一个父类，不可以有多个父类。 
class C extends A{} //ok （可以）
class C extends A，B... //error（不可以）
  1. Java支持多层继承(继承体系)。
class A{} 
class B extends A{} 
class C extends B{}


顶层父类是Object类。所有的类默认继承Object，作为父类。


  1. 子类和父类是一种相对的概念。

2.抽象类

2.1 概述

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有 意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为​抽象方法​。Java语法规定，包含抽象方法 的类就是​抽象类​。

定义

  • 抽象方法 ： 没有方法体的方法。
  • 抽象类：包含抽象方法的类。

2.2 abstract使用格式

​抽象方法​

使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：

修饰符 abstract 返回值类型 方法名 (参数列表)；

代码举例：代码举例：

public abstract void run()；

​抽象类​

如果一个类包含抽象方法，那么该类必须是抽象类。

定义格式：

abstract class 类名字 {
  
   }

代码举例：

public abstract class Animal { 
    public abstract void run();
   }

​抽象的使用​

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父 类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

代码举例：

/*
抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。

如何使用抽象类和抽象方法：
1. 不能直接创建new抽象类对象。
2. 必须用一个子类来继承抽象父类。
3. 子类必须覆盖重写抽象父类当中所有的抽象方法。
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
4. 创建子类对象进行使用。
 */
public abstract class Animal {

    // 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定。
    public abstract void eat();

    // 这是普通的成员方法
//    public void normalMethod() {
//
//    }

}

/**
 * 继承Animal
 */
public class Cat extends Animal {
    //重写抽象类的的方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

}

/**
 * 测试类
 */
public class DemoMain {

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

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

2.3 注意事项

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

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


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


//抽象类
public abstract class Animal {

    // 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定。
    public abstract void eat();

    // 这是普通的成员方法
//    public void normalMethod() {
//
//    }

}

/**
 * 测试类
 */
public class DemoMain {

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

java_继承、super、this、抽象类的使用_父类_05

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


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


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

}

//实现抽象类的子类
public class Zi extends Fu {

    public Zi() {
        //super();默认可以不写，就会调用父类的抽象类的无参构造
        
         super();//调用父类的抽象类的无参构造
        System.out.println("子类构造方法执行");
    }
    
    //重写了抽象类的方法
    @Override
    public void eat() {
        System.out.println("吃饭饭");
    }
}

/**
 * 测试类
 */
public class DemoMain {

    public static void main(String[] args) {
        Zi zi = new Zi();
        //打印：
        //抽象父类构造方法执行！
        //子类构造方法执行
        
        //调用之类的方法
        zi.eat();//吃饭饭
    }

}
  1. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。


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


/*
一个抽象类不一定含有抽象方法，
只要保证抽象方法所在的类是抽象类，即可。

这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途。
 */
public abstract class MyAbstract {
  //这样不会报错，如果一个类里面写了抽象方法那么那个类一定要变成抽象类
}
  1. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象 类。


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


// 最高的抽象父类
public abstract class Animal {

    public abstract void eat();

    public abstract void sleep();

}

// 子类也是一个抽象类
public abstract class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    // public abstract void sleep();
}
/*
继承Dog类，因为Dog类继承Animal类所以要实现里面的所有方法，
但是Dog也是抽象类所以可以实现所有方法或者不实现方法，
而是由其他类继承Dog类，那个类才会要求被实现所有方法，
因为已经实现了eat()的重写，当有类继承Dog类就只会重写sleep的方法
*/
public class Dog2Ha extends Dog {
    @Override
    public void sleep() {
        System.out.println("嘿嘿嘿……");
    }
}
/*
继承Dog类，因为Dog类继承Animal类所以要实现里面的所有方法，
但是Dog也是抽象类所以可以实现所有方法或者不实现方法，
而是由其他类继承Dog类，那个类才会要求被实现所有方法，
因为已经实现了eat()的重写，当有类继承Dog类就只会重写sleep的方法
*/
public class DogGolden extends Dog {
    @Override
    public void sleep() {
        System.out.println("呼呼呼……");
    }
}

//测试类
public class DemoMain {

    public static void main(String[] args) {
//        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();//呼呼呼……
    }
}

3. 继承的综合案例

3.1 综合案例：群主发普通红包

群主发普通红包。某群有多名成员，群主给成员发普通红包。普通红包的规则：

  1. 群主的一笔金额，从群主余额中扣除，平均分成n等份，让成员领取。
  2. 成员领取红包后，保存到成员余额中。

请根据描述，完成案例中所有类的定义以及指定类之间的继承关系，并完成发红包的操作。

3.2 案例分析

根据描述分析，得出如下继承体系：

java_继承、super、this、抽象类的使用_子类_06

3.3 案例实现

​定义用户类：​

public class User {

    private String name; // 姓名
    private int money; // 余额，也就是当前用户拥有的钱数

    public User() {
    }

    public User(String name, int money) {
        this.name = name;
        this.money = money;
    }

    // 展示一下当前用户有多少钱
    public void show() {
        System.out.println("我叫：" + name + "，我有多少钱：" + money);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

​定义群主类：​

/ 群主的类
public class Manager extends User {

    public Manager() {
    }

    public Manager(String name, int money) {
        super(name, money);//调用父类的构造方法吧值传递过去
    }

    public ArrayList<Integer> send(int totalMoney, int count) {
        // 首先需要一个集合，用来存储若干个红包的金额
        ArrayList<Integer> redList = new ArrayList<Integer>();

        // 首先看一下群主自己有多少钱
        int leftMoney = super.getMoney(); // 群主当前余额
        if (totalMoney > leftMoney) {
            System.out.println("余额不足");
            return redList; // 返回空集合
        }

        // 扣钱，其实就是重新设置余额
        super.setMoney(leftMoney - totalMoney);

        // 发红包需要平均拆分成为count份
        int avg = totalMoney / count;
        int mod = totalMoney % count; // 余数，也就是甩下的零头

        // 除不开的零头，包在最后一个红包当中
        // 下面把红包一个一个放到集合当中
        for (int i = 0; i < count - 1; i++) {
            redList.add(avg);
        }

        // 最后一个红包
        int last = avg + mod;
        redList.add(last);

        return redList;
    }
}

​定义成员类：​

public class Member extends User {
    public Member(){

    }

    public Member(String name, int money) {
        super(name, money);
    }

    public void receive(ArrayList<Integer> list){
        //从多个红包当中随便获取一个红包给自己
        //获取随机集合的索引值
        int index= new Random().nextInt(list.size());
        //根据索引，从集合当中删除，并且获取删除的红包值，给自己
        int delta=list.remove(index);
        //当前成员自己本来有多少钱；
        int money=super.getMoney();
        //加法，并且重新设置回去
        super.setMoney(money+delta);
    }
}

​定义测试类：​

public class MainRedPacket {

    public static void main(String[] args) {
        Manager manager = new Manager("群主", 100);

        Member one = new Member("成员A", 0);
        Member two = new Member("成员B", 0);
        Member three = new Member("成员C", 0);

        manager.show(); // 100
        one.show(); // 0
        two.show(); // 0
        three.show(); // 0
        System.out.println("===============");

        // 群主总共发20块钱，分成3个红包
        ArrayList<Integer> redList = manager.send(20, 3);
        // 三个普通成员收红包
        one.receive(redList);
        two.receive(redList);
        three.receive(redList);

        //查看群主和成员的余额情况
        manager.show(); // 100-20=80
        // 6、6、8，随机分给三个人
        one.show();
        two.show();
        three.show();
    }

}

运行结果：

java_继承、super、this、抽象类的使用_构造方法_07

课后请同学自己思考并完成扩展需求。

案例扩展：

  1. 如果成员的余额不为0呢，将如何处理？
  2. 如果群主想输入带小数的金额呢，将如何处理？


举报

相关推荐

java_抽象类

java

Java_接口&抽象类

抽象类JAVA值类型Python后端开发

java_抽象类实例:员工工作

构造方法成员变量构造函数Java编程语言

第八天:继承、super与this、抽象类

JAVA基础

【Java】抽象类&继承的综合案例

java抽象方法抽象类子类编程语言

Java抽象类 Java接口 抽象类和接口使用区别： activity 深度继承关系

Android抽象类抽象方法实例化系统/运维

抽象类接口继承

开发工具java构造器子类实体类Python后端开发

Java抽象类的使用

SystembcJavaScript前端开发

继承、多态和抽象类

多态父类javaJava编程语言

继承，多态，抽象类，接口

System父类子类Java后端开发
0 条评论