day01【复习回顾、继承、抽象类】
day01【复习回顾、继承、抽象类】
今日内容
-
复习回顾
-
static关键字(掌握)
-
继承(掌握)
-
教学目标
- 能够理解static关键字
- 能够写出类的继承格式
- 能够说出继承的特点
- 能够说出子类调用父类的成员特点
- 够说出方法重写的概念
- 能够说出this可以解决的问题
- 能够说出super可以解决的问题
- 描述抽象方法的概念
- 写出抽象类的格式
- 写出抽象方法的格式
- 能够说出父类抽象方法的存在意义
工程和模块
# 1.工程
1）在企业开发中创建工程(项目project)
# 2.模块
1) 在一个空的工程中可以创建多个模块
2）好处：方便管理，我们不做大的项目之前可以每天创建一个模块
3) 弊端：就是一个模块中报错其他模块不能运行
锁哥课程中采用创建每天一个工程。
创建工程：
1.
2.
3.
4.
5.
第一章 复习回顾
1.1 如何定义类
类的定义格式如下:
修饰符 class 类名{
// 类中的五大成分。之前学习三个成分
// 1.成员变量（属性）
// 2.成员方法 (行为)
// 3.构造器 （初始化类的对象数据的）
}
1.2 如何通过类创建对象
类名 对象名称 = new 类名();
例如:
Student stu = new Student();
1.3 封装
1.3.1 封装的步骤
1.使用 private 关键字来修饰成员变量。
2.使用public修饰getter和setter方法。
1.3.2 封装的步骤实现
-
private修饰成员变量
public class Student {
private String name;
private int age;
}
-
public修饰getter和setter方法
public class Student {
private String name;
private int age;
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
}
1.4 构造器
1.4.1 构造器的作用
通过调用构造器可以返回一个类的对象，构造器同时负责帮我们把对象的数据（属性和行为等信息）初始化。
1.4.2 构造器的格式
修饰符 类名(形参列表) {
// 构造体代码，执行代码
}
1.4.3 构造器的应用
首先定义一个学生类，代码如下：
public class Student {
// 1.成员变量
String name;
int age;
// 2.构造器
//无参构造器
public Student() {
System.out.println("无参数构造器被调用")；
}
}
接下来通过调用构造器得到两个学生对象。
public class CreateStu02 {
public static void main(String[] args) {
// 创建一个学生对象
// 类名 变量名称 = new 类名();
Student s1 = new Student();
// 使用对象访问成员变量，赋值
s1.name = "张三";
s1.age = 20 ;
// 使用对象访问成员变量 输出值
System.out.println(s1.name);
System.out.println(s1.age);
Student s2 = new Student();
// 使用对象访问成员变量 赋值
s2.name = "李四";
s2.age = 18 ;
System.out.println(s2.name);
System.out.println(s2.age);
}
}
1.5 this关键字的作用
1.5.1 this关键字的作用
this代表所在类的当前对象的引用（地址值），即代表当前对象。
1.5.2 this关键字的应用
1.5.2.1 用于普通的gettter与setter方法
this出现在实例方法中，谁调用这个方法（哪个对象调用这个方法），this就代表谁（this就代表哪个对象）。
public class Student {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
if (age > 0 && age < 200) {
this.age = age;
} else {
System.out.println("年龄非法！");
}
}
public int getAge() {
return age;
}
}
1.5.2.2 用于构造器中
this出现在构造器中，代表构造器正在初始化的那个对象。
public class Student {
private String name;
private int age;
// 无参数构造方法
public Student() {}
// 有参数构造方法
public Student(String name,int age) {
this.name = name;
this.age = age;
}
}
1.6 匿名对象【理解】
概念
需求：
1、创建一个学生的类Student，并在Student类中定义两个属性name和age。
2、在Student类中定义一个函数demo()。
3、定义一个测试学生类的类StudentTest。
Student：是一个类。描述的是学生这个事物
student：类所创建的对象名(实例名)
匿名对象：就是指没有名称的对象。创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。虽然是创建对象的简化写法，但是应用场景非常有限。
格式：
new 类名(参数列表)；
举例：
new Scanner(System.in)；
new Student();
匿名对象应用场景
说明：匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。
匿名对象的局限性
上述代码结果：
null 学习中。。。。。
出现以上问题的原因如下图所示：
注意：只要在程序中使用new关键字创建对象，那么在堆中都会有一个新的对象产生。
注意：匿名对象通常是在对象只需要访问成员一次的情况下使用
如果对象需要多次的操作成员，就不能使用匿名对象来访问。
注意：匿名对象可以简化代码的书写，但是匿名对象一旦使用结束，这时这个对象就立刻变成垃圾。
如果对象只使用一次，这时可以采用匿名对象，如果这个对象要使用多次，必须给对象起名。
匿名对象作为参数传递(理解)
需求：
1）定义一个Person类，在这个类中定义人的名字和年龄，并定义一个说话的功能;
2）再定义一个测试Person类的类PersonTest，在PersonTest类中定义一个功能，给所有的Person类的对象下的属性name和age进行相同数据的赋值，并调用Person类中的说话的方法。
class Person
{
String name;
int age;
void say()
{
System.out.println(name+"哇哇哇哇叫"+age);
}
}
class PersonTest1
{
public static void main(String[] args)
{
//创建person对象
/*Person person =new Person();
demo(person);
Person person1 =new Person();
demo(person1);
Person person2 =new Person();
demo(person2);
上述程序中创建的Person对象的引用，仅仅是为了把对象传递给demo函数，
这时也可以使用匿名对象传递对象
*/
demo(new Person());
}
/*
定义一个函数给Person类中的属性赋值，并调用Person类中的方法
*/
public static void demo(Person p)//Person p=new Person();
{
p.name="baby";
p.age=1;
p.say();
}
}
1.7代码实践：注册案例
# 需求说明：
1.按面向对象的思想将定义用户类
2.写一个控制台交互的程序，可以输入用户名，手机账号，登录密码，确认密码，电子邮箱，性别，生日，模拟实现注册功能。
3.将注册的用户保存到ArrayList集合中
代码实现：
User类：
package com.itheima.sh.a_demo_01;
// 1.创建用户类User
public class User {
// 2.在User类中定义成员变量
private String username;
private String tel;
private String password;
private String repassword;//确认密码
private String email;
private String sex;
private String birthday;
//3.提供构造方法
public User(String username, String tel, String password, String repassword, String email, String sex, String birthday) {
this.username = username;
this.tel = tel;
this.password = password;
this.repassword = repassword;
this.email = email;
this.sex = sex;
this.birthday = birthday;
}
public User() {
}
// set get
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getRepassword() {
return repassword;
}
public void setRepassword(String repassword) {
this.repassword = repassword;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getBirthday() {
return birthday;
}
public void setBirthday(String birthday) {
this.birthday = birthday;
}
// toString(后面学习) ---使用快捷键：alt+insert
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", tel='" + tel + '\'' +
", password='" + password + '\'' +
", repassword='" + repassword + '\'' +
", email='" + email + '\'' +
", sex='" + sex + '\'' +
", birthday='" + birthday + '\'' +
'}';
}
}
测试类：
package com.itheima.sh.a_demo_01;
import java.util.ArrayList;
import java.util.Scanner;
/*
步骤：
1.创建用户类User
2.在User类中定义成员变量
3.提供构造方法 set get toString(后面学习) ---使用快捷键：alt+insert
4.在测试类中创建ArrayList集合存储User对象，泛型User
5.创建键盘录入的对象
6.提示录入的信息
7.获取录入的信息 锁哥
8.创建User对象给类中的成员变量赋值
9.将User对象存储到集合中
10.打印集合，输出信息
11.使用死循环控制键盘一直可以录入用户信息
*/
public class Test02 {
public static void main(String[] args) {
//4.在测试类中创建ArrayList集合存储User对象，泛型User
ArrayList<User> list = new ArrayList<>();
//5.创建键盘录入的对象
Scanner sc = new Scanner(System.in);
//使用死循环控制键盘一直可以录入用户信息
while (true) {
//6.提示录入的信息
System.out.println("请输入用户名:");
//7.获取录入的信息 锁哥
String username = sc.nextLine();
System.out.println("请输入手机号:");
String tel = sc.nextLine();
System.out.println("请输入登录密码:");
String password = sc.nextLine();
System.out.println("请输入确认密码:");
String repassword = sc.nextLine();
System.out.println("请输入邮箱:");
String email = sc.nextLine();
System.out.println("请输入性别:");
String sex = sc.nextLine();
System.out.println("请输入生日:");
String birthday = sc.nextLine();
//8.创建User对象给类中的成员变量赋值
User user = new User(username, tel, password, repassword, email, sex, birthday);
//9.将User对象存储到集合中
list.add(user);
//10.打印集合，输出信息
System.out.println(list);
}
}
}
第二章 继承(掌握)
2.1继承概述
2.1.1 继承引入
面向对象语言三大基本特征：
封装（private）、继承(extends)、多态
Java中的类是描述生活中的任何事物的。而在生活中任何事物之间必然会存在一些联系。那么我们在前面学习的过程中，仅仅只是在描述单个的事物，并没把握事物和事物之间的关系。
接下来我们要研究的是如何通过Java中的类，展示所描述的事物和事物之间的关系。
一般事物和事物之间会有继承的关系。在Java中我们的类就是描述事物的，那么也就是说我们的类之间也应该存在继承的关系。
需求：
分别描述学生和老师两个类。
学生：
属性：年龄、性别、姓名
行为：学习、吃饭
定义构造函数给属性初始化
老师：
属性：年龄、性别、姓名、薪水
行为：上课、吃饭
定义构造函数给属性初始化.
代码如下所示：
/*
学生：
属性：年龄、性别、姓名
行为：学习、吃饭
*/
class Student
{
String name;
int age;
String sex;
Student( String name , int age , String sex )
{
this.name = name;
this.age = age;
this.sex = sex;
}
//行为
void study()
{
System.out.println(name+"在 学习 java ......");
}
void eat()
{
System.out.println("吃饭.......");
}
}
/*
老师：
属性：年龄、性别、姓名、薪水
行为：上课、吃饭
*/
class Teacher
{
String name;
int age;
String sex;
double salary;
Teacher( String name , int age , String sex , double salary )
{
this.name = name;
this.age = age;
this.sex = sex;
this.salary = salary;
}
void teach()
{
System.out.println(name+"正在讲 Java....");
}
void eat()
{
System.out.println("吃饭.......");
}
}
上述程序在描述学生和老师这2类事物，但是学生和老师这两类事物中有共同的属性和行为，我们应该只描述一次就可以了，然后让学生和老师共享这些属性和行为。
把学生和老师中的共性行为和属性进行抽取。抽取到哪里合适呢？
在描述事物的时候，发现描述的两个事物之间没有继承的关系，但是2个事物之间有共同的属性和行为，那么我们就找这2个事物的共同祖先。
学生和老师，没有继承关系，但是学生和老师都属于人这类事物。那么我们就可以把学生和老师的共性内容抽取到人这个类中，然后让学生和老师与人这个类产生关系即可。
其中，多个类可以称为子类，单独被继承的那一个类称为父类、超类（superclass）或者基类。
2.1.2 继承的含义
继承描述的是事物之间的所属关系。例如，兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。
继承：就是子类继承父类的属性和行为，使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。
2.1.3 Java中的继承体现
需求：把学生和老师中的共性内容抽取到人这个类中
然后分别建立学生、老师和人的关系，可以让学生和老师使用人类中的属性和方法。
怎么建立Person类和Student类还有Teacher类之间的关系？
在java中使用关键字extends 建立类和类之间的关系，extends在java中表示继承的意思。
关键字extends的使用格式：
classs 类1 extends 类2
{
//代码
}
说明：类1叫做子类。类2叫做父类
代码如下：
/*
把学生和老师中的共性内容抽取到人这个类中
*/
class Person
{
String name;
int age;
String sex;
void eat()
{
System.out.println("吃饭.......");
}
}
/*
学生：
属性：年龄、性别、姓名
行为：学习、吃饭
*/
class Student extends Person
{
Student( String name , int age , String sex )
{
this.name = name;
this.age = age;
this.sex = sex;
}
//行为
void study()
{
System.out.println(name+"在 学习 java ......");
}
}
/*
老师：
属性：年龄、性别、姓名、薪水
行为：上课、吃饭
*/
class Teacher extends Person
{
double salary;
Teacher( String name , int age , String sex , double salary )
{
this.name = name;
this.age = age;
this.sex = sex;
this.salary = salary;
}
void teach()
{
System.out.println(name+"正在讲 Java....");
}
}
class ExtendsDemo2
{
public static void main(String[] args)
{
Student s = new Student("张三",23,"男");
s.eat();
s.study();
Teacher t = new Teacher("黑旋风",28,"男",9999.99);
t.eat();
t.teach();
}
}
Java中的继承代码体现：
当某个类需要继承其他类的时候，在当前定义这个类的地方使用 extends 关键字，然后让这个类去继承需要继承的其他类。
这时被继承的类称为 父类。 实现继承的这个类称为 子类。
例如：
classs 类1 **extends** 类2
{
//代码
}
类2就是父类，类1就是子类。
在Java的继承语法中，只要使用extends 关键字 任何2个类之间都可以完成继承。但是我们在写程序的时候，一定要心里清楚2个类之间有没有联系，能不能继承。
2.1.4 继承的好处
-
提高代码的复用性（减少代码冗余，相同代码重复利用）。
-
使类与类之间产生了关系。
2.1.5 案例训练：传智教育的tlias学员教学质量管理系统角色
【1】需求
在传智教育的tlias学员教学质量管理系统中，存在如下角色会进入系统：学生、老师。不同角色类存在独有属性和行为，请看清单。
角色属性和功能简要清单：
学生（名称，课程名称，所在班级，查看课表，填写反馈数据）
老师（名称，课程名称，部门名称，查看课表，发布试题）
【2】分析
父类：
用户类（名称，课程名称，查看课表）
子类：
学生（所在班级，填写反馈数据）
老师（部门名称，发布试题）
【3】代码实现
-
父类，User类
package com.itheima.sh.b_extends_02;
//1.定义父类User
public class User {
//2.在父类中定义成员变量：用户名
private String username;
private String classname;//课程名
//构造方法
public User() {
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getClassname() {
return classname;
}
public void setClassname(String classname) {
this.classname = classname;
}
// 成员方法：查看课表
public void lookSchedule(){
System.out.println(this.username+"在查看课表");
}
} -
学生类Student
package com.itheima.sh.b_extends_02;
// 3.定义子类学生类，继承父类User
//继承格式：子类 extends 父类
public class Student extends User{
// 4.在子类中定义子类特有的成员变量：所在班级
private String classRoom;
public Student() {
}
public String getClassRoom() {
return classRoom;
}
public void setClassRoom(String classRoom) {
this.classRoom = classRoom;
}
// 特有成员方法：填写反馈数据
public void writeData(){
System.out.println("来自于"+this.classRoom+"的学生:"+getUsername()+"学习了"+getClassname()+"之后再填写反馈");
}
} -
老师类Teacher
package com.itheima.sh.b_extends_02;
//5.定义子类老师类，继承父类User
public class Teacher extends User {
//6.在子类老师类中定义子类特有的成员变量：部门名称
private String deptName;
public Teacher() {
}
public String getDeptName() {
return deptName;
}
public void setDeptName(String deptName) {
this.deptName = deptName;
}
// 特有成员方法：发布试题
public void releaseTest(){
System.out.println("来自于"+this.deptName+"的老师:"+getUsername()+"讲解了"+getClassname()+"之后发布试题");
}
} -
测试类
package com.itheima.sh.b_extends_02;
/*
步骤：
1.定义父类User
2.在父类中定义成员变量：用户名 课程名 成员方法：查看课表
3.定义子类学生类，继承父类User
4.在子类中定义子类特有的成员变量：所在班级 特有成员方法：填写反馈数据
5.定义子类老师类，继承父类User
6.在子类老师类中定义子类特有的成员变量：部门名称 特有成员方法：发布试题
*/
public class Test01 {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
//给成员变量赋值
s.setUsername("柳岩");
s.setClassRoom("黑马126期");
s.setClassname("java");
s.writeData();
//创建老师对象
Teacher t = new Teacher();
t.setUsername("锁哥");
t.setDeptName("java教研部");
t.setClassname("java");
t.releaseTest();
}
}
2.1.6 小结
1.继承实际上是子类相同的属性和行为可以定义在父类中，子类特有的属性和行为由自己定义，这样就实现了相同属性和行为的重复利用，从而提高了代码复用。
2.子类继承父类，就可以直接得到父类的成员变量和方法。是否可以继承所有成员呢？请看下节！
3.2 子类不能继承的内容
3.2.1 引入
并不是父类的所有内容都可以给子类继承的：
子类不能继承父类的构造器，因为子类有自己的构造器。
值得注意的是子类可以继承父类的私有成员（成员变量，方法），只是子类无法直接访问而已，可以通过getter/setter方法访问父类的private成员变量。
3.2.2 演示代码
class Fu {
public int num1 = 10;
private int num2 = 20;
public void show1() {
System.out.println("show1");
}
private void show2() {
System.out.println("show2");
}
public int getNum2() {
return num2;
}
public void setNum2(int num2) {
this.num2 = num2;
}
}
class Zi extends Fu {
}
public class Demo03 {
public static void main(String[] args) {
Zi z = new Zi();
System.out.println(z.num1);
// System.out.println(z.num2); // 私有的子类无法使用
// 通过getter/setter方法访问父类的private成员变量
System.out.println(z.getNum2());
z.show1();
// z.show2(); // 私有的子类无法使用
}
}
3.3 继承中的特点
1、Java只支持单继承，不支持多继承。
说明：
单继承：一个子类只能有一个父类。支持
多继承：一个子类可以有多个父类。不支持
//一个类只能有一个父类，不可以有多个父类。
class C extends A{} //ok
class C extends A，B... //error
2、Java支持多重继承(继承体系)。
说明：多重继承也叫做多层次继承
class A{}
class B extends A{}
class C extends B{}
顶层父类是Object类。所有的类默认继承Object，作为父类。
3.4 继承后的特点——成员变量
学习继承：围绕 类中的成员变量 、成员函数 、 构造函数的变化。
当类之间产生了继承关系后，其中各类中的成员变量，又产生了哪些影响呢？
需求：
1、分别定义一个父类和一个子类，让子类继承父类；
2、在父类中定义一个非静态成员变量x，并赋值为3；
3、在子类中定义一个非静态成员变量y,并赋值为10，同时定义一个一般非静态函数show,在这个函数中输出父类的成员变量x和子类的成员变量y的值；
4、定义一个测试类，在这个测试类中创建子类的对象，并使用子类的对象调用子类中的函数show。
//继承中成员变量的特点：
class Fu
{
int x = 3;
Fu()
{
System.out.println("this"+this);
}
}
class Zi extends Fu
{
int y = 10;
void show()
{
System.out.println("x="+x+",y="+y);
}
Zi()
{
System.out.println("this"+this);
}
}
class ExtendsDemo3
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();
}
}
在上述程序中 Zi 类 继承 Fu 类，在测试的程序中 我们仅仅只创建了 Zi类的对象，而没有创建Fu类的对象，但是在程序运行的过程中，使用到了Fu类中的成员变量，说明在程序中一定给Fu类的成员变量开辟了空间。
当子类继承了父类，在创建子类对象的时候，堆中的子类对象中会划分出一片空间来保存父类中的成员变量。
上述代码图解分析：
注意：加载到方法区的顺序：在jvm加载子类的时候，jvm会发现子类的字节码文件里面有一个extends标识，所以jvm会先将父类加载到方法区中，然后再将子类加载到方法区中。
上述代码创建子类对象，给堆中Zi类和Fu类中的成员变量分别隐式初始化值后，创建好的对象会去调用子类的无参构造函数，在执行无参构造函数里面的代码之前，会先执行隐式三步，即调用父类中的构造函数super().
在执行父类中构造函数的时候，同样也有隐式三步，那么父类中的super(),会去调用所有类的上帝类Object类，然后第二步给父类中成员变量x显示赋值，由于没有代码块，然后jvm回到子类构造函数中继续执行隐式第二步。
即给子类中成员变量y显示初始化值，由于子类也没有构造代码块，那么jvm会开始执行子类构造函数内容。
3.4.1 成员变量重名
子父类中出现了同名的成员变量，如何在子类中访问父类的成员变量？
如果在子类中要访问父类中的成员变量，可以使用super关键字。在Java中super关键字主要是用来在子类中去访问父类的内容。
super有两个作用：
1) super.父类成员（变量，函数）super.x super.show()
2) super(参数); 访问父类的构造函数
需求：
1、分别定义一个父类和一个子类，让子类继承父类；
2、在父类中定义一个成员变量x，并赋值为3；
3、在子类中定义一个成员变量x,并赋值为10，同时定义一个一般非静态函数show,在这个函数中再定义一个局部变量 x并赋值为111，在show函数中先输出父类的成员变量x和子类的成员变量x的值；
4、最后在屏幕上输出父类成员变量、子类成员变量和子类局部变量的值；
4、定义一个测试类，在这个测试类中创建子类的对象，并使用子类的对象调用子类中的函数show。
//继承中子父类中出现同名的成员变量：
class Fu
{
int x = 3;
}
class Zi extends Fu
{
int x = 10;
void show()
{
//定义一个局部变量
int x = 111;
/*
如果子类和父类中的成员变量同名，怎样去访问父类中的成员?
使用super关键字
*/
//在屏幕上打印父类中成员变量和子类中的成员变量
//System.out.println("super.x="+super.x+”,x=”+x);
System.out.println("局部变量x="+x);
System.out.println("成员变量x="+this.x);
System.out.println("父类成员变量x="+super.x);
}
}
class ExtendsDemo4
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();
}
}
需要注意的是：
1.super代表的是父类的引用，也可以理解为是一个标记，标记哪个是父类。this代表的是当前对象的引用。
2.当子父类中存在一模一样的成员变量时，子类对象优先使用属于子类对象自己的成员变量，
如果想要让子类中使用父类的成员变量，需要使用关键字：super.父类成员变量名;
小贴士：Fu 类中的成员变量是非私有的，子类中可以直接访问。若Fu 类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？可以在父类中提供公共的getXxx方法和setXxx方法。
继承中的成员变量补充
package com.itheima.sh.c_extends_03;
public class GrandPa {
//成员变量
// int num = 10;
int num1 = 10;
}
package com.itheima.sh.c_extends_03;
public class Fu extends GrandPa{
//成员变量
int num = 20;
}
package com.itheima.sh.c_extends_03;
public class Zi extends Fu{
//成员变量
int num = 30;
public void test(){
System.out.println("本类成员变量:"+this.num);//30
System.out.println("父类成员变量:"+super.num);//20
System.out.println("爷爷类成员变量:"+super.num1);//10
}
}
package com.itheima.sh.c_extends_03;
public class Test01 {
public static void main(String[] args) {
Zi z = new Zi();
z.test();
}
}
结果：
本类成员变量:30
父类成员变量:20
爷爷类成员变量:10
3.5 继承后的特点—成员方法(很重要)
当类之间产生了关系，其中各类中的成员方法，又产生了哪些影响呢？
3.5.1 成员方法不重名
如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。代码如下：
class Fu {
public void show() {
System.out.println("Fu类中的show方法执行");
}
}
class Zi extends Fu {
public void show2() {
System.out.println("Zi类中的show2方法执行");
}
}
public class Demo05 {
public static void main(String[] args) {
Zi z = new Zi();
//子类中没有show方法，但是可以找到父类方法去执行
z.show();
z.show2();
}
}
3.5.2 成员方法重名
如果子类父类中出现重名的成员方法，则创建子类对象调用该方法的时候，子类对象会优先调用自己的方法。
代码如下：
class Fu {
public void show() {
System.out.println("Fu show");
}
}
class Zi extends Fu {
//子类重写了父类的show方法
public void show() {
System.out.println("Zi show");
}
}
public class ExtendsDemo05{
public static void main(String[] args) {
Zi z = new Zi();
// 子类中有show方法，只执行重写后的show方法
z.show(); // Zi show
}
}
3.6 方法重写
3.6.1 概念
方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。
3.6.2 使用场景与案例
发生在子父类之间的关系。 子类继承了父类的方法，但是子类觉得父类的这方法不足以满足自己的需求，子类重新写了一个与父类同名的方法，以便覆盖父类的该方 法。
案例演示：
1）旧手机功能：基本的打电话，发信息 2）新手功功能：基本的打电话下支持视频通话，基本的发信息下支持发送语音和图片。 定义旧手机类，实现打电话，发信息功能。定义新手机类继承老手机，重写打电话和发信息功能。
package com.itheima.sh.d_extends_04;
//1.定义一个旧手机类
public class OldPhone {
//2.在旧手机类中定义打电话
public void call(){
System.out.println("旧手机只能打电话");
}
//和发短信功能
public void sendMessage(){
System.out.println("旧手机只能发短信");
}
}
package com.itheima.sh.d_extends_04;
// 3.定义一个新手机类继承旧手机
public class NewPhone extends OldPhone{
//4.在子类即新手机类中对旧手机的打电话和发短信功能进行重写即重新编写
//书写要重写的方法名回车
@Override
public void call() {
//调用的是父类的功能
super.call();
System.out.println("新手机除了打电话还可以视频通话");
}
@Override
public void sendMessage() {
//调用的是父类的功能
super.sendMessage();
System.out.println("新手机除了发短信还可以发图片");
}
}
package com.itheima.sh.d_extends_04;
/*
步骤：
1.定义一个旧手机类
2.在旧手机类中定义打电话和发短信功能
3.定义一个新手机类继承旧手机
4.在子类即新手机类中对旧手机的打电话和发短信功能进行重写即重新编写
5.在测试类中创建子类对象，使用对象调用方法
*/
public class Test01 {
public static void main(String[] args) {
//5.在测试类中创建子类对象，使用对象调用方法
NewPhone np = new NewPhone();
np.call();
np.sendMessage();
}
}
3.6.3 @Override重写注解
-
@Override:注解，重写注解校验！
-
这个注解标记的方法，就说明这个方法必须是重写父类的方法，否则编译阶段报错。
-
建议重写都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！
加上后的子类代码形式如下：
public class Cat extends Animal {
// 声明不变，重新实现
// 方法名称与父类全部一样，只是方法体中的功能重写写了！
@Override
public void cry(){
System.out.println("我们一起学猫叫，喵喵喵！喵的非常好听！");
}
}
3.6.4 注意事项
-
方法重写是发生在子父类之间的关系。
-
子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
-
子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。
3.7 继承后的特点—构造器
3.7.1 引入
当类之间产生了关系，其中各类中的构造器，又产生了哪些影响呢？ 首先我们要回忆两个事情，构造器的定义格式和作用。
-
构造器的名字是与类名一致的。所以子类是无法继承父类构造方法的。
-
构造器的作用是初始化对象成员变量数据的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个
super()，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。（先有爸爸，才能有儿子）
继承后子类构造器特点:子类所有构造器的第一行都会先调用父类的无参构造器，再执行自己
3.7.2 案例演示
在前面学习对象的创建流程中，在使用new关键字创建对象的时候，先在堆中给对象分配内存空间，接着给非静态的成员变量进行默认初始化，开始调用对应的构造函数。而在执行构造函数中有隐式的三步：
1、super(); 它是在调用自己的父类空参数的构造函数。
2、非静态成员变量显示赋值。
3、构造代码块运行。
4、本构造函数中的代码运行。
需求：
根据以下代码画图说明子父类构造函数的特点。
1）创建一个子类Zi和一个父类Fu,让这个子类来继承这个Fu类；
2）在Fu类中定义一个成员变量x并赋值为3，然后创建Fu类构造代码块，在这个Fu类代码块中打印x的值；
3）在Fu类中定义一个一般函数show，也打印x的值；
4）在Fu类中定义一个无参构造函数，随便打印一句话；
5）在Zi类中定义一个成员变量y并赋值为10，同样定义一个构造代码块，分别写两个打印语句打印x和y的值；
6）在子类中复写父类中show函数，并写两句语句，分别打印x和y的值；
7）在子类中定义一个构造函数，使用super()调用父类无参构造函数，在子类构造函数中打印一句话，调用show函数；
8）定义一个测试类ConstructorDemo ，在这个类中创建Zi类的对象；
//继承中的构造函数细节
class Fu
{
int x = 3;
{
System.out.println("Fu 构造代码块 x="+x);
}
Fu()
{
//super();
System.out.println("Fu的构造函数执行");
}
void show()
{
System.out.println("Fu show x="+x);
}
}
class Zi extends Fu
{
int y = 10;
{
System.out.println("Zi 的构造代码块 x="+x);
System.out.println("Zi 的构造代码块 y="+y);
}
Zi()
{
super();
System.out.println("Zi的构造函数执行。。。。。");
show();
}
void show()
{
System.out.println("Zi show x="+x);
System.out.println("Zi show y="+y);
}
}
class ConstructorDemo
{
public static void main(String[] args)
{
Zi z = new Zi();
}
}
注意：
1、在每个类中都调用父类中的构造函数，是因为子类继承了父类，子类要使用父类中的成员变量，所以调用父类中的构造函数是为了父类中的成员变量显示初始化使用的；
2、上述代码中由于父类的构造函数是Zi类对象来调用的，所以Fu类中的构造函数中this变量记录着Zi类对象的内存地址名；
上述代码的内存执行过程如下所示：
3.7.3 小结
-
子类构造器执行的时候，都会在第一行默认先调用父类无参数构造器一次。
-
子类构造器的第一行都隐含了一个super()去调用父类无参数构造器，super()可以省略不写。
3.8 super(...)和this(...)
3.8.1 引入
class Person {
private String name;
private int age;
public Person() {
System.out.println("父类无参");
}
// getter/setter省略
}
class Student extends Person {
private double score;
public Student() {
//super(); // 调用父类无参构造器,默认就存在，可以不写，必须再第一行
System.out.println("子类无参");
}
public Student(double score) {
//super(); // 调用父类无参构造器,默认就存在，可以不写，必须再第一行
this.score = score;
System.out.println("子类有参");
}
// getter/setter省略
}
public class Demo07 {
public static void main(String[] args) {
// 调用子类有参数构造器
Student s2 = new Student(99.9);
System.out.println(s2.getScore()); // 99.9
System.out.println(s2.getName()); // 输出 null
System.out.println(s2.getAge()); // 输出 0
}
}
我们发现，子类有参数构造器只是初始化了自己对象中的成员变量score，而父类中的成员变量name和age依然是没有数据的，怎么解决这个问题呢，我们可以借助与super(...)去调用父类构造器，以便初始化继承自父类对象的name和age.
3.8.2 super和this的用法格式
super和this完整的用法如下，其中this，super访问成员我们已经接触过了。
this.成员变量 -- 本类的
super.成员变量 -- 父类的
this.成员方法名() -- 本类的
super.成员方法名() -- 父类的
接下来我们使用调用构造器格式：
super(...) -- 调用父类的构造器，根据参数匹配确认
this(...) -- 调用本类的其他构造器，根据参数匹配确认
3.8.3 super(....)用法演示
代码如下：
class Person {
private String name ="凤姐";
private int age = 20;
public Person() {
System.out.println("父类无参");
}
public Person(String name , int age){
this.name = name ;
this.age = age ;
}
// getter/setter省略
}
class Student extends Person {
private double score = 100;
public Student() {
//super(); // 调用父类无参构造器,默认就存在，可以不写，必须再第一行
System.out.println("子类无参");
}
public Student(String name ， int age，double score) {
super(name ,age);// 调用父类有参构造器Person(String name , int age)初始化name和age
this.score = score;
System.out.println("子类有参");
}
// getter/setter省略
}
public class Demo07 {
public static void main(String[] args) {
// 调用子类有参数构造器
Student s2 = new Student("张三"，20，99);
System.out.println(s2.getScore()); // 99
System.out.println(s2.getName()); // 输出 张三
System.out.println(s2.getAge()); // 输出 20
}
}
注意：
子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。
super(..)是根据参数去确定调用父类哪个构造器的。
3.8.4 super(...)案例图解
父类空间优先于子类对象产生
在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造器调用时，一定先调用父类的构造器。理解图解如下：
3.8.5 this(...)用法演示
this(...)
-
默认是去找本类中的其他构造器，根据参数来确定具体调用哪一个构造器。
-
为了借用其他构造器的功能。
package com.itheima._08this和super调用构造器;
class Student{
private String name ;
private int age ;
private char sex ;
public Student() {
// 很弱，我的兄弟很牛逼啊，我可以调用其他构造器：Student(String name, int age, char sex)
this("徐干",21,'男');
}
public Student(String name, int age, char sex) {
this.name = name ;
this.age = age ;
this.sex = sex ;
}
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 char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}
/**
* this(...):
* 默认是去找本类中的其他构造器，根据参数来确定具体调用哪一个构造器。
* 为了借用其他构造器的功能。
*
*/
public class ThisDemo01 {
public static void main(String[] args) {
Student xuGan = new Student();
System.out.println(xuGan.getName()); // 输出:徐干
System.out.println(xuGan.getAge());// 输出:21
System.out.println(xuGan.getSex());// 输出： 男
}
}
3.8.6 小结
-
子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
-
super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。
-
super(..)和this(...)是根据参数去确定调用父类哪个构造器的。
-
super(..)可以调用父类构造器初始化继承自父类的成员变量的数据。
-
this(..)可以调用本类中的其他构造器。
第四章 抽象类
4.1抽象类的产生
父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。
使用类是描述生活中的某一类事物，但是事物和事物之间又有继承的关系，因此我们描述的类和类之间也会有继承关系存在。
在继承中，越往顶层父类中，其中描述的属性和行为更加的共性。
我们在描述事物的过程中，把共性的行为或属性不停的往父类中抽取，这样就会导致在父类中描述的行为越来越不具体，无法表示出事物的特有的特点。可是这时我们依然要进行抽取和简单的描述。
描述猫和狗：
猫：
吃鱼
抓老鼠
狗：
啃骨头
看家
狗和猫中有共性的吃的行为，这时我们可以抽取到父类动物类中，但是在动物类中，这个吃的行为的行为体是没有办法写的十分清楚和具体。
这时我们就需要使用Java中的抽象的概念来描述这个无法写清楚的行为。由于行为我们在Java中以函数的形式体现，也就是说这个函数就变成一个抽象的函数，一旦某个类中有了抽象的函数这个类就变成抽象类了。
对上述描述的猫和狗使用java代码体现出来：
1）定义两个类Cat和Dog类;
2）在Cat类中定义两个函数eat和catchMouse;
3）在Dog类中定义两个函数eat和lookHome;
4）定义一个测试类测试Cat和Dog类;
class Dog
{
void eat()
{
System.out.println("啃骨头");
}
void lookHome()
{
System.out.println("看家");
}
}
class Cat
{
void eat()
{
System.out.println("吃鱼");
}
void catchMouse()
{
System.out.println("抓老鼠");
}
}
class AbstractDemo
{
public static void main(String[] args)
{
Cat c = new Cat();
c.eat();
}
}
通过分析：以上程序中存在共性的内容
Cat类和Dog类中共性内容：
在上述两个类中都有吃的行为，遇到共性内容，需要向上抽取，抽取存放到类中：把共性内容封装到Animal类中。
我们把狗和猫中的eat行为抽取到了Animal类中，但是我们没有办法去明确具体的函数体代码，如果没有办法明确具体的函数体的时候，这时可以把函数体省略。在java中没有函数体的函数我们称为抽象的函数，这个函数必须使用Java中的抽象关键字修饰。抽象关键字：abstract
什么是abstract(抽象)？
当一个事物中的功能(函数)没有具体的实现时或对这个事物不能描述清楚时，这个事物称为抽象事物。
注意： 当一个类中有抽象方法的时候，这个类必须使用 抽象关键字修饰。
abstract(抽象)的用法如下所示：
//把狗和猫中的共性抽取到Animal类中
abstract class Animal
{
abstract void eat();
}
抽象类：
使用某个类描述事物的时候，如果这个类中在描述这个事物的某个行为或功能的时候，只知道这个事物有这个行为或功能，但没有办法书写清楚具体的功能体，函数体，这时可以使用抽象函数来表示这个行为或功能，由于类中有抽象的函数，这个类就会变成抽象类。
当一个类继承某个抽象类，这时这个类要把这个抽象类中的所有抽象方法全部复写。
//把狗和猫中的共性抽取到Animal类中
abstract class Animal
{
abstract void eat();
}
class Dog extends Animal
{
void eat()
{
System.out.println("啃骨头");
}
void lookHome()
{
System.out.println("看家");
}
}
class Cat extends Animal
{
//复写Animal类中的抽象函数eat
void eat()
{
System.out.println("吃鱼");
}
void catchMouse()
{
System.out.println("抓老鼠");
}
}
class AbstractDemo
{
public static void main(String[] args)
{
Cat c = new Cat();
c.eat();
}
}
4.2抽象类案例_加油站收银系统
【1】系统需求： 某加油站推出了2种支付卡，一种是预存10000的金卡，后续加油享受8折优惠。 另一种是预存5000的银卡 ,后续加油享受8.5折优惠。
请分别实现2种卡片进入收银系统后的逻辑，卡片需要包含主人名称，余额， 支付功能。
【2】分析实现 创建一张卡片父类：定义属性包括主人名称、余额、支付功能（具体实现交给子类） 创建一张金卡类：重写支付功能，按照原价的8折计算输出。 创建一张银卡类：重写支付功能，按照原价的8.5折计算输出。
【3】代码实现
package com.itheima.sh.test02;
public abstract class Card {
//成员变量
private String username;
private double leftMoney;
public Card(String username, double leftMoney) {
this.username = username;
this.leftMoney = leftMoney;
}
public Card() {
}
//方法
public abstract void pay(double money);
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public double getLeftMoney() {
return leftMoney;
}
public void setLeftMoney(double leftMoney) {
this.leftMoney = leftMoney;
}
}
package com.itheima.sh.test02;
public class GoldCard extends Card {
public GoldCard(String username, double leftMoney) {
super(username, leftMoney);
}
public GoldCard() {
}
@Override
public void pay(double money) {
double leftMoney = getLeftMoney() - money * 0.8;
setLeftMoney(leftMoney);
System.out.println(getUsername()+"的卡是金卡，加油享受8折优惠，油价是:"+money*0.8+",余额是:"+leftMoney);
}
}
package com.itheima.sh.test02;
public class SilverCard extends Card{
public SilverCard(String username, double leftMoney) {
super(username, leftMoney);
}
public SilverCard() {
}
@Override
public void pay(double money) {
double leftMoney = getLeftMoney() - money * 0.85;
setLeftMoney(leftMoney);
System.out.println(getUsername()+"的卡是银卡，加油享受8.5折优惠，油价是:"+money*0.85+",余额是:"+leftMoney);
}
}
package com.itheima.sh.test02;
public class Test02 {
public static void main(String[] args) {
//创建金卡对象
GoldCard goldCard = new GoldCard("土豪",10000);
goldCard.pay(300);
//创建银卡对象
SilverCard silverCard = new SilverCard("张三", 5000);
silverCard.pay(300);
}
}
4.2 注意事项
关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。
1、子类在继承抽象类后，需要把抽象类中所有的抽象方法全部复写(重写)完成。
抽象类中定义所有子类的共性行为，然后由具体的子类针对自己的实际情况复写父类提供的基本行为，建立适合自己的功能体。
2、抽象类和一般类有什么区别？
抽象类肯定需要abstract修饰，一般类不能使用。
不管是抽象类，还是一般类，它们都是描述事物体系中的某个事物，只不过抽象类描述的一定是这个事物体系中的共性内容，抽象类不一定是最顶层的类，但一定不是最底层的类。
3、抽象类有没有构造函数，能不能创建对象？
有构造函数，但不能创建对象。
构造函数是给成员变量初始化的，抽象类中的构造函数就是为了子类对象初始化使用的，因为抽象类一定有子类，而创建子类对象的时候，在子类的构造函数中一定有super()语句会找自己的父类构造函数进行初始化动作。
需求：演示抽象类中可以有构造函数
1）定义一个抽象类Animal作为父类，在这个父类中定义一个带有一个参数的构造函数，接收子类传递过来的值，并打印；
2）在抽象类Animal中定义一个抽象函数eat；
3）再定义一个Cat猫类，让这个猫类继承Animal类，在这个Cat类中定义一个构造函数，在构造函数中使用super调用Animal中的构造函数；
4）在类Cat中复写eat函数；
5）定义一个测试抽象类，并在这个类中创建Cat的对象；
abstract class Animal
{
Animal(int b)//抽象类中的有参构造函数
{
System.out.println(b);
}
abstract void eat();
}
class Cat extends Animal
{
Cat()
{
super(3);
}
void eat(){}
}
class AbstractDemo
{
public static void main(String[] args)
{
Cat c=new Cat();
}
}
演示抽象类不能实例化，也就是说抽象类不能创建对象。
抽象类一定是个类，类中肯定就会有构造函数。抽象类不能创建对象的原因是抽象类中有抽象函数，如果我们可以直接创建抽象类的对象，那么就可以使用这个对象调用那个抽象函数，而抽象函数是没有函数体的函数，调用函数的最终目的是需要函数体的执行，完成我们想要的结果。因此我们如果可以创建抽象类的对象，那么就会导致可以调用抽象函数，而调用了抽象函数，却得不到任何想要的效果。这样的做法没有意义。因此sun公司在指定抽象类的规则时，不让程序直接创建抽象类的对象。
4、抽象类一定是父类吗？
一定是父类，一定不是顶层父类。
抽象类中通常都有抽象函数，而抽象类中的抽象函数要求必须由子类来复写（由具体的子类来实现其中的函数体）。
子类的主要作用是复写抽象类中的抽象函数。
5、抽象类可以继承其他类吗？
抽象类也是一个类，因此它必须具备类的继承特点。它可以有父类。
6、抽象关键字不能和哪些关键字共存？
private修饰符：表示私有的。
private ：父类中私有的成员，子类是不知道的，因此使用private 和abstract关键字一起修饰函数，导致子类根本无法知道父类中有个抽象函数，同时也导致了子类不能复写父类中的方法。
static修饰符：表示静态的。
static：如果使用static和abstract关键字一起修饰抽象函数，导致这个函数可以使用类名直接调用，而抽象函数是没有方法体的，调用这个抽象函数是没有意义的。
final修饰符：表示最终的。（先了解）
final ：final修饰的函数子类是无法复写的，而abstract修饰的函数，要求子类必须复写。
抽象类何时使用：
当描述事物体系，一般在描述所有体系中最共性的内容时，通常是只知道体系的共性功能，却不能书写具体功能体，这时会使用抽象函数表示，那么这个类一定会使用抽象类表示。
4.3 抽象类存在的意义
抽象类存在的意义是什么？
抽象类：在描述事物的时候，没有足够的信息描述一个事物，这时该事物就是抽象事物。
抽象类存在的意义和我们之前学过的父类存在思想是一样的，那么有父类到底有什么好处呢？父类有抽象和非抽象的，但是都一样，父类或抽象类的存在让我们面对事物发生了改变，我们不要再去面对具体的子类事物，直接面对父类就可以了。
将类定义为抽象类时，这样别人看到你的代码，或你看到别人的代码，你就会注意抽象方法，而知道这个方法是在子类中实现的，所以，有个提示作用。(子类一定要复写父类中的抽象方法)
举例：问你个问题，你知道什么是“东西”吗？什么是“物体”吗？
“麻烦你，小黑。帮我把那个东西拿过来好吗”
在生活中，你肯定用过这个词－－东西。
小黑：“你要让我帮你拿那个水杯吗？”
你要的是水杯类的对象。而东西是水杯的父类。通常东西类没有实例对象，但我们有时需要东西的引用指向它的子类实例。
总结：抽象类存在的意义是为了被子类继承，否则抽象类将毫无意义，抽象类体现的是模板思想，模板是通用的东西。模板中不能决定的东西定义成抽象方法，让使用模板（继承抽象类的类）的类去重写抽象方法实现需求，这是典型的模板思想。
4.4 第一个设计模式：模板模式
设计模式：解决问题的方案。最早起源于建筑领域。后来被应用到计算机领域。只要遇到相同问题，直接按照这种方式做就可以解决问题。在java中设计模式有23种。我们今天学习第一个设计模式：模板模式。
模板设计模式是一种行为设计模式，一般是准备一个抽象类，将部分逻辑以具体方法实现(带方法体)，然后声明一些抽象方法，这样可以强制子类实现剩余的逻辑。不同的子类以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。这就是模板设计模式能达成的功能。
适用于一些复杂操作进行步骤分割、抽取公共部分由抽象父类实现、将不同的部分在父类中定义抽象实现、而将具体实现过程由子类完成。对于整体步骤很固定，但是某些部分易变，可以将易变的部分抽取出来，供子类实现。
角色：
抽象类：
1）定义了一个或多个抽象方法，以便让子类实现。这些抽象方法叫做基本操作，它们是一个顶级逻辑的组成步骤。
2）定义带方法体的方法。这些方法一般是一个具体方法(带方法体)，它给出了一个顶级逻辑的骨架，而逻辑的组成步骤在相应的抽象操作中，推迟到子类实现。
具体类：
1） 实现父类所定义的一个或多个抽象方法，它们是一个顶级逻辑的组成步骤。
2） 每一个抽象模板角色都可以有任意多个具体模板角色与之对应，而每一个具体模板角色都可以给出这些抽象方法（也就是顶级逻辑的组成步骤）的不同实现，从而使得顶级逻辑的实现各不相同。
实现抽象类中的抽象方法，完成特定的算法
我们现在使用抽象类设计一个模板模式的应用，例如在小学的时候，我们经常写作文，通常都是有模板可以套用的。假如我现在需要定义新司机和老司机类，新司机和老司机都有开车功能，开车的步骤都一样，只是驾驶时的姿势有点不同，新司机:开门,点火,双手紧握方向盘,刹车,熄火，老司机:开门,点火,右手握方向盘左手抽烟,刹车,熄火。我们可以将固定流程写到父类中，不同的地方就定义成抽象方法，让不同的子类去重写，代码如下:
// 司机开车的模板类
public abstract class Driver {
public void go() {
System.out.println("开门");
System.out.println("点火");
// 开车姿势不确定?定义为抽象方法
ziShi();
System.out.println("刹车");
System.out.println("熄火");
}
public abstract void ziShi();
}
现在定义两个使用模板的司机：
public class NewDriver extends Driver {
@Override
public void ziShi() {
System.out.println("新司机双手紧握方向盘");
}
}
public class OldDriver extends Driver {
@Override
public void ziShi() {
System.out.println("老司机右手握方向盘左手抽烟...");
}
}
编写测试类
public class Demo02 {
public static void main(String[] args) {
NewDriver nd = new NewDriver();
nd.go();
OldDriver od = new OldDriver();
od.go();
}
}
运行效果
可以看出，模板模式的优势是，模板已经定义了通用架构，使用者只需要关心自己需要实现的功能即可！非常的强大！
浙公网安备 33010602011771号