继承、抽象类、模板设计模式、_nal关键字
2024-05-16 08:06:47
继承、抽象类、模板设计模式、final关键字
今日内容介绍
1. 面向对象基础知识回顾* 如何定义类public class Student{}* 如何创建类的对象Student s = new Student();* 构造方法* this关键字 区分成员变量和局部变量* 匿名对象 new Student().();
2. 面向对象第二大特征——继承* 继承的概念和作用(好处) 简化代码，对父类进行增强；* 继承的格式 public class Test extends Student{}* 继承后的特点(成员变量、成员方法、构造方法)* 方法覆盖重写 存在继承或者实现关系；default* super关键字和this关键字 super代表父类，子类代表本类* 继承的特点 java只允许单继承 子类即父类 允许多级继承
3. 抽象类* 抽象的概念 * 抽象类的使用 * 抽象类的特征* 抽象类的注意事项* 抽象类存在的意义——模板设计模式
4. final关键字 * final关键字的特点* final关键字的使用* 修饰类* 修饰方法* 修饰变量(局部变量<基本类型、引用类型>、成员变量)
- 掌握继承的格式
- 通过代码测试（继承后成员变量、成员方法、构造方法的特点）
学习目标
* 能够写出类的继承格式public class Fu{}public class Zi extends Fu{}* 能够说出继承的特点Java只允许单继承(一个儿子只有一个亲爹)Java允许多级继承一个父类可以有多个子类(一个爸爸可以有多个亲儿子)子类就是父类Object是所有类的顶层父类* 能够说出子类调用父类的成员特点不重名：根据变量名来识别调用的父类还是子类的 重名：默认访问子类自己的，也可以通过super.变量名称来明确指定访问父类的成员变量* 能够说出方法重写的概念1. 存在于2个类中，而且这2个类存在继承或者实现关系2. 方法签名必须完全一致，除了访问权限修饰符(子类的范围不得低于父类)好处：可以对父类的方法进行增强* 能够说出this可以解决的问题成员变量与局部变量重名，导致局部变量隐藏成员变量，造成为成员变量赋值失败的问题！* 能够说出super可以解决的问题父子类重名的成员变量和成员方法，默认访问的是子类的，可以通过super来指定访问父类的* 能够描述抽象方法的概念没有方法体的方法就是抽象方法* 能够写出抽象类的格式public abstarct class 类名{}* 能够写出抽象方法的格式public abstract 返回值数据类型 方法名称(参数列表);* 能够说出父类抽象方法的存在意义供子类去覆盖重写，用于模板设计模式* 能够描述final修饰的类的特点这个类不能被继承* 能够描述final修饰的方法的特点方法不能被覆盖重写* 能够描述final修饰的变量的特点修饰成员变量： 它就是常量，必须初始化，不能二次赋值！修饰局部变量：基本类型：不能二次赋值！引用类型：不能修改地址值，但是可以修改里面的数据
一、面向对象回顾
* 如何定义类
* 如何创建类的对象
* 构造方法
* this关键字
* 匿名对象
1.1如何定义类
public class 类名{// 成员变量// 成员方法// 构造方法// 代码块 {java代码}// 静态代码块 static{java代码}
}
* 说明：代码块和静态代码块是在后续课程中学习！
例如：
/*类的定义类中可以出现的内容：* 成员变量* 成员方法* 构造方法* 代码块 {java代码}* 静态代码块 static{java代码}封装的步骤：1. 将要封装的内容使用private修饰2. 提供public修饰的方法对private修饰的内容进行处理，以供外界访问如何调用本类中重载的其它构造方法？this(); // 你要调用哪个重载的构造方法，那么就在小括号中书写对应的参数！*/
public class Student {// 成员变量(使用private修饰)private String name; // 姓名private int age; // 年龄// getter and setterpublic void setName(String name){// this.name是一个成员变量，等号右侧的name是一个局部变量！this.name = name;}public String getName(){return name;}public void setAge(int age){this.age = age;}public int getAge(){return age;}// 成员方法(一般使用public修饰)public void show(){// 局部变量没有与成员变量重名，那么可以直接写成员变量名称，省略thisSystem.out.println("姓名:" + this.name + ", 年龄："+ age);}// 方法之间可以相互调用！public void method(){show();}// 构造方法(一般使用public修饰)public Student(){System.out.println("无参构造方法被执行了！");}public Student(String name){System.out.println(name);}// 重载的满参构造方法public Student(String name,int age){// 可以使用this来调用重载的构造方法this();//this("jack");this.name = name;this.age = age;}}
测试类：
/*测试类：* 类的对象创建：格式： 类名 对象名称 = new 类名(); // 类是对象的数据类型！构造方法：在类中没有提供任何构造方法，那么系统会自动赠送一个无参构造方法！是在创建对象的时候，由JVM负责调用的！一旦提供了构造方法，那么系统将不再赠送无参构造方法！【建议：以后在定义类的时候，请手动提供一个无参构造方法】* 构造方法的作用：1. 创建对象！(针对无参构造方法)2. 为成员变量赋值！(针对的满参构造方法)*/
public class StudentDemo {public static void main(String[] args) {// 创建学生类的对象/*Student student = new Student();System.out.println(student);// 为成员变量赋值student.setName("鲁班七号");student.setAge(40);System.out.println(student.getName()+", "+ student.getAge());System.out.println("=====================");student.show();System.out.println("=====================");*/// 使用满参构造方法创建对象Student student1 = new Student("不知火舞",18); // 有名称的对象！【多次使用的都是同一个对象】student1.show();student1.show();student1.show();student1.show();student1.show();System.out.println("==================");new Student("虞姬",18).show(); // 匿名对象！【只能使用一次！多次使用的不是同一个对象！】new Student("虞姬",18).show();}}
二、继承
2.1 Java中继承的举例
注意：上图推出的继承的特点！
2.2 继承的格式
// 父类
public class Fu{// 成员变量// 成员方法// 构造方法
}// 子类
public class Zi extends Fu{// 成员变量// 成员方法// 构造方法
}
演示：
/*父类！*/
public class Fu {// 定义成员变量private int number = 10;// 定义成员方法public void show(){System.out.println("number:"+ number);}}
/*子类： 通过extends关键字来建立Fu与Zi的继承关系！*/
public class Zi extends Fu {}
/*测试类*/
public class Test {public static void main(String[] args) {// 创建子类对象Zi zi = new Zi();// 调用方法zi.show(); // 从父类继承过来的！}}
2.3 子类无法从父类继承的内容
子类无法继承父类被private修饰的内容(成员变量)！但是可以使用父类提供方法(getter and setter)
/*父类！*/
public class Fu {// 定义成员变量private int number = 10;// 定义方法public void setNumber(int number){this.number = number;}public int getNumber(){return number;}// 定义成员方法public void show(){System.out.println("number:"+ number);}}
/*子类： 通过extends关键字来建立Fu与Zi的继承关系！*/
public class Zi extends Fu {}
/*测试类*/
public class Test {public static void main(String[] args) {// 创建子类对象Zi zi = new Zi();// 调用方法zi.show(); // 从父类继承过来的！// 子类没有成员变量number，但是父类有，我们使用从父类继承过来的成员变量！// zi.number= 100; // 子类不能继承父类被private修饰的内容(成员变量)zi.setNumber(100);System.out.println(zi.getNumber());}}
2.4 继承之后子类的特点(成员变量)
* 子类与父类的成员变量不重名在访问的时候，通过不同的变量名称来区分访问的是父类继承过来的，还是子类自己独有的！
* 子类与父类的成员变量重名 默认访问的是子类自己的重名成员变量访问父类的成员变量(与子类重名的成员变量)super.重名的成员变量名称
演示：
/*父类*/
public class Fu {// 定义成员变量int number = 10;}
/*子类*/
public class Zi extends Fu{// 子类独有的成员变量int count = 5;// 子类与父类重名的成员变量int number = 200;// 成员方法public void show(){// 子类没有定义成员变量number，那么sout(number)访问的是父类的成员变量！// 子类定义了与父类重名的成员变量，sout(number)访问的是子类的！System.out.println("访问子类的number:"+ this.number);// 通过supper访问父类重名的成员变量！System.out.println("访问父类的number:"+ super.number);}
}
/*测试类*/
public class Test {public static void main(String[] args) {// 创建子类对象Zi zi = new Zi();zi.show();}
}
2.5 继承之后子类的特点(成员方法)
* 子类与父类的成员方法未重名通过你调用的方法名称来区分：* 是从父类继承过来的成员方法* 还是子类独有的成员方法
* 子类与父类的成员方法重名默认调用的是子类与父类重名的成员方法* this.重名的成员方法() 调用的依旧是子类！* supper.重名的成员方法() 调用的是父类！
演示：
/*父类*/
public class Fu {// 定义成员方法public void fuMethod(){System.out.println("父类的成员方法执行了。。。");}}
/*子类*/
public class Zi extends Fu {// 子类独有的成员public void ziMethod(){System.out.println("子类独有的成员方法执行了。。。");}// 子类与父类重名的方法public void fuMethod(){System.out.println("子类与父类重名的成员方法执行了。。。");}public void show(){// 调用子类独有的成员方法ziMethod();// 若子类没有提供fuMethod，那么调用fuMethod调用的是从父类继承过来的！// 子类提供了fuMethod方法，调用子类与父类重名的方法//fuMethod();this.fuMethod();// 调用父类与子类重名的方法super.fuMethod();}
}
/*测试类*/
public class Test {public static void main(String[] args) {// 创建子类对象Zi zi = new Zi();// 调用子类与父类重名的成员方法zi.show();}
}
2.6 继承之后子类特点(成员方法—方法覆盖重写)
回忆基础班学习的方法重载Overload
* 有三个条件：① 多个方法在同一个类中！② 多个方法的方法名称完全一致！③ 多个方法的参数列表不同！(参数的个数，类型)
方法覆盖重写Override
* 有两个条件：① 存在于多个类(接口)中，多个类要有继承或者实现关系！② 多个类中的方法签名得完全一致！(除了访问权限修饰符以外<子类的访问权限不得低于父类>)访问权限修饰符(范围从大到小)：public protected default privatedefault：在定义方法的时候没有写任何的权限修饰符！【注意：：不是写default】* 为了让我们在子类中成功的覆盖重写父类的方法，JDK提供了一个注解@Override 注解：它与注释不同！(注释是给人看的，不参与程序的执行；注解是给机器看的，参与程序的执行！)不同的注解，其功能也不一样！【我们可以通过自定义注解来指定注解的具体功能】@Override注解是JDK提供的，其功能已经注定了！在编译阶段对方法进行语法检查(一旦不符合方法覆盖重写的要求就会报错！)
演示：
/*父类*/
public class Fu {// 定义成员方法public void show(){System.out.println("小鲁班腿很短。。。");}}
/*子类*/
public class Zi extends Fu {// 覆盖重写父类的方法@Overridepublic void show(){//System.out.println("小鲁班腿很短。。。");super.show(); // 功能等价于上面的那行代码！// 对父类的方法进行增强(在父类这个方法里面添加的额外的功能代码)！System.out.println("但是它的走位很骚。。。");}}
/*测试类*/
public class Test {public static void main(String[] args) {// 创建子类对象Zi zi = new Zi();zi.show();}
}
方法的覆盖重写有好处： 可以对父类的方法进行增强！
2.7 继承之后子类的特点(构造方法)
* 子类不能继承父类的构造方法！
* 在子类的构造方法中的第一行，都默认去调用了父类的无参构造方法！可以在子类的构造方法里面，使用super(实参)来调用父类指定的带参构造方法！
/*父类*/
public class Fu {String fu = "父类成员变量";// 父类的无参构造方法public Fu(){System.out.println("父类的无参构造方法执行了。。。");}public Fu(String fu){this.fu = fu;}}
/*子类*/
public class Zi extends Fu {String zi;// 子类的无参构造方法public Zi(){// 默认在此处(第一行)去调用了父类的无参构造方法super(); // 写不写都一样！System.out.println("子类的无参构造方法执行了。。。");}// 子类的带参构造方法public Zi(String zi){// 通过参数类指定，调用父类的哪种构造方法！super(zi);this.zi = zi;System.out.println("子类的带参构造方法执行了。。。");}}
/*测试类*/
public class Test {public static void main(String[] args) {// 创建子类对象Zi zi = new Zi("子类的成员变量！");}
}
2.8 super和this小结
* 基本使用：① this: 区分重名的成员变量和局部变量！代表的是本类的对象！谁调用当前这个方法，那么这个方法中的this就代表谁成员变量：this.成员变量名称成员方法：this.成员方法名称(实参)构造方法：this(实参); ② supper:代表父类！区分父类与子类重名的内容(成员变量、成员方法)与构造方法父类成员变量：super.成员变量名称父类成员方法：super.成员方法名称(实参);父类构造方法：super(实参);
演示：
/*父类*/
public class Fu {// 成员变量int number = 10;// 成员方法public void method(){System.out.println("父类成员方法执行了。。。");}// 构造方法public Fu(){System.out.println("父类无参构造方法执行了。。。");}}
/*子类*/
public class Zi extends Fu {// 成员变量int number = 20;// 成员方法public void method() {System.out.println("子类的成员方法执行了。。。");}// 构造方法public Zi() {// 默认要调用父类的无参构造方法！super();System.out.println("子类的无参构造方法执行了。。。");System.out.println("子类：" + this.number); // 调用子类的成员变量System.out.println("父类：" + super.number); // 调用父类的成员变量System.out.println("=============");this.method(); // 调用子类的成员方法super.method(); // 调用父类的成员方法}public Zi(int number) {// 调用本类的无参构造方法this();this.number = number;System.out.println(this.number);}}
/*测试类*/
public class Test {public static void main(String[] args) {// 创建子类对象Zi zi = new Zi(100);}
}
2.9 super内存图
public class Person extends Object{private String name;private int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public Person(){}public Person(String name, int age) {this.name = name;this.age = age;}}
public class Student extends Person{// 子类从父类继承了2个成员变量 name agepublic Student(){}public Student(String name, int age) {// 由于父类没有提供无参构造方法，所以这里必须调用父类的带参构造！【创建子类对象，必定先要创建父类对象！】super(name, age); // 调用父类的带参构造方法，创建父类对象！【为父类的成员变量赋值！】}}
public class Test {public static void main(String[] args) {// 创建子类对象/*Student student = new Student("jack", 38);System.out.println(student.name + ", " + student.age);*/Student student = new Student();student.setName("jack");}}
在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造器调用时，一定先调用父类的构造器。
2.10 继承的特点以及好处总结
★ 特点：
* 一个父类可以拥有多个子类！【爸爸可以有多个亲生儿子】public class A extends B{}public class C extends B{}* 一个子类只能拥有一个直接父类！【儿子只能有1个亲爹】=====>>> 单继承！public class A extends B{}public class A extends B,C{} // 错误！！！ 【不允许多继承！】* Java允许多级继承！public class A extends B{} public class B extends C{}* Java顶层父类是Object任何一个类没有明确去继承Object,其实已经默认继承了！！！★ 好处：
* 在子类中对父类的方法进行增强！【方法的覆盖重写】
* 简化代码，提高开发效率！【共性抽取到父类！】* 继承也有局限性：占用了继承位(置) 【java是单继承的！】public class A extends B{// 重写B类中的方法进行增强！ }
三、抽象类
3.1 抽象类图解
3.2 抽象类和抽象方法的定义
* 抽象类public abstract class 类名{}* 抽象方法public abstract void eat(); // 没有方法体！① 一个类中有抽象方法，那么这个类必定是一个抽象类！
② 抽象类中可以没有抽象方法！
③ 抽象类不能被实例化对象！但是它有构造方法！【供子类去继承，重写！】
演示：
/*抽象类和抽象方法的定义*/
public abstract class Animal {// 抽象类中可以没有抽象方法！public void show(){}// 抽象方法public abstract void eat();public Animal(){}}
/*测试类*/
public class Test {public static void main(String[] args) {// 创建类的对象// Animal animal = new Animal(); // 抽象类不能实例化对象！}
}
3.3 抽象类的使用
供子类继承重写！
/*抽象类和抽象方法的定义*/
public abstract class Animal {// 抽象类中可以没有抽象方法！public void show(){System.out.println("显示方法！");}// 抽象方法public abstract void eat();// 构造方法public Animal(){}}
/*抽象父类存在抽象方法，子类必须重写父类的抽象方法！*/
public class Cat extends Animal {@Overridepublic void eat() {System.out.println("喵星人吃鱼！");}// 独有功能！public void catchMouse(){System.out.println("猫抓老鼠！");}
}
/*抽象父类存在抽象方法，子类必须重写父类的抽象方法！*/
public class Dog extends Animal {@Overridepublic void eat() {System.out.println("汪星人吃骨头");}// 独有功能public void watchHouse(){System.out.println("狗看家！");}}
/*测试类*/
public class Test {public static void main(String[] args) {// 创建类的对象// Animal animal = new Animal(); // 抽象类不能实例化对象！Cat cat = new Cat();cat.eat();cat.show();cat.catchMouse();}
}
3.4 抽象类的特征
* 有得有失！有得：抽象类得到了拥有抽象方法的能力。有失：抽象类失去了创建对象的能力。
* 抽象类允许有：成员方法(非抽象方法)、抽象方法、构造方法、静态方法、成员变量！
3.5 抽象类的注意事项
* 抽象类不能被创建对象！假设能实例化对象，那么就可以拿着对象去调用方法(抽象方法)，这是不行的！【抽象方法没有方法体！】* 一个抽象类中可以没有抽象方法！被子类继承直接使用！* 一个类中如果有抽象方法，那么这个类必定是一个抽象类！不让调用抽象法方法(不提供类的对象，抽象类不能创建对象！)* 抽象类可以有构造方法的 在创建子类对象的时候为抽象父类的成员变量赋值！【查看demo12包下的代码！】* 抽象父类有抽象方法，子类必须重写所有的抽象方法！子类创建对象之后，调用抽象法就有问题了！* 抽象类存在的意义===========>>>> 被子类继承！！！ 【模板设计模式】
3.6 模板设计模式
* 设计模式为了解决某一类问题！模板设计模式也是为了解决某一类问题！！！小学学习写作业：开头：xxxxxx中间：自由发挥结尾：yyyyyy* 例如：司机开车！新司机：开门系安全带点火双手紧握方向盘！停车熄火老司机：开门系安全带点火左手握着方向盘，右手夹着一支烟停车熄火可以将司机开车作为一个模板！
/*司机：父类！*/
public abstract class Driver {// 定义一个方法：开车！public void run(){System.out.println("开门");System.out.println("系安全带");System.out.println("点火");// 握方向盘ziShi();System.out.println("停车");System.out.println("熄火");}public abstract void ziShi();}
/*新司机：子类！开门系安全带点火双手紧握方向盘！停车熄火*/
public class NewDriver extends Driver{@Overridepublic void ziShi() {System.out.println("双手紧握方向盘！");}}
/*老司机：子类！开门系安全带点火左手握着方向盘，右手夹着一支烟停车熄火*/
public class OldDriver extends Driver {@Overridepublic void ziShi() {System.out.println("左手握着方向盘，右手夹着一支烟");}
}
/*测试类*/
public class Test {public static void main(String[] args) {// 创建新司机类的对象NewDriver newDriver = new NewDriver();newDriver.run();System.out.println("===============");// 创建老司机类的对象OldDriver oldDriver = new OldDriver();oldDriver.run();}
}
四、final关键字
* 关键字：被java内定的单词(全部由小写字母组成)，赋予了特殊含义！之前我们学习过一些类： String类！(都是别人提供的，有很多功能)，这些类中的功能是不希望被程序员更该的！=====>>>> final关键字可以完成！* final关键字能修饰啥？①类：不能被继承！②变量：不能被更改值！③方法：不能被覆盖重写！
4.1 final修饰类
final修饰类，这个类不能被继承！
public final class Fu{}
public class Zi extends Fu{ // 编译报错！}
4.2 final修饰方法
final修饰方法，不能被覆盖重写
/*final修饰类：不能被继承！final修饰方法：不能被覆盖重写！*/
public class Fu {public final void method(){System.out.println("虞姬吊打鲁班七号");}}
public class Zi extends Fu {@Overridepublic void method() { // 编译报错！super.method();System.out.println("么么哒！");}
}
4.3 final修饰变量
修饰成员变量：它其实是一个常量，必须初始化，其值不能更改！
public class Fu {// 常量！// final int NUMBER; // 报错！必须初始化！final int NUMBER = 100; // 一般都是将变量名的每个字母全部大写！// 标准写法// public static final int NUMBER = 100;public void show(){// 修改变量的值NUMBER = 100; // 编译报错！}}
修饰局部变量(基本数据类型)：不能二次赋值
public void show(){// 定义变量final int number;// 初始化number = 10;// 修改值number = 100; // 编译报错！不能二次赋值！System.out.println(number);}
修饰局部变量(引用数据类型)：不能修改地址值，但是可以修改里面的数据(数值)！
public class Student {private String name;private int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}}
public class Test {// 无参构造方法！public Test(){}// 成员方法public void method(){// 定义变量(引用数据类型)final Student student = new Student("jack",38);// 修改变量的地址值//student = new Student(); // 地址值不能被更改！System.out.println(student.getName()+", " + student.getAge());// 修改变量里面的数据！(不是地址值)student.setName("rose");student.setAge(18);System.out.println(student.getName()+", " + student.getAge());}// 主方法public static void main(String[] args) {Test test = new Test();// 这个方法没有被static修饰，只能通过对象调用！test.method();}}
umber = 100; // 编译报错！不能二次赋值！
System.out.println(number);}
> 修饰局部变量(引用数据类型)：不能修改地址值，但是可以修改里面的数据(数值)！```java
public class Student {private String name;private int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}}
public class Test {// 无参构造方法！public Test(){}// 成员方法public void method(){// 定义变量(引用数据类型)final Student student = new Student("jack",38);// 修改变量的地址值//student = new Student(); // 地址值不能被更改！System.out.println(student.getName()+", " + student.getAge());// 修改变量里面的数据！(不是地址值)student.setName("rose");student.setAge(18);System.out.println(student.getName()+", " + student.getAge());}// 主方法public static void main(String[] args) {Test test = new Test();// 这个方法没有被static修饰，只能通过对象调用！test.method();}}
继承、抽象类、模板设计模式、_nal关键字相关推荐
- 【复习回顾、继承、抽象类模板设计模式】
day01[复习回顾.继承.抽象类模板设计模式] 今日内容 面向对象复习------>必须掌握 继承 继承的格式------>必须掌握 继承后成员访问特点------>必须掌握 th ...
- Java——抽象类+模板设计模式
目录 1.抽象类介绍 2.抽象类细节 3.抽象类细节02 4.抽象类实例(员工问题) test01.java Employee.java Manager.java CommonEmployee.jav ...
- 抽象类 模板设计模式
抽象类 包含抽象方法的类 abstract 修饰 1.抽像类不可以被实例化 Person p = new Person("bit",10); 2.如果一个非抽象类继承了抽象类,必须 ...
- 黑马毕向东Java课程笔记（day07）:面向对象（第三部分）继承+抽象类+模板方法设计模式+接口+final+继承补充（就业班）
在这一部分中,我们将讲解有关继承的相关内容,包括继承的概述.继承的特点.super关键字.函数覆盖.子类的实例化过程.final关键字这几个部分的内容. 1.继承的概述以及特点 1.1.概述 ...
- 【26天高效学完Java编程】Day11：继承、抽象类、模板设计模式详解
本专栏将从基础开始,循序渐进,由浅入深讲解Java的基本使用,希望大家都能够从中有所收获,也请大家多多支持. 专栏地址:26天高效学习Java编程 相关软件地址:软件地址 所有代码地址:代码地址 如果 ...
- 01-复习回顾、继承、抽象类、模板设计模式
day01[复习回顾.继承.抽象类模板设计模式] 今日内容 面向对象复习 类的创建------>必须掌握 对象的创建和使用------>必须掌握 匿名对象 继承 如何继承-继承的格式--- ...
- 【复习回顾、继承、抽象类、模板设计模式】
day01[复习回顾.继承.抽象类模板设计模式] 今日内容 面向对象复习------>必须掌握 继承 继承的格式------>必须掌握 继承后成员访问特点------>必须掌握 抽象 ...
- day01-【复习回顾、继承、抽象类、模板设计模式】
复习总结[复习回顾.继承.抽象类模板设计模式] 今日内容 面向对象复习------>必须掌握 继承 继承的格式------>必须掌握 继承后成员访问特点------>必须掌握 抽象类 ...
- Java笔记018-抽象类、抽象类最佳实践-模板设计模式、接口、内部类
目录 抽象类 先看一个问题 小结: 抽象类快速入门 抽象类的介绍 抽象类使用的注意事项和细节讨论 抽象类练习题 抽象类最佳实践-模板设计模式 基本介绍 模板设计模式能解决的问题 最佳实践 最佳实践 接 ...
- 0047 抽象类、模板设计模式
/*抽象类1.用abstract关键字来修饰一个类时,这个类就叫抽象类访问修饰符 abstract 类名{}2.用abstract关键字来修饰一个方法时,这个方法就是抽象方法访问修饰符 abstr ...
最新文章
- 用 Python 和 OpenCV 检测图片上的条形码Detecting Barcodes in Images with Python and OpenCV
- Java iText PDF：用 iText 包生成简单的 pdf 文件
- SpringBatch 多线程(TaskExecutor)启动Job详解 (七)
- 中文版开源！最最最经典的Python编程教材强势来袭~
- 一个YII社区学习网站
- SpringBoot 如何统一后端返回格式？老鸟们都是这样玩的！
- Idea开发环境中搭建Maven并且使用Maven打包部署程序
- pandas获取符合条件值的索引
- 阶段1 语言基础+高级_1-3-Java语言高级_06-File类与IO流_01 File类_5_File类获取功能的方法...
- 转行python算法_转：Python：SMOTE算法
- 用html制作静态音乐欣赏,【HTML】简单的静态音乐网页设计
- iOS系列—wakeup in XNU
- f5 gtm 工作原理_F5 LTM工作原理.ppt
- Chrome浏览器下调试和动态修改网页JavaScript
- Premiere使用教程（五）视频导出及添加视频、音频过渡
- 计算机linux二级试题,计算机二级考试题及答案
- 【干货收藏】数据分析师必备的20种分析思维
- 铜死亡丨解锁细胞死亡新方式 - MedChemExpress
- 一个啥都不懂但还不知天高地厚的我
- 日志收集Agent方案和比较