day01 【复习回顾、继承、抽象类模板设计模式】

主要内容

1.面向对象回顾
2.封装(基础班),继承(今天),多态(明天+后天)
3.设计模式:模板设计模式

第一章 复习

1.1 如何定义类

格式:
public class 类名{
//成员变量
数据类型 成员变量名;
//成员方法
public 返回值类型 方法名(参数列表){
方法体;
return 返回值;
}
}

1.2 如何通过类创建对象

格式:
类名 对象名 = new 构造方法名(具体参数);

1.3 封装

• 封装的步骤

  a.给成员变量加上private
  b.为每个成员变量,提供一组getter和setter

• 封装的代码实现

  public class Dog {
  //成员变量
  private int age;
  private String name;
  //提供getter和setter
  //alt+insert 省略...
  //成员方法:吠
  public void bark() {
  System.out.println("小狗嗷嗷叫~~~");
  }
  }
  
  public class TestDog {
  public static void main(String[] args) {
  //创建对象
  Dog dd = new Dog();
  //封装之后,我们需要通过调用get和set方法来取值或者赋值
  System.out.println(dd.getName());
  System.out.println(dd.getAge());
  //调用方法
  dd.bark();
  }
  }

1.4 构造器(构造方法)

• 构造器的作用

  给创建出的对象的成员变量初始化!!

• 构造器的格式

  格式:
  public 类名(){
  
  }
  
  public 类名(参数列表){
  给对象中成员变量赋值
  }

• 构造器的使用

  无参构造:
  类名 对象名 = new 构造方法名();
  
  有参构造:
  类名 对象名 = new 构造方法名(实际参数);
  
  例如:
  Dog dd = new Dog(); //使用无参构造
  Dog dd2 = new Dog(10,"旺财");

1.5 this关键字

• this关键字代表什么

  代表当前对象的引用:
  当前对象,成员方法由哪个对象调用的,方法中的this就代码那个对象

• this在代码中的应用

  a.在set方法中使用到this,给同名的成员变量赋值
  public void setAge(int age) {
  this.age = age;
  }
  
  b.在构造方法中使用到this,给同名的成员变量赋值
  public Dog(int age, String name) {
  this.age = age;
  this.name = name;
  }

1.6 匿名对象

• 什么是匿名对象

  没有名字的对象!!!!
  匿名对象是指只new对象,但是不用对象名来接收
  正常对象:
  Dog d = new Dog();
  
  匿名对象:
  new Dog();
  
  注意: 这里匿名是指没有使用对象名接收,而不是对象中没有name属性

• 匿名对象的使用场景

  当一个对象我们只需要使用一次时就可以选择使用匿名对象
  public class NiMingDemo {
  public static void main(String[] args) {
  //需求:编写一个程序,要求用户输入他的年龄
  System.out.println("请输入您的年龄:");
  //使用正常对象
  //        Scanner sc = new Scanner(System.in);
  //        int age = sc.nextInt();//ctrl+alt+v 或者 .var 自动接收方法返回值
  //使用匿名对象
  int age = new Scanner(System.in).nextInt();
  System.out.println("您刚刚输入的年龄是:" + age);
  }
  }

第二章 继承

• 引入案例

  假如我们要定义如下类: 学生类,老师类和班主任类，分析如下：
  1. 学生类 属性:姓名,年龄 行为:吃饭,睡觉
  2. 老师类 属性:姓名,年龄，薪水 行为:吃饭,睡觉，教书
  3. 班主任 属性:姓名,年龄，薪水 行为:吃饭,睡觉，管理
  
  如果我们定义三个类,每个类都有姓名,年龄,吃饭,睡觉

2.1 继承的概念

在一个已知类A的基础上,创建新类B的过程,称之为继承

这里类A,称为父类,基类,超类,英文名SuperClass
这里类B,称为子类,派生类,英文名SubClass

2.2 继承的格式

格式:
public class 父类{
//成员变量
//成员方法
}

public class 子类 extends 父类{
子类中就自动继承了父类中的成员变量和成员方法
子类也可以添加自己的成员变量和成员方法
}

