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

今日目标

  • 面向对象回顾
  • 匿名对象介绍
  • 面向对象特征 - 继承
  • 抽象类的使用

  • 模板设计模式

    1 面向对象回顾

  • 面向对象的核心思想是什么 ?

    • 用代码来模拟现实生活中的事物 , 比如学生类表示学生事物 , 对象表示的就是具体的学生 , 有了类就可以描述万千世界所有的事物了
  • 现有的类还是先有的对象 ?
    • 对象是根据类创建出来的 , 所有现有的类 , 再有对象
  • Java类的创建 ?
    • 类名建议使用大驼峰命名法 , 每个单词首字母需要大写
    • Java规定 , 一个Java文件中可以定义多个类 , 但是只能有一个类使用public修饰 , public修饰的类名需要和java文件名保持一致
    • 按照规范 , 实际工作之时 , 建议一个Java文件中只能有一个类
  • 类中的组成成分 ?
    • 1 成员变量
    • 2 成员方法
    • 3 构造方法
    • 4 内部类(后面学)
    • 5 代码块(后面学)
  • image.png
  • 创建对象所使用的关键字 ?
    • new关键字
  • 创建对象的格式 ?
    • 类名 对象名 = new 类名(参数列表);
  • 调用对象的成员 ?
    • 调用成员变量 : 对象名.成员变量名
    • 调用成员方法 : 对象名.成员方法名(参数)
  • 定义构造方法的格式 ?
    • 修饰符 类名(参数){ … }
  • 定义构造方法的特点 ?
    • 没有返回值 , 连void都没有
    • 方法名与类名相同
    • 构造方法可以进行重载定义
  • 构造方法的作用 ?
    • 空参构造 : 初始化对象的数据为默认值
    • 有参构造 : 初始化对象时 , 为对象的属性赋值
  • 面向对象三大特征是什么 ?
    • 封装 , 继承 , 多态
  • 封装的思想及其作用 ?
    • 思想 : 把实现细节隐藏 , 对外提供公共的访问方式
    • 作用 : 提高代码的安全性 , 提高代码的复用性
  • 封装的步骤 ?
    • 把成员变量进行private修饰
    • 提供对应的setter和getter方法
  • this关键字的含义 ?
    • this代表的是本类对象的引用
    • 在构造方法中 , this代表的是new的对象
    • 在成员方法中 , this代表的是调用此方法的对象

  • this关键字的作用 ?

    • 主要用于区分局部变量和成员变量同名的问题

      2 匿名对象介绍

  • 什么是匿名对象 ?

    • 没有变量接收的对象 , 称作为匿名对象
  • 匿名对象的使用 ?
    • 直接使用匿名对象调用方法
    • 匿名对象作为方法传参
    • 匿名对象作为方法的返回值

  • 代码实现

    1. package com.itheima.anonymous;
    2. /*
    3.   匿名对象 : 没有名字的对象,叫做匿名对象
    4.   一般一个对象使用一次 , 那么我们可以使用匿名对象 !
    5.   使用方式 :
    6.       1 直接调用方法
    7.       2 作为方法的参数传递  !!!
    8.       3 作为方法的返回值    !!!
    9.    注意 :
    10.        1 方法的参数是一个类 , 那么调用此方法需要传入此类的对象
    11.        2 方法的返回值类型是一个类 , 那么此方法需要返回此类的对象
    12. */
    13. public class Test1 {
    14.   public static void main(String[] args) {
    15.       //有名对象
    16.       Student stu = new Student();
    17.       stu.study();
    18.       stu.study();
    19.       stu.study();
    20.       System.out.println("============");
    21.       //匿名对象
    22.       new Student();
    23.       //匿名对象只能用一次，下一次new得到的匿名对象，是新的一个对象。
    24.       //1. 直接调用对象成员
    25.       new Student().study();
    26.       //2. 当做参数传递
    27.       showStudent(new Student());//实参     ==> Student stu = new Student();
    28.       //3. 当做返回值传递
    29.       Student stu2 = getStudent();
    30.       stu2.study();
    31.   }
    32.   public static void showStudent(Student stu) {//形参
    33.       stu.study();
    34.   }
    35.   public static Student getStudent() {
    36.       //当做返回值传递
    37.       return new Student();
    38.   }
    39. }
    40. package com.itheima.anonymous;
    41. public class Student {
    42.   public void study() {
    43.       System.out.println("同学们在认真的学习Java！！");
    44.   }
    45. }

  • 代码实践：注册案例
    image.png 

    1. package com.itheima.anonymous;
    2. import java.util.ArrayList;
    3. import java.util.Scanner;
    4. /*
    5.       需求 :
    6.       1 创建用户(User)类 ,
    7.       2 创建对象数据采用键盘录入而来
    8.       3 用户(User)包含的属性 : 演示部分即可
    9.           用户名   (username)
    10.           手机号码 (phoneNumber)
    11.           登录密码 (password)
    12.           确认密码 (confirm)
    13.           电子邮箱 (email)
    14.           性别     (sex)
    15.           出生日期 (birthday)
    16.       4 如果登录密码和确认密码不一致 , 重新输入
    17.       5 把用户(User)对象 ,添加到ArrayList集合中 , 打印集合对象即可
    18. */
    19. public class Test2 {
    20.   public static void main(String[] args) {
    21.       //创建集合，键盘输入对象创建好
    22.       ArrayList<User> accounts = new ArrayList<>();//保存注册的账号
    23.       Scanner sc = new Scanner(System.in);
    24.       //1.键盘输入信息，将信息封装到对象中
    25.       User user = new User();
    26.       System.out.println("请输入用户名：");
    27.       String name = sc.next();
    28.       user.setUsername(name);
    29.       System.out.println("请输入手机号：");
    30.       String tel = sc.next();
    31.       user.setPhoneNumber(tel);
    32.       while (true) {
    33.           System.out.println("请输入登入密码：");
    34.           String password = sc.next();
    35.           System.out.println("请再次输入密码，确认：");
    36.           String confirm = sc.next();
    37.           //对比两次密码是否一致
    38.           if (password.equals(confirm)) {
    39.               user.setPassword(password);
    40.               //退出循环
    41.               break;
    42.           } else {
    43.               System.out.println("两次密码输入不一致，请重新输入！");
    44.           }
    45.       }
    46.       System.out.println("请输入电子邮箱：");
    47.       String email = sc.next();
    48.       user.setEmail(email);
    49.       System.out.println("请输入性别：");
    50.       String sex = sc.next();
    51.       user.setSex(sex);
    52.       System.out.println("请输入生日：");
    53.       String birthday = sc.next();
    54.       user.setBirthday(birthday);
    55.       //已经把数据录入完毕
    56.       //加入到集合中
    57.       accounts.add(user);
    58.     System.out.println("恭喜您，注册成功！！");
    59.       System.out.println("user = " + user);
    60.   }
    61. }
    1. package com.itheima.anonymous;
    2. public class User {
    3.   // 用户名   (username)
    4.   private String username;
    5.   // 手机号码 (phoneNumber)
    6.   private String phoneNumber;
    7.   // 登录密码 (password)
    8.   private String password;
    9.   // 确认密码 (confirm)
    10.   // 电子邮箱 (email)
    11.   private String email;
    12.   // 性别     (sex)
    13.   private String sex;
    14.   // 出生日期 (birthday)
    15.   private String birthday;
    16.   public User() {
    17.   }
    18.   public String getUsername() {
    19.       return username;
    20.   }
    21.   public void setUsername(String username) {
    22.       this.username = username;
    23.   }
    24.   public String getPhoneNumber() {
    25.       return phoneNumber;
    26.   }
    27.   public void setPhoneNumber(String phoneNumber) {
    28.       this.phoneNumber = phoneNumber;
    29.   }
    30.   public String getPassword() {
    31.       return password;
    32.   }
    33.   public void setPassword(String password) {
    34.       this.password = password;
    35.   }
    36.   public String getEmail() {
    37.       return email;
    38.   }
    39.   public void setEmail(String email) {
    40.       this.email = email;
    41.   }
    42.   public String getSex() {
    43.       return sex;
    44.   }
    45.   public void setSex(String sex) {
    46.       this.sex = sex;
    47.   }
    48.   public String getBirthday() {
    49.       return birthday;
    50.   }
    51.   public void setBirthday(String birthday) {
    52.       this.birthday = birthday;
    53.   }
    54.   //toString方法重写
    55.   //Alt+Insert 生成构造方法
    56.   // 目的是让对象打印出来时，能看到属性信息
    57.   @Override
    58.   public String toString() {
    59.       return "User{" +
    60.               "username='" + username + '\'' +
    61.               ", phoneNumber='" + phoneNumber + '\'' +
    62.               ", password='" + password + '\'' +
    63.               ", email='" + email + '\'' +
    64.               ", sex='" + sex + '\'' +
    65.               ", birthday='" + birthday + '\'' +
    66.               '}';
    67.   }
    68. }

    3 继承

    3.1 为什么学习继承 ?

  • 继承是将多个类的相同属性和行为抽取到单独一个类中，那么多个类无需再定义这些共性属性和行为，只要继承这个单独类即可继承这些属性和行为了

  • 多个类称为子类（派生类），单独的这个类称为父类(基类 或超类)

    3.2 继承的格式 ?

  • 使用关键字extends进行连接子类与父类

  • 举例 : public class Student extends People{ … }

    3.3 继承的好处 ?

  • 提高代码的复用性

  • 提高代码的维护性

  • 让类与类产生了关系(继承关系) , 是多态的前提

    package com.itheima.extends_demo;
