2020.4.22课堂笔记（继承、多态、抽象类、抽象方法）
在继承的情况下，子类的方法满足以下条件：
1、方法名相同
2、参数列表相同
3、返回值类型相同，或者是父类返回值类型的子类
4、访问修饰符的权限不能小于父类方法
5、抛出的异常不能大于父类（严于）
多态
抽象类abstract关键字修饰类
抽象类不能被实例化（不能创建对象）含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写
抽象方法：
抽象方法必须在抽象类中
抽象方法没有结构体
子类继承抽象类的时候，必须实现父类的抽象方法，除非这个子类也是抽象类
TestFinal.java
public class TestFinal{
public static void main(String[] args){
T t=new T;
//t.i=8;
}
}
class T{
final int i=8;
public void m(final Cat cat){//不能让这个引用指向其他的猫
j=9;//报错不能指定最终参数j（final int j 的时候）
}
}
public final void m(){
//
}
Final关键字：
public final class String /public final class Math /public final class Boolean
不能被继承，重写方法
final的变量值不能被改变（成员变量、局部变量）
final的方法不能被重写
final的类不能被继承
java中是单继承、但是生活中存在多继承的现象，不可以这么写就是使用接口
接口：本质上讲，接口是一种特殊的抽象类，在这个抽象类里面，所有的方法都是抽象方法，
所有的成员变量都必须是public static final的，只包含常量和方法的定义，而没有变量和方法的实现。
public interface Runner{
public static final int id=1;
public void start();//所有的方法不用写abstract实际都是abstract的
}
一个类可以实现多个接口
接口中声明的属性默认是public static final也只能是public static final的
一个接口里面的方法只能是public的抽象方法
接口和实现类之间存在多态性 只能看到实现类中自己的方法
Singer s=new Student(); //把student当作singer来看，每一个接口暴露了对象的一部分方法，使用什么样的接口，只能访问这个接口对应的方法
s.sing();
只要实现了这个接口的任意一个类的对象都可以往里面传,new这个对象出来就可以往里面传，
重写了我sing的方法，我实际调用的就是重写的方法，接口本质上仍然是一个类，帮助我们实现多重继承
f(Singer s){
s.sing();
}
第三章总结：
内存分析贯穿始终
对象和类的概念
类是具有同样特征的同一类事物的抽象
对象是这类事物的特殊的实例
类和对象直接的关系：关联、继承、聚合（聚集、组合）、多态、实现
面向对象设计思想：和面向过程不一样，这个问题里有哪些类哪些对象，类里面有哪些属性哪些方法，类和类之间有什么关系，有没有继承、多态的关系
Class、new关键字，引用的概念：一小块内存指向一大块内存，new一般和构造方法一起使用，构造一个新对象的时候调用的方法，和类同名，没有返回值，void都不可以写。
方法的重载，方法名字一样，参数列表不同（参数的类型不一样或者参数的个数不一样）
this关键字：当前对象，你现在在调用哪个方法，this指的就是谁，内存里new出一个对象来，有一个自己的引用指向自身
static的成员变量是属于所有类的，一般分配在data区域里面，属于这个类的所有对象，属于整个类，不需要new这个对象就可以去访问它。非static的必须去new一个对象出来才可以去访问它的值，static不需要，只要用类名.就可以访问它的值，或者来访问这个方法。
package解决类重名的问题，约定俗成、公司域名倒过来
访问控制：private 修饰成员变量，只有自己能访问，出了类没有人能访问它
default同一个包里面其他类可以访问
protected它的子类可以访问
public所有类都能访问
default和public还可以修饰class
所有的关键字都可以修饰内部类，
extends继承，一个类从另外一个类继承，封装了这样一种语义，XXX是一种XXX，只要说通了，它们之间是一种继承关系。继承下来相当于拥有了那个类所有的成员变量，所有的方法，包括private的，但是对于private的成员变量，拥有了所有权但是没有使用权
overwrite：方法的重写
父类实现一方法不满意，重写。重写的时候有一个best practise最佳的实践
final的变量不能改变值，final的方法不能被重写，final的class不能被继承
Object
toString封装了一个对象在一个字符串上的表现，可以重写它，写一个字符串，来表现它
upcasting父类引用指向子类对象/接口的引用指向实现的对象，向上转型
downcasting向下转型
多态：要有继承、要有重写、父类引用指向子类对象
多态也叫动态绑定dynamic binding 迟绑定 late binding：new的是哪个类，我就找那个类对象的方法，这叫动态绑定
abstract class有抽象方法的类叫做抽象类，抽象方法只有定义，没有实现
interface接口
特殊的抽象类，所有的方法都是抽象方法，而且都是public的，所有的成员变量都是public static final的
接口和接口之间可以互相继承，类和类之间可以互相继承，类和接口之间只能实现implements
一个类可以实现多个接口，多个类可以实现一个接口，内存里可以看见这个对象的一部分方法，这就是接口。
Cat:
package cn.kgc.kb09;
/**
* @Author: ChaoKeAiMuZhi
* @Date: 2020/7/22 16:13
* @Description:
**/
public class Cat extends Pet {
@Override
public void toHospital() {
if(getHealth()<50){
setHealth(90);
System.out.println("猫有九条命，不用治");
}
}
public void playwithBall(){
System.out.println("猫玩毛线球");
}
@Override
public void eat() {
setHealth(getHealth()+3);
System.out.println("猫吃鱼，健康值加3");
}
}
Dog
package cn.kgc.kb09;
/**
* @Author: ChaoKeAiMuZhi
* @Date: 2020/7/22 15:59
* @Description:
**/
public class Dog extends Pet {
String strain;
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
@Override
public void toHospital() {
if(getHealth()<50){
setHealth(60);
System.out.println("给狗狗治疗，吃药，打针");
}
}
@Override
public void eat() {
setHealth(getHealth()+5);
System.out.println("狗狗吃骨头，健康值加5");
}
public void catchFrisbee(){
System.out.println("狗狗接飞盘");
}
}
Fish:
package cn.kgc.kb09;
/**
* @Author: ChaoKeAiMuZhi
* @Date: 2020/7/22 16:37
* @Description:
**/
public class Fish extends Pet {
@Override
public void toHospital() {
}
@Override
public void eat() {
System.out.println("鱼吃虾米，健康值加3");
}
}
Master:
package cn.kgc.kb09;
/**
* @Author: ChaoKeAiMuZhi
* @Date: 2020/7/22 16:06
* @Description:
**/
public class Master {
//全局静态常量，只有一个副本，不会创建
public static final String CAT="cat";
public static final String DOG="dog";
public static final String PENGUIN="penguin";
public void cure(Pet p){
p.toHospital();
}
public void feed(Pet p){
p.eat();
}
//在返回值的部分使用多态
//代理模式
public Pet getPet(String type){
Pet p=null;
if(CAT.equals(type)){
//猫类型
p=new Cat();
}
if(DOG.equals(type)){
p=new Dog();
}
if(PENGUIN.equals(type)){
p= new Penguin();
}
return p;
}
}
Penguin
package cn.kgc.kb09;
/**
* @Author: ChaoKeAiMuZhi
* @Date: 2020/7/22 15:59
* @Description:
**/
public class Penguin extends Pet {
public void toHospital(){
if(getHealth()<50){
setHealth(70);
System.out.println("给企鹅治疗，吃鱼、疗养");
}
}
@Override
public void eat() {
System.out.println("企鹅吃鱼，健康值加3");
}
public void swim(){
System.out.println("企鹅在南极游泳");
}
}
Pet
package cn.kgc.kb09;
/**
* @Author: ChaoKeAiMuZhi
* @Date: 2020/7/22 15:06
* @Description:
**/
public abstract class Pet {
private String name;
private int health;
private int love;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
//重写equals方法
@Override
public boolean equals(Object obj) {
if(this==obj){
return true;
}
if(obj instanceof Pet){
Pet p=(Pet) obj;
//自定义比较规则
//如果宠物的名称相同，则认为是同一个对象
if(this.name!=null && this.name.equals(p.name) && this.love!=0 &&this.love==p.love && this.health!=0 &&this.health==p.health){
return true;
}
}
return false;
}
/*@Override
public String toString(){
return "我叫"+this.name+",我的健康值为："+this.health+",与主人的亲密度为："+this.love;
}*/
/*@Override
public String toString() {
return "Pet{" +
"name='" + name + '\'' +
", health=" + health +
", love=" + love +
'}';
}*/
public abstract void toHospital();/*{
System.out.println("宠物去医院");
}*/
public abstract void eat();
}
TestMaster:
package cn.kgc.kb09;
/**
* @Author: ChaoKeAiMuZhi
* @Date: 2020/7/22 16:22
* @Description:
**/
public class TestMaster {
public static void main(String[] args) {
Master m=new Master();
//Pet p=m.getPet("Dog");
Pet p=new Cat();
Dog d=new Dog();
System.out.println(p);
//涉及类型转换的时候，如果有多种可能，那么最好用instanceof关键字进行类型判断
if(p instanceof Cat){
Cat c=(Cat) p;
c.playwithBall();
}
if(p instanceof Dog){
Dog c=(Dog) p;
System.out.println("转成狗类");
}
m.feed(d);
m.cure(d);
/*//出现异常java.lang.ClassCastException
Dog d=(Dog)p;*/
}
}
TestPet
package cn.kgc.kb09;
/**
* @Author: ChaoKeAiMuZhi
* @Date: 2020/7/22 15:20
* @Description:
**/
public class TestPet {
public static void main(String[] args) {
/*Pet p1=new Pet();
Pet p2=new Pet();
p1.setName("宠物1号");
p2.setName("宠物1号");
p1.setHealth(96);
p2.setHealth(96);
p1.setLove(92);
p2.setLove(92);
System.out.println(p1.toString());
//System.out.println();默认会去调用object的toString方法，我们重写了
System.out.println(p2);
//System.out.println(p1==p2);
System.out.println(p1.equals(p2));*/
//父类引用指向子类对象
Pet d=new Dog();//子类对象引用父类类型，多态的基础
//这时候不能直接使用子类的属性和方法
System.out.println(d);
Master master=new Master();
/*master.cure(d);
Penguin p=new Penguin();
master.cure(p);
Cat c=new Cat();
master.cure(c);
master.feed(c);
master.feed(d);
master.feed(p);*/
Pet pet=master.getPet("penguin");
System.out.println(pet);
if(pet instanceof Dog){
Dog dog=(Dog)pet;
dog.catchFrisbee();
}
if(pet instanceof Penguin){
Penguin penguin=(Penguin)pet;
penguin.swim();
}
}
}