2.3 继承的案例

父类:人类
public class Human {
//人类的共同成员变量和成员方法
int age;
String name;

public void eat(){
System.out.println("我吃蝙蝠...");
}

public void sleep(){
System.out.println("我听课睡着了...");
}
}

学生类:
public class Student extends Human{
}

老师类:
public class Teacher extends Human {
//薪水
double salary;
//教书
public void teach(){
System.out.println("#$%&*($%^*()%&*...");
}
}

班主任类:
public class BanZhuRen extends Human{
//薪水
double salary;
//管理
public void manager(){
System.out.println("开播了,赶紧起床~~~~");
}
}
测试类
public class TestDemo {
public static void main(String[] args) {
//1.测试Student类
Student s1 = new Student();
System.out.println(s1.age);
System.out.println(s1.name);
s1.eat();
s1.sleep();
//2.测试Teacher类
Teacher t1 = new Teacher();
System.out.println(t1.age);
System.out.println(t1.salary);
t1.eat();
t1.teach();
//3.班主任类...自己写完
}
}

• 继承好处总结

  a.提高代码的复用性
  b.类与类之间有了关系,为以后学的"多态"提供了前提

2.4 子类不能继承的内容

a.父类的构造方法子类无法继承!! (因为构造方法和类名是一样的)
b.父类的私有成员,子类可以继承但是不能直接使用!!!(间接使用)

父类:
public class Animal {
private int age;

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public Animal() {
}

public Animal(int age) {
this.age = age;
}
}

子类:
public class Dog extends Animal {
//构造方法无法继承
//私有成员能继承,但是子类无法直接访问

}

测试类:
public class TestDog {
public static void main(String[] args) {
//1.创建Dog对象
Dog d = new Dog();
//2.构造方法无法继承
//Dog d1 = new Dog(10); //报错!!
//3.私有成员可以继承,但是无法直接访问
//d.age; //错误,无法直接访问
//比如:
//古代皇帝,皇帝驾崩了,太子继位,
//皇帝江山属于太子,但是皇帝妃子,太子也继承了叫额娘,但是不能用!!
//4.私有成员我们可以间接访问
//我们通过 get和set方法,间接访问私有成员
d.setAge(10);
int age = d.getAge();
System.out.println("获取到age:"+age);
}
}

2.5 继承后的特点——成员变量

a.当子父类的成员变量不同名时,访问成员变量时没有歧义,写哪个变量名就是访问哪个变量
b.当子父类的成员变量同名时,在子类中会根据就近原则,优先访问子类自己的那个成员变量
c.如果我就想访问父类的成员变量,能否做到???
可以,在子类的方法中,使用super.变量名,就会访问父类中那个成员变量!

/**
* 父类
*/
public class Fu {
//    int numFu = 10;
int num = 10;
}

/**
* 子类
*/
public class Zi extends Fu{
//    int numZi = 99;
int num = 99;
//展示
public void show() {
//子父类成员变量不同名
//        System.out.println(numZi); // 99
//        System.out.println(numFu); // 10
//子父类成员变量同名
//就近原则,优先访问子类自己的成员变量
System.out.println(num); // 99

//如果就想访问父类的num能否做到??
//使用Java提供的另外一个关键字
System.out.println(super.num); //10
}
}

public class TestDemo {
public static void main(String[] args) {
//1.创建Zi对象
Zi zz = new Zi();
//2.调用方法
zz.show();
}
}

2.6 继承后的特点——成员方法[重点]

a.当子父类的成员方法不同名时,调用成员方法时没有歧义,写哪个方法名就是调用哪个方法
b.当子父类的成员方法同名时,使用子类对象调用该方法,根据就近原则,优先调用子类自己的那个成员方法
c.如果我就想通过子类对象,调用父类中的那个同名方法,能做到吗???
不能做到!!
但是可以在子类的方法中,使用super.方法名()调用父类那个同名方法!!!

/**
* 父类
*/
public class Fu {
//    public void showFu() {
//        System.out.println("Fu类的show....");
//    }

public void show() {
System.out.println("Fu类的show....");
}
}