/*
  学生类 : 姓名(name) , 课程名称(course) , 所在班级(className)  , 查看课表(lookForm) , 填写反馈数据(write)
  老师类 : 姓名(name) , 课程名称(course) , 部门名称(department) , 查看课表(lookForm) , 发布试题(release)
  设计 : 把学生类 和 老师类的共性内容抽取到一个单独的类中(Person),存储共性内容
  父类 : 姓名(name) , 课程名称(course) ,  查看课表(lookForm)
*/
public class ExtendsDemo1 {
  public static void main(String[] args) {
      Student s = new Student();
      s.setName("张三");
      s.setCourse("Java");
      s.setClassName("三年二班");
      s.lookForm();
      s.write();
  }
}

    package com.itheima.extends_demo;
/*
  此类定义的是子类的共性成员
*/
public class Person {
  private String name;
  private String course;
  public String getName() {
      return name;
  }
  public void setName(String name) {
      this.name = name;
  }
  public String getCourse() {
      return course;
  }
  public void setCourse(String course) {
      this.course = course;
  }
  public void lookForm(){
      System.out.println("查看课表");
  }
}

    package com.itheima.extends_demo;
/*
  子类只需要定义自己特有的成员 , 共性的成员需要抽取到父类中
*/
public class Student extends Person{
  private String className;
  public String getClassName() {
      return className;
  }
  public void setClassName(String className) {
      this.className = className;
  }
  public void write(){
      System.out.println("填写反馈数据");
  }
}

    package com.itheima.extends_demo;
