成员变量与局部变量的区别

1）在类中的位置不同
成员变量：在类中方法外面
局部变量：在方法或者代码块中，或者方法的声明上（即在参数列表中）
2）在内存中的位置不同，可以看看Java程序内存的简单分析
成员变量：在堆中（方法区中的静态区）
局部变量：在栈中
3）生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用或者代码块的执行而存在，随着方法的调用完毕或者代码块的执行完毕而消失
4）初始值
成员变量：有默认初始值
局部变量：没有默认初始值，使用之前需要赋值，否则编译器会报错（The local variable xxx may not have been initialized）

1. 写代码时，什么场景下可以使用继承，为了解决什么问题 ？

一个类中有多个同属性的成员变量 那么就可以写在一个父类中 不同的成员变量就写在自己所分属的类中 解决了代码的重复编写问题 提高了代码的复用性

2. 具体使用代码举例子说明继承 ？

Student 类 Teacher类
同样的成员变量 name age 可写在一个父类中
别的不同的成员变量写在各自的类中
如果需要调用 可直接使用子类名.extends父类名 进行使用！

3.继承的三个特点是什么 ？

单继承 不可多继承 可多层继承

A-B-C-D （允许继承方式）

B
/
A （ 不可以这样继承）
\
C

4.继承中成员变量和成员方法的访问特点是什么 ？

就近原则 先找本类 本类没有找父类

5.继承中什么叫方法的重写，怎么重写方法 ？

子类和父类中有了一模一样的方法 （方法名，参数列表）
声明不变，重新实现
重新方法名和参数列表需要一致，对方法体重新定义

6. 继承中构造方法的执行流程是怎样的？

子类通过 super，手动调用父类的带参的构造方法

7.继承中子类如果要访问父类的构造方法，如何访问 ?
super.(参数)；

8.讨论super和this之间的区别 ？

this 代表的是本类对象的引用
spuer 代表父类储存空间
this 和 super本质还是同一对象，this空间包含了super空间

9.什么场景下可以使用抽象类。怎么定义抽象类，抽象方法？

父类创建的方法 每个子类要对其进行使用时 使用的内容不同，
此时父类定义这个方法就可以定义为抽象方法，类也必须同步成为抽象类！

抽象类：
public abstract class 类名{ }
抽象方法：
public abstract 返回值类型 方法名(参数列表);

10.抽象类能直接创建对象么，如果不能需要怎么用？

不能直接创建对象， 需要重新定义一个构造方法

11.请用自己的话描述，什么叫做设计模式 ?

通过多方测试实验后，提供给人使用的简洁的，一看就懂的代码模板，既提高了代码的安全性，又充分利用到了代码的复用性！

12.请用自己的话描述，模板方法设计模式是为了解决什么问题 ?

//解决一个问题的通用思想

为了解决模块过于死板，避免使用者不能随时提取自己想要编写的模板区域进行编写内容，
而利用在抽象类中定义抽象方法，就可以实现这种随提随用的功能，便捷使用者对代码的自由编写。

13.讨论下课堂中写作文案例为什么可以用模板方法设计模式，用代码重新实现下 ？

是为了解决一类问题，这种问题的解决需要相对于固定的一个步骤流程

因为模板已经创建了一种通用的格式，可以随意创建新的接收 来调用编写里面抽象方法中的内容。

模板的类：

public abstract class WorkRj {

public void write() {
System.out.println(“《Java的大咖》”);
zuozhe();
neirong();
System.out.println(“java大咖就是这样诞生的！”);
}

public abstract void neirong();

public abstract void zuozhe();
}

class james extends WorkRj {

@Override
public void zuozhe() {
System.out.println(“作者：James \n”);
}

@Override
public void neirong() {
System.out.println(“这是james的作文! \n”);
}
}

class boi extends WorkRj {

@Override
public void zuozhe() {
System.out.println(“作者：boi \n”);
}

@Override
public void neirong () {
System.out.println(“这是boi的作文 \n”);

}
}