/**
* 子类
*/
public class Zi extends Fu {

//    public void showZi(){
//        System.out.println("Zi类的show...");
//    }

public void show(){
//在子类中可以使用super
System.out.println("Zi类的show...");
super.show();
}
}

public class TestDemo {
public static void main(String[] args) {
//1.创建子类对象
Zi zz = new Zi();
//2.调用方法
//子父类成员方法不同名
//        zz.showZi(); //Zi类的show...
//        zz.showFu(); // Fu类的show....
//子父类成员方法同名
//就近原则,优先子类自己的show方法
zz.show(); // Zi类的show...
//无法做到直接通过子类对象,super去调用父类的同名方法
//zz.super.show(); //报错!!!因为在测试类使用super,并不是Fu类,而是指测试类的父类
//可以在子类的show方法中,使用super.show()调用父类的同名方法
//记住: super关键字只能在子类内部使用
}
}

2.7 重写的概念和应用

方法的重载(overload):
在同一个类中,出现了方法名一样,但是参数列表(参数个数|参数类型|参数顺序)不一样的各种方法,称为方法的重载
方法的重写(override):
在继承关系中,子类中出现了一个和父类除了方法体,其他一模一样的方法,称为方法的重写

方法重写的具体应用:
子类继承父类时,会继承父类的成员方法,那么当子类发现继承过来的方法功能不足或者不适用时,子类就可以重写该方法,重新实现自己需要的方法体即可

/**
* 动物类
*/
public class Animal {

public void eat(){
System.out.println("动物在吃");
}

public void sleep(){
System.out.println("动物在睡");
}
}

/**
* 狗类
*/
public class Dog extends Animal{
//当子类继承父类的方法后,发现父类的方法功能不足或者不适用,我们可以重写
public void eat(){
System.out.println("狗狗舔着吃...");
}

public void sleep(){
System.out.println("狗狗趴着睡...");
}
}

2.8 @Override注解

@Xxxx 这种东西,我们称为注解,英文名Annotation
@Override  此注解叫做方法重写注解,
主要作用就是检查重写的方法是否格式正确(和父类的除了方法体一模一样)

/**
* 动物类
*/
public class Animal {

public void eat(){
System.out.println("动物在吃");
}

public void sleep(){
System.out.println("动物在睡");
}
}

/**
* 狗类
*/
public class Dog extends Animal{
//当子类继承父类的方法后,发现父类的方法功能不足或者不适用,我们可以重写
@Override //加上此注解,可以帮助我们检测eat方法重写的是否正确
public void eat(){
System.out.println("狗狗舔着吃...");
}
@Override //加上此注解,可以帮助我们检测eat方法重写的是否正确
public void sleep(){
System.out.println("狗狗趴着睡...");
}
}

2.9 方法重写的注意事项

a.方法重写是发生在子父类之间的关系
b.子类方法重写父类方法，必须要保证权限大于等于父类权限(一般来说,父类方法写啥权限,子类也写啥权限)
Java中有四大权限,从大到小依次为:
public protected 不写(默认|default) private
c.方法重写,除了方法体其他的都要和父类一模一样(虽然权限可以不一样,但是一般我们也写一样的权限)

2.10 继承后的特点——构造方法

• 构造方法特点介绍

  a.子类能否继承父类的构造方法??
  子类是无法继承父类的构造方法
  b.在子类的"任何构造方法"的"第一行",都有默认一句代码"super()",代表调用父类的无参构造

• 构造方法案例演示

  /**
  * 父类
  */
  public class Person {
  int age;
  String name;
  
  public Person() {
  System.out.println("Person的无参构造...");
  }
  }
  
  /**
  * 子类
  */
  public class Worker extends Person {
  //工资
  double salary;
  
  //构造方法
  public Worker(){
  //默认有一句代码 super();
  System.out.println("Worker的构造方法");
  }
  
  public Worker(double salary){
  //默认有一句代码 super();
  this.salary = salary;
  System.out.println("Worker的salary构造方法");
  }
  
  }
  
  public class TestDemo {
  public static void main(String[] args) {
  //1.创建Worker对象
  //        Worker w = new Worker(); // 调用子类无参构造,子类无参构造中调用父类的无参构造
  Worker w = new Worker(3000); // 调用子类有参构造,子类有参构造中调用父类的无参构造
  }
  }

