Java Part1 Day11继承 方法重写 super多态

面向对象

一.内容回顾

封装;将类内部的属性隐藏private在类的内部，通过对外的公共接口（public setxxx getxxx）去操作，切薄数据的安全（合理）

实现过程：1属性私有 2封装方法 3在setxxx方法中对值的范围进行判断

继承：描述类和类之间的一种关系，通过这种关系子类就可以访问父类中可以访问的成员

好处：代码复用 ，结构清晰（父类中存放公共的成员，子类存放独有成员）

实现：子类extends父类

特点：单继承 传递性

子类继承了父类中的哪些成员：

1. public
2. 在同一包中的父类的默认访问修饰符成员
3. protected受保护的

二.今日内容

1. 各种访问修饰符 总结
2. 继承的本质
3. 多态以及多态的应用
4. 面向对象的应用
5. 关键字：static final abstract

1.各种访问修饰符 总结

	本类	同包类	同包子类	不同包子类	不同包类
privated	√	×	×	×	×
默认的	√	√	√	×	×
protected	√	√	√	√	×
public	√	√	√	√	√

【说明】默认访问修饰符，具有包内可见性，无论是否为子类，都能访问

​ 受保护的，包内可见，子类可见

​ 修饰类：public 默认的

​ 修饰属性、方法：private 默认的 protected public

​ 局部变量：不使用任何修饰符，使用默认

2，继承的本质–扩展

枚举：是一种数据类型，把变量可能出现的值一一列举出来

性别：男女 四季：春夏秋冬 一年的月份 周的星期

作用：给枚举类型变量负值时，只能赋值枚举列出来的值，否则非法报错

本质：创建子类对象之前，先创建父类对象

3，方法的重写

提问：什么是重载？

面试题：方法重载和方法重写的区别

问题：父类中无法确定方法体

如何解决？

1. 在父类中编写方法–虚方法

2. 在子类中重写父类中的方法

   重写规则

   1. 重写的方法（子类中的方法）不能比被重写的方法（父类中的方法）的访问修饰符恒严重
   2. 方法头要相同

方法重写/方法覆盖：在子类中重写父类的方法

原理：在印象过程中，也就是方法调用过程中，子类的方法把弗雷德方法覆盖掉了

面试题：方法重载和方法重写的区？

1. 重载时发生在一个类中，重写时发生在子类中，子类覆盖父类的方法
2. 重载：同名不同参 与访问不修饰符无关

4、super

super：父类对象，通过哪个子类对象访问，就代表哪个子类的父类对象

super的作用：

1. 可以使用super来访问父类中的成员，很好的区分开哪些成员时子类的（子类成员使用this访问），哪些是父类的

public void sayHi(){
		System.out.println("我是宠物："+super.getName()+",品种是："+this.strain);
	}

2. 调用父类的构造方法

xxxxxxxxxx //3个参数    public Dog(String name,AnimalSex sex,String strain){        //通过super关键字，调用父类有参构造方法        super(name,sex);        this.strain=strain;    }

5,明确

1. 子类中的方法可以和父类相同—方法重写
2. 子类中的属性可以和父类相同—属性不会重写 需要通过super或this进行区分

继承：概念

​ 语法 子类 extends 父类

​ 特点：单继承 传递性

​ 子类继承了父类的哪些成员

​ 4个访问修饰符的访问权限

​ 继承的本质：对象的创建顺序

​ super关键字的使用

6. 多态

问题：方法的参数是子类类型，有多少个子类，就需要重载多少个方法，繁琐

package com.qf.pro2103.day11;

public class Master {
	private String name;
	//主人喂养宠物,参数是需要喂养的宠物
	public void feed(Dog dog){
		System.out.println("主人"+this.name+"正坐在喂养宠物："+dog.getName());
		System.out.println("宠物"+dog.getName());
		dog.eat();
	}
	//方法重载：参数是Cat
	public void feed(Cat cat){
		System.out.println("主人"+this.name+"正在喂养宠物："+cat.getName());
		System.out.println("宠物"+cat.getName());
		cat.eat();
	}
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

解决问题的方法：使用多态–优化方法

解决步骤：

1. 在父类中编写方法

public void eat(){
		//由于在父类中，无法确定哪种动物，所以无法确定方法体
	}

2. 在子类中重写父类中的方法

  public void eat(){ //Dog类中
    	System.out.println("啃骨头！");
    }

//重写父类吃的方法
	public void eat(){//在Cat类中
		System.out.println("吃鱼！");
	}

3. 在使用的时候用父类做类型，赋值子类对象