模板的对象：

public class WorkSc {
public static void main(String[] args) {
james j1=new james();
j1.write();
boi b1=new boi();
b1.write(); }}
静态成员特点：
1 > 静态成员可以被本类所有对象的共享。
2 > 静态成员可以通过类名调用也可以通过对象调用，推荐使用类名调用！
3 > 静态成员随着类和加载而加载，优先于对象存在

静态方法的注意事项：
1. 非静态方法可以访问任何成员
2. 静态方法中只能访问静态成员，要想访问非静态成员需要使用对象调用
3. 静态方法中不能使用this关键字

继承入门

为了解决同属性代码的重复编写，将俩个类中的共性成员提出了 交给一个父类，然后让俩个子类用（public class 子类名extends 父类名 {…}）去继承这个父类，
就可以实现父类中的实现父类中的属性方法。
三大特性：
1. 提供代码的复用性
2. 提供代码的维护性
3. 让类与类产生关系，是多态的前提

Java中的类只支持单继承，多层继承。 不支持多继承。

子类的特有功能 不能放在父类中，这会导致其他继承父类的子类也会拥有这些属性和行为，这与Java严谨性违背。

继承成员变量访问

父类中的私有成员（private方法定义）子类不能直接访问，需要使用get，set方法。

子类继承父类后访问变量规则：就近原则

子类局部范围>子类成员范围>父类成员范围
Num this.num super.num

继承成员方法访问

通过对象名访问同一个方法：就近原则
1. 本类范围
**2. 父类成员范围

本类范围 > 父类成员范围
**方法名 super.方法名

继承方法重写

方法重写：
子类是父类出现了一模一样的方法（方法名，参数列表）

应用场景：

子类需要父类的功能，但父类的功能不满足自己的需要，子类可以重写父类中的方法，这样沿袭了父类的功能，有定义了子类特有的功能。
私有方法不能被重写
子类重写父类方法时，子类方法访问权限必须要大于或等于父类的定义权限。
（public > protected > 默认的 > private ）

如何快速重写方法：
声明不变，重写实现！ 快捷键 Ctrl+O 选择方法即可。
也就是之前的格式名字不改变，只改变括号中的输出内容，如果要继承父类原有的功能，可以用super.方法名。

继承中构造方法

子类中所以的构造方法默认都会访问父类中无参的构造方法

子类在初始化的时候，有可能会使用到父类中的数据，如果父类中的数据没有得到初始化 就会访问不到，所以当给子类进行初始化时，会先执行父类的无参构造方法，给父类的数据进行初始化。

如果父类中没有空参构造方法，只有带参构造方法，建议使用：
子类通过super，手动去调用父类带参构造方法。

注意：this.{…}和super.{…} 必须要在构造方法的第一行有效语句，俩者不能并存。
class Cat extends Animla {
public Cat() { //super.(); 这个super是默认存在的 不管你写不写都会默认执行！！ System.out.println(“子类的无参构造”);}
}**

抽象类

有抽象方法的类，一定是抽象类

但抽象类里面可以没有抽象方法

Abstract 抽象类的修饰关键字

抽象类中也可以有无参满参构造 正常私有公开变量也可以定义，但是抽象类不能创建对象（也就是不能实例化对象），抽象类天生就是当父类的，也就是创建子类后，让子类去继承他，并重写他里面所定义的方法，而子类要是不想变成抽象类 可以把所有的父类方法进行重写，否则会报错！

抽象类的定义：
Public abstract class 类名{}

抽象方法的定义：
Public abstract 返回值类型 方法名（参数列表）;
注意：抽象方法没有方法体 也就是没有大括号！

day01-匿名对象 , 继承 , 抽象类

今日目标

  • 面向对象回顾

  • 匿名对象介绍

  • 面向对象特征 - 继承

  • 抽象类的使用

  • 模板设计模式

1 面向对象回顾