• 构造方法总结

  a.子类的任何构造,第一行都会调用父类的无参构造
  b.子类的构造方法第一行,super是默认存在的,可以省略不写,但是不写不代表没有!!!

2.11 super(参数)和this(参数)

• 案例引入

  /**
  * 父类
  */
  public class Person {
  int age;
  String name;
  
  public Person() {
  System.out.println("Person的无参构造...");
  }
  
  public Person(int age, String name) {
  this.age = age;
  this.name = name;
  System.out.println("Person有参构造");
  }
  }
  
  /**
  * 子类
  */
  public class Worker extends Person {
  //工资
  double salary;
  
  //构造方法
  public Worker(){
  //默认有一句代码 super();
  System.out.println("Worker的构造方法");
  }
  
  public Worker(double salary){
  //默认有一句代码 super();
  this.salary = salary;
  System.out.println("Worker的salary构造方法");
  }
  
  //子类的构造中默认第一行调用父类无参构造
  //但是我们可以手动修改super()代码,让他调用有参构造
  public Worker(int age,String name,double salary){
  //调用父类的有参构造
  super(age,name);
  this.salary = salary;
  }
  }
  
  public class TestDemo {
  public static void main(String[] args) {
  //1.创建Worker对象
  Worker w = new Worker(20,"小王吧",4000);
  //2.打印对象中属性值
  System.out.println(w.name);
  System.out.println(w.age);
  System.out.println(w.salary);
  }
  }

• super(…)用法演示

  super() 代表调用父类的无参构造,默认的
  super(参数) 代表调用父类的有参构造,具体调用哪个有参构造根据参数来决定

• super(…)案例图解

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f8iRHAMy-1583144789620)(img/image-20200302143555121.png)]

• this(…)用法演示

  this(参数):
  在本类的构造方法中调用本类的其他构造
  
  public class Dog {
  int age;
  String name;
  
  public Dog() {
  //在本类的构造方法中
  this(10,"来福");
  //调用本类的另外一个构造
  }
  
  public Dog(int age, String name) {
  this.age = age;
  this.name = name;
  }
  }
  
  注意: this(参数)也必须写在构造方法的第一行,所以this(参数)和super(参数)他们只能出现一个

• 小结

  a.子类的构造方法中默认有一句super()调用父类无参构造,我们可以手动改写super(参数)调用父类的有参构造,
  具体是哪个有参构造,由参数决定
  b.super(...)和this(...) 必须在第一行,所有不能同时出现
  c.super(..)和this(..)调用父类的构造和子类自己的其他构造,具体哪个构造由参数决定
  d.super(..) 调用父类的有参构造,初始化父类继承的成员变量
  e.this(..) 调用子类的其他构造方法

2.12 Java中继承的特点

1. Java只支持单继承，不支持多继承。(一个类最多只有一个亲爹)
2. 一个类可以有多个子类。(一个类可以有多个孩子)
3. 可以多层继承(一个类可以有父类,其父类也有父类)
总结:  Java只支持单继承,但是支持多层继承

第三章 抽象类

3.1 抽象类的概念和引入

a.抽象方法: 只有方法的声明,没有方法的实现
b.含有抽象方法的类就是一个抽象类

3.2 abstract使用格式

• 抽象方法

  public  abstract 返回值类 方法名(参数列表);

• 抽象类

  public abstract class 类名{
  抽象方法
  正常方法
  }