   形式：参数—形参是父类类型，实参是子类对象

   ​ 返回值—返回值类型是父类类型，return子类对象

   ​ 创建对象—对象的类型是父类类型，new子类对象

Master类中

//多态的第三步
	//方法的形参数是父类，传参的实参可以是子类类型
	public void feed(Animal animal){
		System.out.println("主人"+this.name+"正在喂养宠物:"+animal.getName());
		System.out.println("宠物"+animal.getName());
		animal.eat();
	}

测试类

Dog wangcai=new Dog("旺财",AnimalSex.雄性,"拉布拉多");
		Cat huanhuan=new Cat("欢欢",AnimalSex.雌性,"胖橘");
		
		Master yukunJia=new Master();
		yukunJia.setName("贾玉堃");
		//喂养宠物
		//类型是父类，赋值为类---里氏代换原则 LSP
		yukunJia.feed(wangcai);
		yukunJia.feed(huanhuan);

概念：同一父类类型，对同一方法表现出不同的状态，称为多态

多态具备的要素：1.父类 方法

​ 2.子类 不同子类以不同的方式重写父类的方法

​ 3.父类做类型，赋值子类对象

案例：人类：吃饭方法

​ 中国人类：吃饭方法—用筷子吃

​ 美国人类：吃饭方法—用刀叉吃

​ 人类 jia=new 美国人();

​ 人类 zhang =new 中国人();

​ jia.eat();

​ zhang.eat();

多态的好处：代码简洁，适用于程序的扩展

多态使用的技术：继承 方法重写 LSP(父类的引用指向子类)

梳理多态：优化方法的

在不使用多态时

1. 各个子类里都有eat方法

Dog：

 public void eat(){
    	System.out.println("啃骨头！");
    }

Cat:

public void eat(){
		System.out.println("吃鱼！");
	}

2. 主人喂养方法的参数只能是子类类型

//主人喂养宠物,参数是需要喂养的宠物
public void feed(Dog dog){
	System.out.println("主人"+this.name+"正坐在喂养宠物："+dog.getName());
	System.out.println("宠物"+dog.getName());
	dog.eat();
}
//方法重载：参数是Cat
public void feed(Cat cat){
	System.out.println("主人"+this.name+"正在喂养宠物："+cat.getName());
	System.out.println("宠物"+cat.getName());
	cat.eat();
}

问题：子类越多，重载的喂养方法feed方法，就越多，再增加宠物类型时，还需要增加喂养方法

​ 编写大量的方法

解决使用多态：

1. 在父类中编写方法

public void eat(){
		//由于在父类中，无法确定哪种动物，所以无法确定方法体
	}

2. 子类重写父类方法

Dog

public void eat(){
    	System.out.println("啃骨头！");
    }

Cat

public void eat(){
		System.out.println("吃鱼！");
	}

//多态的第三步
	//方法的形参数是父类，传参的实参可以是子类类型
	public void feed(Animal animal){
		System.out.println("主人"+this.name+"正在喂养宠物:"+animal.getName());
		System.out.println("宠物"+animal.getName());
		animal.eat();
	}

调用

TestAnimal

Dog wangcai=new Dog("旺财",AnimalSex.雄性,"拉布拉多");
		Cat huanhuan=new Cat("欢欢",AnimalSex.雌性,"胖橘");
		
		Master yukunJia=new Master();
		yukunJia.setName("贾玉堃");
		//喂养宠物
		//类型是父类，赋值为类---里氏代换原则 LSP
		yukunJia.feed(wangcai);
		yukunJia.feed(huanhuan);

【说明】类型是父类，即使赋值子类对象，在访问时，依然只能访问父类，及父类的父类成员，子类成员是无法访问的

作业：

1. 理解概念
2. 做课堂案例
3. 自行编写多态的案例 思考为什么？ Human jia=new Woker(); 不能访问子类独有成员
4. 文档里的题

​

欢欢",AnimalSex.雌性,“胖橘”);

	Master yukunJia=new Master();
	yukunJia.setName("贾玉堃");
	//喂养宠物
	//类型是父类，赋值为类---里氏代换原则 LSP
	yukunJia.feed(wangcai);
	yukunJia.feed(huanhuan);

【说明】类型是父类，即使赋值子类对象，在访问时，依然只能访问父类，及父类的父类成员，子类成员是无法访问的

作业：

1. 理解概念
2. 做课堂案例
3. 自行编写多态的案例   思考为什么？    Human jia=new Woker();  不能访问子类独有成员
4. 文档里的题



​		

​