/*
  子类只需要定义自己特有的成员 , 共性的成员需要抽取到父类中
*/
public class Teacher extends Person {
  private String department;
  public String getDepartment() {
      return department;
  }
  public void setDepartment(String department) {
      this.department = department;
  }
  public void release() {
      System.out.println("发布试题....");
  }
}

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

    day01-匿名对象 , 继承 , 抽象类 - 图3
    学生类Student继承了Person类。
    创建学生对象在内存中，学生对象中包含自己的成员变量，也包含了从父类中继承下来的成员变量。

    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 抽象方法和抽象类必须用关键字 abstract
   2 抽象类中可以有抽象方法 , 也可由非抽象方法
     但是抽象方法必须存在抽象类中
     非抽象方法 : 让子类去继承 , 提高代码的复用性
     抽象方法 : 让子类必须完成某些功能(规范)
   3 抽象类不能进行实例化(不能创建对象)
   4 抽象的子类
       要么重写所有的抽象方法
       要么这个子类是一个抽象类
   抽象类虽然不能创建对象 , 但是存在构造方法
   构造方法存在的意义 : 让子类去通过super访问 , 从而给抽象类中的私有变量赋值
*/
public class AnimalTest {
public static void main(String[] args) {
   // 抽象类不能进行实例化(不能创建对象)
   // Animal a = new Animal();
}
}

      // 抽象类案例