• 抽象类的使用

  //抽象类:动物
  public abstract class Animal {
  //抽象方法:跑
  public abstract void run();
  }
  
  注意:抽象类是不能创建对象的,天生就是做父类的! 给其他子类继承的!!!
  
  抽象类不能创建对象,需要有子类继承它,并且重写所有抽象方法之后,该子类才能创建对象
  
  //抽象类:动物
  public abstract class Animal {
  //抽象方法:跑
  public abstract void run();
  }
  
  /**
  * 抽象类的子类猫
  */
  public class Cat extends Animal {
  //a.给Cat也加上abstract
  //b.重写抽象类中所有的抽象方法
  @Override
  public void run() {
  System.out.println("猫在屋顶上跑...");
  }
  }
  
  public static void main(String[] args) {
  //1.创建Animal的对象
  //Animal an = new Animal(); // Java规定抽象类不能创建对象
  //2.创建Animal的子类Cat对象
  Cat cc = new Cat();
  cc.run();
  }

3.3 抽象类的特征和注意事项

抽象类的特征:
有得有失!!
有得: 抽象类具备了含有抽象方法的能力
有失: 失去创建对象的能力

注意事项:
a.抽象类不能创建对象(Java规定的!!)
b.抽象类是有构造方法的,用于初始化类的成员变量
c.抽象类中不一定有抽象方法,但是含有抽象方法的类一定是抽象类(一般来说抽象类中是有抽象方法)
d.抽象类的子类必须重写抽象类的所有抽象方法,否则子类还是一个抽象类
e.抽象类的天生作用就是做父类,为子类提供模板

3.4 抽象类存在的意义

抽象类的天生作用就是做父类,为子类提供模板

3.5 第一个设计模式：模板模式(司机开车)

司机开车:
开门,点火,开车,熄火,关门
新司机:
开门,点火,两只手全是汗紧握方向盘,熄火,关门
老司机:
开门,点火,一只手接电话,一只手抽着烟,偶尔手指点点,熄火,关门

/**
* 司机类,父类,模板
*/
public abstract class Driver {
//开车
public void drive(){
System.out.println("开门...");
System.out.println("点火...");
kai();
System.out.println("熄火...");
System.out.println("关门...");
}
////新司机: 两只手全是汗紧握方向盘
////老司机: 一只手接电话,一只手抽着烟,偶尔手指点点
public abstract void kai();
}

/**
* 新司机
*/
public class NewDriver extends Driver {
@Override
public void kai() {
System.out.println("两只手全是汗紧握方向盘,慢慢开车..");
}
}

/**
* 老司机
*/
public class OldDriver extends Driver {
@Override
public void kai() {
System.out.println("一只手接电话,一只手抽着烟,偶尔手指点点,biu一下过去了..");
}
}
//测试类
public class TestDemo {
public static void main(String[] args) {
//1.新司机
NewDriver nd = new NewDriver();
nd.drive();
//2.老司机
OldDriver od = new OldDriver();
od.drive();
}
}

总结

继承:

a.继承的格式
public class 子类 extends 父类{

}
b.不能继承的内容
i.构造方法子类不能继承
ii.私有成员子类可以继承但是不能直接使用(间接使用,通过get/set方法使用)
c.继承后成员变量和成员方法的特点:
i.不同名,没有歧义
ii.同名时在子类中优先调用子类自己的成员
iii.我们可以使用关键字
super.变量名 访问父类的同名成员变量
super.方法名() 调用父类的同名成员方法
d.方法的重写
方法的重写:在继承关系中,子类有一个和父类除了方法体其他一模一样的方法,该方法称为重写的方法
什么时候需要重写:
当子类继承父类的方法后,发现父类的方法适用,那么子类就可以重写该方法
重写时可以使用@override帮助我们检测是否重写格式正确
e.super(..)
用于子类的构造方法第一行,调用父类的构造方法,具体是哪一个构造
由super(参数)中的参数决定
f.this(..)
用于本类的构造方法第一行,调用本类的其他构造方法,具体是哪一个构造
由this(...)中的参数决定
g.Java继承的特点:
只支持单继承,但是支持多层继承

抽象类:
a.抽象方法格式: public abstract void 方法();
抽象类格式:  public abstract class 抽象类名{ 可能有抽象方法,也可以没有抽象方法}
b.抽象类怎么用?
使用子类继承抽象类,重写所有抽象方法后,子类才能创建对象
c.抽象类的意义:
给子类继承的,为子类提供的模板(模板设计模式)

• 点赞
• 收藏
• 分享
• 文章举报