  • 面向对象的核心思想是什么 ?
    • 用代码来模拟现实生活中的事物 , 比如学生类表示学生事物 , 对象表示的就是具体的学生 , 有了类就可以描述万千世界所有的事物了

  • 现有的类还是先有的对象 ?
    • 对象是根据类创建出来的 , 所有现有的类 , 再有对象

  • Java类的创建 ?
    • 类名建议使用大驼峰命名法 , 每个单词首字母需要大写
    • Java规定 , 一个Java文件中可以定义多个类 , 但是只能有一个类使用public修饰 , public修饰的类名需要和java文件名保持一致
    • 按照规范 , 实际工作之时 , 建议一个Java文件中只能有一个类

  • 类中的组成成分 ?
    • 1 成员变量
    • 2 成员方法
    • 3 构造方法
    • 4 内部类(后面学)
    • 5 代码块(后面学)

  • 创建对象所使用的关键字 ?
    • new关键字

  • 创建对象的格式 ?
    • 类名 对象名 = new 类名(参数列表);

  • 调用对象的成员 ?
    • 调用成员变量 : 对象名.成员变量名
    • 调用成员方法 : 对象名.成员方法名(参数)

  • 定义构造方法的格式 ?
    • 修饰符 类名(参数){ … }

  • 定义构造方法的特点 ?
    • 没有返回值 , 连void都没有
    • 方法名与类名相同
    • 构造方法可以进行重载定义

  • 构造方法的作用 ?
    • 空参构造 : 初始化对象的数据为默认值
    • 有参构造 : 初始化对象时 , 为对象的属性赋值

  • 面向对象三大特征是什么 ?
    • 封装 , 继承 , 多态

  • 封装的思想及其作用 ?
    • 思想 : 把实现细节隐藏 , 对外提供公共的访问方式
    • 作用 : 提高代码的安全性 , 提高代码的复用性

  • 封装的步骤 ?
    • 把成员变量进行private修饰
    • 提供对应的setter和getter方法

  • this关键字的含义 ?
    • this代表的是本类对象的引用
    • 在构造方法中 , this代表的是new的对象
    • 在成员方法中 , this代表的是调用此方法的对象

  • this关键字的作用 ?
    • 主要用于区分局部变量和成员变量同名的问题

2 匿名对象介绍

  • 什么是匿名对象 ?
    • 没有变量接收的对象 , 称作为匿名对象