public abstract class Animal {
private String breed;
private String color;
public Animal() {
}
public Animal(String breed, String color) {
   this.breed = breed;
   this.color = color;
}
public String getBreed() {
   return breed;
}
public void setBreed(String breed) {
   this.breed = breed;
}
public String getColor() {
   return color;
}
public void setColor(String color) {
   this.color = color;
}
// 抽象方法
public abstract void eat();
public void drink(){
   System.out.println("喝水....");
}
}

      public class Dog extends Animal{
public Dog(){
}
public Dog(String breed , String color){// breed = "边牧" ,color = "黑白"
   super(breed , color);
}
@Override
public void eat() {
   System.out.println("狗吃骨头!");
}
}

      /*
需求：
定义猫类（Cat）和狗类（Dog）
猫类成员方法：eat（猫吃鱼）drink（喝水…）
狗类成员方法：eat（狗吃肉）drink（喝水…）
向上抽取父类 :
   Animal类 : 品种 , 颜色 , eat（);  , drink（）{喝水…}
*/
public class AnimalTest {
public static void main(String[] args) {
   // 空参构造 + set
//        Dog d1 = new Dog();
//        d1.setBreed("哈士奇");
//        d1.setColor("黑白相间");
//        System.out.println(d1.getBreed() + "---" + d1.getColor());
//        d1.drink();
//        d1.eat();
   // 全参构造
   Dog d2 = new Dog("边牧" , "黑白");
   System.out.println(d2.getBreed() + "---" + d2.getColor());
}
}

      5 模板设计模式

      5.1 设计模式

      1 什么是设计模式？
      设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
      使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
      简单来说 , 就是一套良好的编码风格 , 通过众多开发人员 , 长时间测试 , 经验总结而来, 不同的设计模式也有不同的好处

      5.2 模板方法设计模式

  • 为完成某任务而定义的算法步骤（模板），算法中的一些步骤延迟到子类中实现，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。

  • 把抽象类整体就可以看做成一个模板，设计一个模板方法，定义算法步骤。步骤中不能当下决定的东西定义成抽象方法，让使用模板的子类类（继承抽象类的类）去重写抽象方法实现需求

模板类

package com.itheima.abstract_template;
/*
    模板类(作为作文模板类)
 */
public abstract class Template {
    //模板方法
    public void write() {
        //1 作文的题目
        System.out.println("《我的爸爸》");
        //2 作文的主体（不确定）
        body();
        //3.结尾
        System.out.println("啊！这就是我的爸爸！");
    }
    //这就是具体写作文主体的方法
    public abstract void body();
}

使用模板的类

public class Jack extends Template{
    @Override
    public void body() {
        System.out.println("那是一个秋天 , 风儿那么缠绵 ,记忆中,那天爸爸骑车送我放学回家 , 我的脚卡在了自行车链中 , 爸爸蹬不动, 他就站起来蹬!\n");
    }
}

测试类

package com.itheima.abstract_template;
public class Demo {
    public static void main(String[] args) {
        Jack jack = new Jack();
        jack.write();
    }
}