文章目录
一、面向对象回顾
学习目标
能够定义类并创建对象
内容讲解
【1】类的定义格式
关键字:class
修饰符 class 类名{
成员变量
成员方法
构造方法
代码块
内部类
}
例如:
定义一个学生类,包含属性姓名,年龄
public class Student{
public String name;
public int age;
}
默认有一个无参构造方法
【2】创建对象
关键字:new
类名 对象名 = new 类名(参数);
例如:
创建学生对象
Student stu = new Student();
//给姓名赋值为小明
stu.name = "小明";
stu.age = 18;
System.out.println(stu.name);
内容小结
类定义的关键字:class
对象定义的关键字:new
二、 面向对象特性之【封装】
学习目标
- 理解关键字private
- 能够使用private对类中成员进行封装
内容讲解
【1】private关键字
private关键字的含义就是私有。可以用来对成员进行封装
【2】封装的操作步骤
-
第一步:先把成变量使用private封装
-
第二步:提供getter、setter方法
举例:
定义一个学生类,含有属性姓名,年龄。对姓名和年龄进行封装,并提供可访问的getter、setter方法
public class Demo01 {
public static void main(String[] args) {
Student stu = new Student();
//给name属性赋值小明
//stu.name
stu.setName("小明");
//System.out.println(stu.name);
System.out.println(stu.getName());
}
}
/*
定义一个学生类,含有属性姓名,年龄。对姓名和年龄进行封装,并提供可访问的getter、setter方法
*/
class Student{
//1. 将成员变量使用private进行修饰
private String name;
private int age;
//2. 提供getter、setter方法
//name的getter和setter方法
//getter:获取成员变量值
public String getName() {
return name;
}
//setter:负责赋值
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
内容小结
封装使用什么关键字?
private
封装的步骤?
第一步:先把成变量使用private封装
第二步:提供getter、setter方法
三、 构造器(Constructor)
学习目标
- 能够定义并使用类的构造器
内容讲解
【1】构造器的定义及其作用
格式:
修饰符 类名 (形参){
给成员变量初始化值
}
特点:
- 没有返回值(即使void也不用写)
- 方法名一定是和当前类的类名一样
- 构造方法支持重载(同名不同参)
作用:
- 结合关键字new创建对象,也可以同时给成员变量赋值。
【2】代码演示
定义一个学生类,含有属性姓名,年龄。对姓名和年龄进行封装,并提供可访问的getter、setter方法
同时提供无参构造方法,满参构造方法。
public class Demo01 {
public static void main(String[] args) {
//使用无参构造方法创建对象
Student stu = new Student();
stu.setName("昌老师");
stu.setAge(18);
System.out.println(stu.getName() + "::" + stu.getAge());
stu.study();
//使用满参构造方法创建对象
Student stu2 = new Student("苏群", 17);
System.out.println(stu2.getName() + "::" + stu2.getAge());
stu2.study();
}
}
//定义一个学生类,含有属性姓名,年龄。对姓名和年龄进行封装,并提供可访问的getter、setter方法
//同时提供无参构造方法,满参构造方法。
class Student {
//1.成员变量
private String name;
private int age;
//2.构造方法
// 无参构造方法,(如果写了其他非无参构造方法,就没有默认的无参了)
public Student() {
}
// 满参构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//3.getter/setter
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;
}
//4.行为方法
public void study() {
System.out.println(name + "正在认真的学习Java");
}
}
内容小结
构造方法特点?
- 没有返回值
- 可以重载
- 方法名和类名一样
构造方法有什么作用?
- 为了结合new关键字创建对象,可以给成员变量初始化值
四、this关键字
学习目标
- 理解this关键字的含义
- 能够使用this关键字解决局部变量和成员变量冲突问题
内容讲解
【1】this的含义
- this就是指当前类型的对象
- this一般出现在构造器,实例方法中
- 如果在构造器中,this就是当前new的对象。
- 如果出现在实例方法,this就是调用该方法的对象。
【2】作用
this关键字就是为了解决局部变量和成员变量名字冲突的调用问题。
格式:
this.成员变量
例如:
//构造方法
public Student(String name,int age){
this.name=name;
this.age = age;
}
//setter
public void setName(String name){
this.name = name;
}
【3】代码演示
public class Demo01 {
public static void main(String[] args) {
Student stu = new Student("张三");
System.out.println("stu.name = " + stu.name);
System.out.println("stu=" + stu);//stu=_03this关键字.Student@6bf256fa
}
}
class Student {
public String name;
public Student(String name) {
//name = name;//没有设置成功,使用冲突的局部变量和成员变量,就近选择局部变量
this.name = name;
System.out.println("this=" + this);//this=_03this关键字.Student@6bf256fa
}
//实例方法自己验证:调用方法的对象就是方法内部的this对象
}
内容小结
-
this关键字含义?
this在构造器中就是指当前创建的对象,如果在实例方法中就是调用方法的对象
-
this关键字有什么作用?
区分名字冲突的成员变量和局部变量。
五、 匿名对象
学习目标
- 能够定义类的匿名对象
内容讲解
【1】什么是匿名对象
-
有名对象:有对象名保存地址的对象
Student stu = new Student(); Scanner sc = new Scanner(System.in);
-
匿名对象:没有对象名的对象就是匿名对象
new Student(); new Scanner(System.in);
【2】匿名对象怎么用
匿名对象的使用特点:只能使用一次,对象名可以怎么用,匿名对象也可以怎么用。
- 直接使用匿名对象调用方法
- 直接当做一个参数传给方法
- 直接当做返回值进行传递
【3】代码演示
public class Demo01 {
public static void main(String[] args) {
//- 直接使用匿名对象调用方法
new Student().setName("张三");
new Student("少林").study();
//- 直接当做一个参数传给方法
showStudent(new Student("李四"));
//有名对象
Student stu = new Student("张三");
showStudent(stu);
}
public static void showStudent(Student stu) {
stu.study();
}
//- 直接当做返回值进行传递
public static Student getStudent() {
return new Student("王五");
}
}
class Student{
private String name;
public Student() {
}
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
System.out.println("调用了set方法");
this.name = name;
}
public void study() {
System.out.println(name+"正在认真的学习Java");
}
}
内容小结
-
什么是匿名对象?
没有对象名的对象
-
匿名对象怎么用?
只能用一次,对象名可以怎么用,匿名对象也可以怎么用
- 直接调用成员
- 直接当做方法参数传递
- 直接当做返回值传递
六、 面向对象特性之【 继承】
学习目标
-
理解继承的思想
-
能够使用关键字extends书写继承的代码
-
能够知道继承的好处
内容讲解
【1】继承的概述
面向对象的特性:封装,继承,多态
设计类的过程中就可以去使用继承,可以提高代码的复用性。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IbUtVkOc-1616501047834)(imgs/image-20201028103456573.png)]
【2】继承的格式
Java中如何完成类型的继承:需要借助关键字,extends,implements
今日讲extends,类继承类使用 extends。
class Fu { //父类,基类,超类
成员
}
class Zi extends Fu{ // 子类
}
表示Zi类继承了Fu类。
内容小结
-
继承的思想?
比如A类继承了B类,A就可以拥有B中的属性成分。
-
继承的好处?
提高代码的复用性
-
继承使用的关键字?
extends
-
格式
class A{} class B{} A继承B class A extends B{}
01、继承入门案例
学习目标
- 能够使用继承思想定义类
内容讲解
【需求】
以继承的思想定义以下类型:
- 学生类
属性:姓名,年龄
行为:吃饭,睡觉 - 老师类
属性:姓名,年龄,薪水
行为:吃饭,睡觉,教书 - 班主任
属性:姓名,年龄,薪水
行为:吃饭,睡觉,管理
【分析】
如果不用继承的思想定义类,发现有属性:姓名,年龄。行为:吃饭,睡觉,会重复定义。
使用继承的思想定义类:
- 把共性的属性或者行为抽取到父类中。
- 定义子类继承父类。重复的部分不用定义,特有的需要定义。
【步骤】
- 抽取父类,人(属性:姓名,年龄 行为:吃饭,睡觉)
- 然后再定义子类
- 测试
【代码】
public class Demo01 {
public static void main(String[] args) {
//3. 测试
//学生类:
Student stu = new Student();
stu.name = "张三";//name就是父类继承下来的
stu.eat();//来自父类的方法
stu.sleep();//来自父类的方法
//老师类:
Teacher t = new Teacher();
t.name = "昌老师";//来自父类的属性
t.salary = 100000;//来自本类
t.eat();//来自父类的方法
t.teaching();//来自本类的方法
}
}
//1. 抽取父类,人(属性:姓名,年龄 行为:吃饭,睡觉)
class Person { //父类
public String name;
public int age;
public void eat() {
System.out.println(name + "在吃饭饭!");
}
public void sleep() {
System.out.println(name + "在睡觉觉!");
}
}
//2. 然后再定义子类
class Student extends Person {
}
class Teacher extends Person {
//特有的属性
public int salary;//薪资
//特有的行为
public void teaching() {
System.out.println(name + "老师,在教书书!");
}
}
内容小结
如何使用继承思想设计类?
在设计很多类的时候,可以将共性的属性或者行为抽取到父类中。
02、 继承中成员变量的使用特点
学习目标
- 理解继承中子类访问父类成员变量的特点
- 能够解决方法中变量,成员变量中及其父类中成员变量冲突
内容讲解
【1】继承中成员变量的使用特点
- 子类可以直接使用父类中非私有的属性
- 如果子类和父类相同包,可以直接使用父类的public,protected,package-private修饰的属性
- 如果子类和父类在不同包,可以直接使用父类的public,protected修饰的属性。
- 如果是私有的,也可以使用getter,setter去进行访问
- 如果子类中存在与父类相同的成员变量,就近先使用子类的(会把父类同名成员变量隐藏)。
【代码测试】
class Fu{
public int age; //公共的
protected int height; //受保护的
int weight;// 包私有的
private String sex; //私有的
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
class Zi extends Fu{
public void show1() {
System.out.println(age);
System.out.println(height);
System.out.println(weight);
//System.out.println(sex);//不能访问父类私有成分
System.out.println(getSex());//可以借助getter、setter方法进行访问
}
}
【2】继承中子类方法中局部变量,子类成员变量中,父类成员变量中名字冲突
在子类方法中访问:
位置 | 子类方法中局部变量 | 子类成员变量 | 父类成员变量 |
---|---|---|---|
访问 | 直接访问 | this.成员变量 | super.成员变量 |
代码示例:
public class Demo02 {
public static void main(String[] args) {
Cat cat = new Cat();
cat.show();
}
}
class Animal{
int age = 10;
}
class Cat extends Animal{
int age = 20;
public void show() {
int age = 30;
//要求,把所有age变量的值都打印出来
System.out.println(age);//30
System.out.println(this.age);//20
System.out.println(super.age); // 10
}
}
内容小结
继承中子类访问父类成员变量的特点?
- 同包中:公共的,受保护的,包私有修饰的属性是可以直接访问,私有不行
- 不同包:公共的,受保护的修饰的属性是可以直接访问
不能直接访问的成分,可以借助公共的getter,setter方法进行访问
如果方法中局部变量,本类成员变量,父类的成员变量名字有冲突?
局部变量:直接访问
本类成员变量:this.
父类成员变量:super.
03、 继承中成员方法的使用特点
学习目标
- 理解继承中子类访问父类成员方法的特点
内容讲解
【1】方法的访问特点
访问特点和成员变量是一样的。
同包中:子类可以访问父类的public,protected,包私有修饰的方法
不同包:子类可以访问父类的public,protected,的方法
如果子类中定义声明了与父类一样的方法,优先访问子类的方法。
【2】代码示例
public class Demo01 {
public static void main(String[] args) {
//创建子类对象访问方法
Zi zi = new Zi();
zi.test1();
zi.test2();
zi.test3();
//zi.test4(); //同包中,私有的父类方法不能访问
//父类和子类方法相同
zi.test5();
}
}
class Fu {
public void test1() {
System.out.println("这是父类的public修饰的test1方法");
}
protected void test2() {
System.out.println("这是父类的protected修饰的test2方法");
}
void test3() {
System.out.println("这是父类的包私有修饰的test3方法");
}
private void test4() {
System.out.println("这是父类的private修饰的test4方法");
}
public void test5() {
System.out.println("来自父类的方法");
}
}
class Zi extends Fu {
public void test5() {
System.out.println("来自子类的方法");
}
}
内容小结
继承中子类访问父类方法的特点?
同包中:public,protected,包私有修饰的成分可以访问
不同包:public,protected修饰的成分可以访问
继承中如果子类方法和父类方法相同了,子类对象调用该方法优先访问谁呢?
优先访问子类方法
04、方法重写
学习目标
- 能够理解为什么要重写
- 能够覆盖重写父类方法
内容讲解
【1】重写概念
当父类中方法继承到子类后,不满足子类需要的时候,子类就可以对这个方法进行覆盖,重写(Override)。
如何重写父类中的方法呢?
声明不变,重新实现。
- 方法的声明:
修饰符 返回值类型 方法名 (参数列表)
- 逻辑的重新实现:方法体的逻辑重写
修饰符 返回值类型 方法名 (参数列表){
方法体的逻辑重写
}
例如:
class Animal {
public void eat(){
System.out.println("吃东西");
}
}
class Cat extends Animal{
//重写eat方法
public void eat(){
System.out.println("猫吃鱼");
}
}
【2】注解
@Override :注解,表示该方法是重写的方法。
IDEA重写方法:
- 直接写方法名,回车补全
- 快捷键:Ctrl+O
代码实例
public class Demo01 {
public static void main(String[] args) {
Cat c = new Cat();
c.eat();
}
}
class Animal {
public void eat() {
System.out.println("动物吃东西!");
}
public void sleep() {
}
}
class Cat extends Animal {
//直接写方法名,回车补全
/* @Override //注解:表示该方法是重写的方法
public void eat() {
super.eat();//调用父类的eat方法
System.out.println("猫吃鱼!!");
}*/
//Ctrl+O:快捷重写
@Override
public void eat() {
System.out.println("猫吃鱼!!");
}
@Override
public void sleep() {
super.sleep();
}
}
【3】注意事项
-
方法重写是发生在子父类之间的关系。
-
子类方法覆盖父类方法,必须要保证权限大于等于父类权限。
-
子类方法覆盖父类方法,返回值类型、函数名和参数列表都要一模一样。
返回值类型(子类返回值类型要小于等于父类返回值类型【不考虑基本数据类型】)子类继承父类,子类范围更具体更小的,父类范围会更抽象更宽泛。父类型大于子类型。
平时重写方法时:声明不变
内容小结
为什么要重写?
父类继承到子类的方法逻辑不满足子类需要时,子类可以进行重写。
如何重写?
声明不变,重新实现。
05、继承中构造方法的使用特点
学习目标
- 能够使用super调用父类构造方法初始父类属性
内容讲解
构造方法是不能冲父类继承到子类中的,但是可以在子类中借助super关键字进行访问。
如何借助super关键字调用父类的构造方法?
-
格式:
需要在子类构造方法中第一句位置,使用super调用
super() 调用父类的无参构造 super(参数) 调用父类的有参构造方法
-
特点:
super调用构造方法一次只能有一个。
父类的构造方法,总是在子类构造方法执行前,执行。
子类的构造方法,一定会先调用父类构造方法,如果没有显式使用super调用,默认会有
super()
代码实践
public class Demo01 {
public static void main(String[] args) {
Student stu = new Student();
System.out.println("stu.name = " + stu.name);
//使用满参构造方法创建对象
Student stu2 = new Student("李四",20,1);
System.out.println("stu2.name = " + stu2.name);
System.out.println("stu2.age = " + stu2.age);
System.out.println("stu2.id = " + stu2.id);
}
}
class Person {
public String name;
public int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
class Student extends Person {
public int id;
public Student() {
//super();//如果没有写,默认会有
super("张三", 18);
}
//构建一个满参,包含本类的属性,父类的属性初始化
public Student(String name, int age,int id) {
super(name, age);
this.id=id;
}
}
内容小结
如何调用父类的构造方法?
- 使用关键字:super
- 位置要求:必须在子类构造方法的第一句
- 格式:super(参数)
06、继承的特点
学习目标
- 能够理解继承的三个特点
内容讲解
继承的特点有三个:
-
只支持单继承
class A {} class B {} class C extends A{} class D extends A,B{} //不行,错误
-
允许一个父类有多个子类
class A{} class B extends A{} class C extends A{}
-
允许类多层继承
class A{} //如果一个类没有显式的继承一个类,默认会继承Object(上帝类) class B extends A{} class C extends B{} class D extends C{}
继承也是具有传递性的,A中的成分不仅会继承给B,也会继承给C,也会继承给D。
内容小结
继承三个特点?
- 单继承
- 一个父类可有多个子类
- 可以多层继承
七、super和this关键字使用小结
学习目标
- 能够区分super和this的用法
- 能够使用this关键字调用本类中的构造方法
内容讲解
【1】super和this的异同
super和this都是指代的同一个对象,this表示的本类空间,super表示的父类空间。
this和super用法一样:
- 调用成员变量
- 调用成员方法
- 调用构造方法
区别在于,this调用的是本类的成分,super调用父类的成分。
【2】this调用本类构造方法
-
格式:
位置:必须在本类构造方法的第一句
this(参数)
注意:不能调用自身构造方法
-
特点:
- this和super调用构造方法不能共存的
代码实践:
public class Demo01 {
public static void main(String[] args) {
//使用无参构造方法创建对象,name和age都有初始的值
Student stu = new Student();
System.out.println("stu.name = " + stu.name);
System.out.println("stu.age = " + stu.age);
}
}
class Student {
public String name;
public int age;
public Student() {
//name : 尼古拉斯.赵四
//age : 18
//name = "尼古拉斯.赵四";
//age = 18;
this("尼古拉斯.赵四", 18);
}
public Student(String name) {
this.name = name;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
内容小结
super和this是的是什么?
只同一个对象的两个空间,super指父类空间,this指本类空间。
this如何调用本类其他构造方法?
位置:在本类的构造方法第一句
格式:this(参数)
不能调用自身,否则会报错。
this为何要调用本类其他构造方法?
- 为了初始化成员
- 提高代码的复用性
八、抽象
01、抽象类的定义
学习目标
- 理解什么是抽象类,抽象方法
- 能够定义抽象类和抽象方法
内容讲解
【定义】
abstract关键字:表示抽象。
使用关键字abstract修饰的类,称为抽象类。
使用关键字abstract修饰的方法,没有方法体,且以分号结尾的方法,称为抽象方法。
【格式】
//抽象类
修饰符 abstract class 类名{
//抽象方法
修饰符 abstract 返回值类型 方法名(参数列表);
}
- 在抽象类中,可以没有抽象方法。但是如果一个类中存在抽象方法,该类一定是抽象类。
- 抽象类本质上也是一个类,也可以有普通类中的各种成分(成员变量,成员方法,构造方法)
【使用场景】
抽象类,抽象方法的使用场景。
抽取多个类的父类时,通常就会使用抽象类。如果多个类中有共同的方法,但是逻辑具体由不同,此时就可以使用抽象方法。
抽象类就是以父类的角色存在。
【代码实践】
学生:姓名,年龄,吃饭,工作
老师:姓名,年龄,吃饭,工作
班主任:姓名,年龄,吃饭,工作
抽取父类人,描述上面的共同的父类。
分析:
属性:姓名,年龄
行为:吃饭,工作,吃饭大家都一样的,可以使用具体的方法,而工作,因为每个角色的内容不同,可以使用抽象方法。
public abstract class Person {
//属性
public String name;
public int age;
//构造方法
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
//行为
public void eat() {
System.out.println("吃饭");
}
//抽象方法
public abstract void work();
}
内容小结
什么叫抽象类,什么叫抽象方法?
被abstract修饰的类就是抽象类,被abstract修饰的方法就是抽象方法
抽象的关键字是什么?
abstract
什么时候可以使用抽象类,抽象方法?
抽取多个类的父类时,通常就会使用抽象类。如果多个类中有共同的方法,但是逻辑具体由不同,此时就可以使用抽象方法。
02、抽象类的使用
学习目标
- 能够使用抽象抽象
内容讲解
【1】抽象类的使用方式
-
抽象类不能直接实例化对象使用。
-
可以定义子类继承抽象的父类,如果存在抽象方法,要将所有的抽象方法进行重写
重写抽象方法可以叫做实现。
-
如果子类不重写抽象方法,你可将子类也变成抽象类。
【2】代码实践
使用上一个知识点的Person抽象类作为父类定义学生类,老师类。
当我们使用一个类继承一个抽象类时,发现报错:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lIucYJa0-1616501047838)(imgs/image-20201028160114179.png)]
类Student必须要么定义成抽象类,要么把来自父类的抽象方法work实现
public class Demo01 {
public static void main(String[] args) {
//抽象类不能创建对象
//Person p1 = new Person();
//使用时,用其子类即可
Student stu = new Student();
stu.work();
stu.sleep();
}
}
//创建子类去继承抽象类,并实现抽象方法
class Student extends Person{
@Override
public void work() {
System.out.println("学生的工作,就是学习!!");
}
@Override
public void sleep() {
System.out.println("睡觉站着睡觉");
}
}
abstract class Teacher extends Person {
//父类的抽象方法就会继承到子类Teacher中。
}
内容小结
抽象类怎么使用?
- 不能创建对象
- 可以使用子类继承抽象类,实现所有的抽象方法。
- 如果子类不实现抽象方法,子类要定义成为抽象类
03、抽象类的使用注意事项
学习目标
内容讲解
-
抽象类不能创建对象,如果创建,编译无法通过而报错。只能创建其非抽象子类的对象。
理解:假设创建了抽象类的对象,调用抽象的方法,而抽象方法没有具体的方法体,没有意义。
-
抽象类中,可以有构造器,是供子类创建对象时,初始化父类成员使用的。
理解:子类的构造方法中,有默认的super(),需要访问父类构造方法。
-
抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类。
理解:未包含抽象方法的抽象类,目的就是不想让调用者创建该类对象,通常用于某些特殊的类结构设计。
-
抽象类的子类,必须重写抽象父类中所有的抽象方法,否则子类也必须定义成抽象类,编译无法通过而报错。
理解:假设不重写所有抽象方法,则类中可能包含抽象方法。那么创建对象后,调用抽象的方法,没有意义。
04 、抽象类存在的意义
学习目标
- 能够理解抽象类存在的意义
内容讲解
抽象类在抽取父类型的时候可以使用,有一些方法假如具体子类型有不同的逻辑,可以使用抽象方法。
抽象类的子类必须要实现所有的抽象方法。否则要变成抽象类。
对子类有一个约束,子类会根据父类而进行设计,体现一种模板思想。
内容小结
抽象类可以当做父类型,里面定义抽象方法,可以约束子类一定要做一个具体的实现。
九、模板设计模式
学习目标
- 理解什么是设计模式
- 能够使用抽象类设计模板模式
内容讲解
什么是设计模式?
设计模式体现的是解决一个问题一个需求的一种最佳实践。
模板设计模式:
可以利用抽象类定义一些需要子类完成的一系列功能的模板方法。子类继承抽象类之后,只要实现抽象方法。
而模板方法直接继承到子类,不需要重写。子类调用模板方法的时候,就可以按照模板的逻辑进行执行了。
例如:
我现在需要定义新司机和老司机类,新司机和老司机都有开车功能,开车的步骤都一样,只是驾驶时的姿势有点不同,
新司机:开门,点火,双手紧握方向盘,刹车,熄火
,老司机:开门,点火,右手握方向盘左手抽烟,刹车,熄火
。
使用模板设计模式进行定义相关的类,步骤:
- 抽取所有的共性方法到抽象类中,如果具体类型的逻辑不同的使用抽象方法定义。
- 定义模板方法,定义每个子类都必须遵循的一个业务逻辑(流程)。
抽象父类(模板)
//新司机:开门,点火,双手紧握方向盘,刹车,熄火,老司机:开门,点火,右手握方向盘左手抽烟,刹车,熄火。
abstract class Driver {
//定义方法
public void open() {
System.out.println("开门");
}
public void start() {
System.out.println("开火启动");
}
public abstract void zishi();
public void breakDown() {
System.out.println("刹车");
}
public void stop() {
System.out.println("熄火");
}
//模板方法:定义流程
public final void drive() {//final加上的目的就是为了阻断重写
open();
start();
zishi();
breakDown();
stop();
}
}
测试类及其子类:
public class Demo01 {
public static void main(String[] args) {
NewDriver d1 = new NewDriver();
d1.drive();//调用模板方法
System.out.println("=============");
OldDriver oldDriver = new OldDriver();
oldDriver.drive();//调用模板方法
}
}
class OldDriver extends Driver {
@Override
public void zishi() {
System.out.println("左手抽烟,右手搭在方向盘");
}
}
class NewDriver extends Driver {
@Override
public void zishi() {
System.out.println("双手握紧方向盘,聚精会神");
}
}
内容小结
什么时候使用模板设计模式?
当子类都有一个固定的业务流程时,就可以使用模板设计模式
如何设计?
- 抽取所有的共性方法到抽象类中,如果具体类型的逻辑不同的使用抽象方法定义。
- 定义模板方法,定义每个子类都必须遵循的一个业务逻辑(流程)。
十、总结
-
能够写出类的继承格式
使用extends关键字。
class A{} class B extends A{}
-
能够说出类继承的三个特点
单继承 一个父类可以有多个子类 可以多层继承,有传递性
-
能够说出继承中子类访问成员的特点
子类和父类在同包:被public,protected,包私有修饰的的成员,子类可以访问
子类和父类在不同包::被public,protected 修饰的的成员,子类可以访问
如果子类定义了与父类一样的成员,优先访问子类的。
-
能够说出继承中方法重写的使用场景
当父类的方法继承到子类其逻辑不能满足子类需要时,就可以进行重写
-
能够说出this和super的使用方式及其区别
使用方式:
- 可以访问成员变量,成员方法,构造方法
区别:
this访问本类,super访问父类
-
能够定义抽象类和抽象方法
abstract:表示抽象
abstract class 类名{ public abstract void test(); }
-
能够使用含有抽象方法的抽象类
- 子类要实现所有的抽象方法
- 将子类变成抽象类
- 抽象类不能实例化对象
-
能够说出父类抽象方法的存在意义
System.out.println(“熄火”);
}
//模板方法:定义流程
public final void drive() {//final加上的目的就是为了阻断重写
open();
start();
zishi();
breakDown();
stop();
}
}
测试类及其子类:
```java
public class Demo01 {
public static void main(String[] args) {
NewDriver d1 = new NewDriver();
d1.drive();//调用模板方法
System.out.println("=============");
OldDriver oldDriver = new OldDriver();
oldDriver.drive();//调用模板方法
}
}
class OldDriver extends Driver {
@Override
public void zishi() {
System.out.println("左手抽烟,右手搭在方向盘");
}
}
class NewDriver extends Driver {
@Override
public void zishi() {
System.out.println("双手握紧方向盘,聚精会神");
}
}
内容小结
什么时候使用模板设计模式?
当子类都有一个固定的业务流程时,就可以使用模板设计模式
如何设计?
- 抽取所有的共性方法到抽象类中,如果具体类型的逻辑不同的使用抽象方法定义。
- 定义模板方法,定义每个子类都必须遵循的一个业务逻辑(流程)。