  • 匿名对象的使用 ?
    • 直接使用匿名对象调用方法
    • 匿名对象作为方法传参
    • 匿名对象作为方法的返回值
  • 代码实现
    ```java package com.itheima.anonymous;

/* 匿名对象 : 没有对象名接收的对象 , 称作为匿名对象 有对象名接收的对象 , 称作有名对象

  1. 注意 : 一般使用一次的对象 , 我们可以采用匿名对象
  3. 匿名对象的使用 :
  4.     1 使用匿名对象直接调用方法
  5.     2 使用匿名对象作为方法的传参
  6.     3 使用匿名对象作为方法的返回值

*/ public class Demo1 { public static void main(String[] args) {

// Student s = new Student(); // s.study(); // 1 使用匿名对象直接调用方法 new Student().study();

// Student s2 = new Student(); // useStudent(s2); // 2 使用匿名对象作为方法的传参 useStudent(new Student()); }

  1. public static void useStudent(Student s) {
  2.     s.study();
  3. }
  5. public static Student getStudent() {

// Student s = new Student(); // return s; // 3 使用匿名对象作为方法的返回值 return new Student(); } } class Student { public void study() { System.out.println(“学生学习…”); } }

  2. -  <br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/26714721/1650955798620-b52cc946-fa62-4610-b9cc-e8dc467bc568.png#clientId=ua08f1451-60ae-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=372&id=ufc6f791f&margin=%5Bobject%20Object%5D&name=image.png&originHeight=744&originWidth=1335&originalType=binary&ratio=1&rotation=0&showTitle=false&size=195085&status=done&style=none&taskId=u7f803522-75cf-4e1c-af28-209c8231649&title=&width=667.5)  
  3. <a name="abde630b"></a>
  4. ##### 代码实践：注册案例
  5. ```java
  6. package com.itheima.anonymous;
  8. import java.util.ArrayList;
  9. import java.util.Scanner;
  11. /*
  12.     需求 :
  13.         1 创建用户(User)对象 , 对象数据采用键盘录入而来
  14.         2 用户(User)包含的属性 :
  15.             用户名   (username)
  16.             手机号码 (phonNumber)
  17.             登录密码 (password)
  18.             确认密码 (confirm)
  19.             电子邮箱 (email)
  20.             性别     (sex)
  21.             出生日期 (birthday)
  22.         3 如果登录密码和确认密码不一致 , 重新输入
  23.         4 把用户(User)对象 ,添加到ArrayList集合中 , 打印集合对象即可
  24.  */
  25. public class Demo2 {
  26.     public static void main(String[] args) {
  27.         // 创建集合对象
  28.         ArrayList<User> list = new ArrayList<>();
  30.         // 创建键盘录入对象 , 录入用户的数据
  31.         Scanner sc = new Scanner(System.in);
  32.         System.out.println("请输入用户名:");
  33.         String username = sc.nextLine();
  34.         System.out.println("请输入手机号码:");
  35.         String phoneNumber = sc.nextLine();
  36.         System.out.println("请输入登录密码:");
  37.         String password = sc.nextLine();
  38.         System.out.println("请输入确认密码:");
  39.         // 如果登录密码 , 和确认密码不一致 , 需要重新输入确认密码
  40.         String confirm;
  41.         while (true) {
  42.             confirm = sc.nextLine();
  43.             if (password.equals(confirm)) {
  44.                 break;
  45.             } else {
  46.                 System.out.println("您输入的登录密码和确认密码不一致, 请重新输入...");
  47.             }
  48.         }
  49.         System.out.println("请输入电子邮箱:");
  50.         String email = sc.nextLine();
  51.         System.out.println("请输入性别:");
  52.         String sex = sc.nextLine();
  53.         System.out.println("请输入出生日期:");
  54.         String birthday = sc.nextLine();
  56.         // 把用户对象添加到集合中
  57.         list.add(new User(username, phoneNumber, password, confirm, email, sex, birthday));
  59.         // 遍历集合
  60.         for (int i = 0; i < list.size(); i++) {
  61.             // 获取集合中的用户对象
  62.             User u = list.get(i);
  63.             System.out.println(u.getUsername() + "---" + u.getPhonNumber() + "---" + u.getPassword() 
  64.             + "---" + u.getConfirm()  + "---" + u.getEmail() + "---" + u.getSex() + "---" + u.getBirthday() );
  65.         }
  66.     }
  67. }
  1. package com.itheima.anonymous;
  2. // 用户类
  3. public class User {
  4.     private String username;
  5.     private String phoneNumber;
  6.     private String password;
  7.     private String confirm;
  8.     private String email;
  9.     private String sex;
  10.     private String birthday;
  13.     public User() {
  14.     }
  16.     public User(String username, String phonNumber, String password, String confirm, String email, String sex, String birthday) {
  17.         this.username = username;
  18.         this.phoneNumber = phonNumber;
  19.         this.password = password;
  20.         this.confirm = confirm;
  21.         this.email = email;
  22.         this.sex = sex;
  23.         this.birthday = birthday;
  24.     }
  26.     public String getUsername() {
  27.         return username;
  28.     }
  30.     public void setUsername(String username) {
  31.         this.username = username;
  32.     }
  34.     public String getPhonNumber() {
  35.         return phoneNumber;
  36.     }
  38.     public void setPhonNumber(String phonNumber) {
  39.         this.phoneNumber = phonNumber;
  40.     }
  42.     public String getPassword() {
  43.         return password;
  44.     }
  46.     public void setPassword(String password) {
  47.         this.password = password;
  48.     }
  50.     public String getConfirm() {
  51.         return confirm;
  52.     }
  54.     public void setConfirm(String confirm) {
  55.         this.confirm = confirm;
  56.     }
  58.     public String getEmail() {
  59.         return email;
  60.     }
  62.     public void setEmail(String email) {
  63.         this.email = email;
  64.     }
  66.     public String getSex() {
  67.         return sex;
  68.     }
  70.     public void setSex(String sex) {
  71.         this.sex = sex;
  72.     }
  74.     public String getBirthday() {
  75.         return birthday;
  76.     }
  78.     public void setBirthday(String birthday) {
  79.         this.birthday = birthday;
  80.     }
  81. }

3 继承

3.1 为什么学习继承 ?

  • 继承是将多个类的相同属性和行为抽取到单独一个类中，那么多个类无需再定义这些共性属性和行为，只要继承这个单独类即可继承这些属性和行为了
  • 多个类称为子类（派生类），单独的这个类称为父类(基类 或超类)

3.2 继承的格式 ?

  • 使用关键字extends进行连接子类与父类
  • 举例 : public class Student extends People{ … }

3.3 继承的好处 ?

  • 提高代码的复用性
  • 提高代码的维护性
  • 让类与类产生了关系(继承关系) , 是多态的前提
  1. package com.itheima.extends_demo;
  2. /*
  4.     学生类 : 姓名(name) , 课程名称(course) , 所在班级(className)  , 查看课表(lookForm) , 填写反馈数据(write)
  5.     老师类 : 姓名(name) , 课程名称(course) , 部门名称(department) , 查看课表(lookForm) , 发布试题(release)
  7.     设计 : 把学生类 和 老师类的共性内容抽取到一个单独的类中(Person),存储共性内容
  8.     父类 : 姓名(name) , 课程名称(course) ,  查看课表(lookForm)
  10.  */
  11. public class ExtendsDemo1 {
  12.     public static void main(String[] args) {
  13.         Student s = new Student();
  15.         s.setName("张三");
  16.         s.setCourse("Java");
  17.         s.setClassName("三年二班");
  19.         s.lookForm();
  20.         s.write();
  21.     }
  22. }
  1. package com.itheima.extends_demo;
  2. /*
  3.     此类定义的是子类的共性成员
  4.  */
  5. public class Person {
  6.     private String name;
  7.     private String course;
  9.     public String getName() {
  10.         return name;
  11.     }
  13.     public void setName(String name) {
  14.         this.name = name;
  15.     }
  17.     public String getCourse() {
  18.         return course;
  19.     }
  21.     public void setCourse(String course) {
  22.         this.course = course;
  23.     }
  25.     public void lookForm(){
  26.         System.out.println("查看课表");
  27.     }
  29. }
  1. package com.itheima.extends_demo;
  2. /*
  3.     子类只需要定义自己特有的成员 , 共性的成员需要抽取到父类中
  4.  */
  5. public class Student extends Person{
  6.     private String className;
  8.     public String getClassName() {
  9.         return className;
  10.     }
  12.     public void setClassName(String className) {
  13.         this.className = className;
  14.     }
  16.     public void write(){
  17.         System.out.println("填写反馈数据");
  18.     }
  19. }
  1. package com.itheima.extends_demo;
  3. /*
  4.     子类只需要定义自己特有的成员 , 共性的成员需要抽取到父类中
  5.  */
  6. public class Teacher extends Person {
  8.     private String department;
  10.     public String getDepartment() {
  11.         return department;
  12.     }
  14.     public void setDepartment(String department) {
  15.         this.department = department;
  16.     }
  18.     public void release() {
  19.         System.out.println("发布试题....");
  20.     }
  21. }

3.5 继承后,子类对象内存图解

image.png

3.6 继承的特点

  • Java只支持单继承 , 不支持多继承 , 但是可以多层继承
    • 简单理解 : 一个儿子只能有一个亲爹

  • 为什么不支持多继承 ?
    • 因为一个子类如果继承多个父类 , 父类有相同的方法声明, 子类会产生继承冲突 , 所以不允许

3.7 继承中成员的发访问特点

  • 成员变量
    • 访问特点-就近原则 : 局部有访问局部的 , 局部没有访问本类成员的 , 本类成员没有访问父类非私有成员

  • 成员方法
    • 访问特点-就近原则 : 子类有调用子类的 , 子类没有调用父类的

  • 构造方法
    • 子类所有的构造方法都会默认去访问父类的空参数构造方法
      • 原因 : 因为子类在初始化时 , 可能会用到父类的数据 , 所以通过访问父类的构造 , 先给父类进行初始化
    • 如果进行初始化呢 ?
      • 每个构造方法中默认第一条语句都会有一个super()
    • 如果父类没有空参数构造 , 那么子类如果进行给父类初始化 ?
      • 子类可以通过super(…)访问父类的有参数构造方法
      • 子类通过this(..)访问子类的有参构造 , 在通过有参构造区访问父类的有参构造 , 不推荐
    • 注意事项 :
      • super(…) 和 this(…) 因为二者都需要放在构造方法的第一条可执行语句, 所以二者不能共存

3.8 方法重写

  • 什么是方法重写 ?
    • 子类和父类出现了一模一样的方法的声明(方法名 , 参数列表)

  • 为什么要学习方法重写 ?
    • 当子类需要使用父类的功能 , 但是父类的功能又满足不了子类 , 那么子类需要重写 , 这样既可以使用父类的功能 ,也可以增加新的功能

  • 如果进行方法重写 ?
    • 子类和父类的方法声明一样 , 方法体中的内容重新定义

  • Override注解是做什么的，有什么用？
    • @Override是放在重写后的方法上，作为重写是否正确的校验注解，加上该注解后如果重写错误，编译阶段会出现错误提示。建议重写方法都加@Override注解，代码安全，优雅！

  • 方法重写的注意事项 ?
    • 私有的方法无法重写
    • 重写的方法与被重写的方法 , 名字 , 参数列表需要保持一致
    • 子类重写父类方法时，子类方法访问权限必须大于或者等于父类方法权限 （暂时了解 ：缺省 < protected < public）
      • 一般保持一致即可

3.9 this和super关键字的区别

  • this : 代表的是本类的对象
  • super : 代表的是父类数据存储空间(可以看做成父类的对象)
  • 使用 :
    • 调用变量 :
      • this.变量名 : 访问本类的成员变量
      • super.变量名 : 访问父类的成员变量
    • 调用方法 :
      • this.方法名(…) : 访问本类的成员方法
      • super.方法名(…): 访问父类的成员方法
    • 调用构造 :
      • this.构造方法名(…) : 访问本类的构造方法
      • super.构造方法名(….) : 访问父类的构造方法

4 抽象类

4.1 抽象类 :

  • 抽象类其实就是为抽象方法提供存活的空间 , 需要在类的前面加上上abstract关键字进行修饰
  • 抽象类的作用主要是规范子类必须实现某种规则

4.2 抽象方法 :

  • 一个方法要么有方法体 , 要么是一个抽象方法

4.3 抽象类的注意事项 :

  • 抽象方法和抽象类必须使用abstract关键字进行修饰
  • 抽象类中可以抽象方法 , 也可以有非抽象方法 , 抽象方法必须存在抽象类中
    • 抽象方法的作用 : 让子类必须实现此功能
    • 非抽象方法的作用 : 让子类去继承此功能
  • 抽象类不能实例化
  • 抽象类的子类
    • 要么是一个抽象类
    • 要么重写所有的抽象方法
  1. /*
  2.     注意事项
  3.         1 抽象方法和抽象类必须用关键字 abstract
  4.         2 抽象类中可以有抽象方法 , 也可由非抽象方法
  5.           但是抽象方法必须存在抽象类中
  6.           非抽象方法 : 让子类去继承 , 提高代码的复用性
  7.           抽象方法 : 让子类必须完成某些功能(规范)
  8.         3 抽象类不能进行实例化(不能创建对象)
  9.         4 抽象的子类
  10.             要么重写所有的抽象方法
  11.             要么这个子类是一个抽象类
  13.         抽象类虽然不能创建对象 , 但是存在构造方法
  14.         构造方法存在的意义 : 让子类去通过super访问 , 从而给抽象类中的私有变量赋值
  15.  */
  16. public class AnimalTest {
  17.     public static void main(String[] args) {
  18.         // 抽象类不能进行实例化(不能创建对象)
  19.         // Animal a = new Animal();
  20.     }
  21. }
  1. // 抽象类案例
  2. public abstract class Animal {
  3.     private String breed;
  4.     private String color;
  6.     public Animal() {
  7.     }
  9.     public Animal(String breed, String color) {
  10.         this.breed = breed;
  11.         this.color = color;
  12.     }
  14.     public String getBreed() {
  15.         return breed;
  16.     }
  18.     public void setBreed(String breed) {
  19.         this.breed = breed;
  20.     }
  22.     public String getColor() {
  23.         return color;
  24.     }
  26.     public void setColor(String color) {
  27.         this.color = color;
  28.     }
  30.     // 抽象方法
  31.     public abstract void eat();
  33.     public void drink(){
  34.         System.out.println("喝水....");
  35.     }
  36. }
  1. public class Dog extends Animal{
  2.     public Dog(){
  3.     }
  5.     public Dog(String breed , String color){// breed = "边牧" ,color = "黑白"
  6.         super(breed , color);
  7.     }
  8.     @Override
  9.     public void eat() {
  10.         System.out.println("狗吃骨头!");
  11.     }
  12. }
  1. /*
  2.     需求：
  3.     定义猫类（Cat）和狗类（Dog）
  5.     猫类成员方法：eat（猫吃鱼）drink（喝水…）
  6.     狗类成员方法：eat（狗吃肉）drink（喝水…）
  8.     向上抽取父类 :
  9.         Animal类 : 品种 , 颜色 , eat（);  , drink（）{喝水…}
  11.  */
  12. public class AnimalTest {
  13.     public static void main(String[] args) {
  14.         // 空参构造 + set
  15. //        Dog d1 = new Dog();
  16. //        d1.setBreed("哈士奇");
  17. //        d1.setColor("黑白相间");
  18. //        System.out.println(d1.getBreed() + "---" + d1.getColor());
  19. //        d1.drink();
  20. //        d1.eat();
  22.         // 全参构造
  23.         Dog d2 = new Dog("边牧" , "黑白");
  24.         System.out.println(d2.getBreed() + "---" + d2.getColor());
  25.     }
  26. }

5 模板设计模式

5.1 设计模式

  • 一套良好的编码风格 , 经过众多的开发人员不断的测试总结而来

5.2 模板设计模式

  • 可以把抽象类 , 看做一个模板 , 非抽象方法理解为模板的通过格式 , 抽象方法是使用者具体完成的业务逻辑
  • 模板已经定义好了通用的结构 , 使用者只要关心自己需要的那部分实现的功能即可 
  1. public abstract class Template {
  3.     public void write() {
  4.         System.out.println("<<我的爸爸>>");
  6.         // 正文
  7.         body();
  9.         System.out.println("啊~这就是我的爸爸.");
  10.     }
  12.     public abstract void body();
  13. }
  15. public class Tom extends Template {
  16.     @Override
  17.     public void body() {
  18.         System.out.println("那是一个秋天 , 风儿那么缠绵 ,记忆中,那天爸爸骑车送我放学回家 , " +
  19.                 "我的脚卡在了自行车链中 , 爸爸蹬不动, 他就站起来蹬!"
  20.         );
  21.     }
  22. }
  24. public class Test {
  25.     public static void main(String[] args) {
  26.         Tom tom = new Tom();
  27.         tom.write();
  28.     }
  29. }