Java基础——继承与多态

Java基础——继承与多态

方法重写

构造方法不能被重写

public class Fpet {
     String name;
  int health;
    int love;
     public void print(){
        System.out.println("宠物的自白：");
        System.out.println("我的名字是"+this.getName()+"健康度是"+this.getHealth()+"我的亲密度是"+this.getLove());
    }
public Fpet method1(){
    return Fpet;
} 
}
public class penguin extends Fpet {
    penguin(){}
    penguin(String nmae,int health,int love){
        super(nmae,health);
        this.love=love;
        this.sex="nv";
    }
    private String sex;
    public void print(){
        super.print();
        System.out.println("性别是"+this.sex);
        public penguin methodl(){
            return penguin;
        }//返回值类型是其子类也是方法的重写
    }

重写的方法修饰符范围不能小于父类lie

Object类是所有类的父类

public class student {
    String name;
    int code;
    int age;
   public student(){};
   public  student(String name,int code,int age){
       this.name=name;
       this.age=age;
       this.code=code;
   }

}
//我们认为当学号，姓名，和年纪相同时认为相同
public class TestStudent {


    public static void main(String[] args) {
        student stu1=new student("wang",1,18);
        student stu2=new student("wang",1,18);
       boolean a= stu1.equals(stu2);
       System.out.println(a);
    }
}

运行结果flase

没重写之前equal通过比较两个对象的内存地址来判断是否相等和==作用相同

在内存里两个对象开辟了不同的两个空间在内存中是不同的

显然object自带的equal方法无法满足我们的需求

对equal方法进行重写

public class student {
    String name;
    int code;
    int age;
   public student(){};
   public  student(String name,int code,int age){
       this.name=name;
       this.age=age;
       this.code=code;
   }
   //对父类Object的equal函数进行重写
    public boolean equals(Object o) {
        boolean flang = false;
        if (this == o) {
            flang = true;
        }
        if (!(o instanceof student)) {
            flang = false;
        } else {
            student stu=(student) o;//将强制转换为student类型
            if (this.name==this.name && this.age==stu.age&&this.code==stu.code){
                flang=true;
            }
        }
        return flang;
    }
}

//我们认为当学号，姓名，和年纪相同时认为相同
public class TestStudent {
    public static void main(String[] args) {
        student stu1=new student("wang",1,18);
        student stu2=new student("wang",1,18);
        boolean a=stu1.equals(stu2);
        System.out.println(a);

    }
}
运行结果ture

多态

代码需求改变时，需要频繁修改代码时使用多态

多态：同一引用类型，Pet

使用不同的实例 Dog 对象 penguin对象

而执行不同的操作 Dog的toHospital(), penguin的toHospital(JVM的动态绑定机制)

用父类类型声明一个变量，引用的是子类的的 对象

Pet pet =new Dog();

重写toHospital方法

抽象方法

1.普通方法

修饰符 返回值 方法名（参数列表）{

方法体；

}

2.抽象方法（约束行为在抽象类中不具体实现）

修饰符 abstract 返回值 方法名（参数列表）；

拥有抽象方法的类必须声明成抽象类（abstract）

但是抽象类中不一定要有抽象方法

抽象方法在子类中一定要实现，除非子类是抽象类继承抽方法

抽象类不能创建对象（抽象类不允许实例化）

向上转型

Pet pet=new Dog();

可以调用父类的方法，不能调用之类特有的对象

向下转型

Penguin penguin=（Penguin）pet;

实际运行时，会出现转换异常 ClassCastException

怎么办？

使用nstanceof:判断变量类型是否相等

多态的应用

1.使用父类作为方法的形式参数

2.使用父类作为方法的返回值类型

public abstract class Animal {
    public abstract void cry();
    }
class dog extends Animal {
    public void cry() {
        System.out.println("汪汪汪");
    }
}

class cat extends Animal {
    public void cry() {
        System.out.println("喵喵喵");
    }
}
class dunck extends Animal {
    public void cry() {
        System.out.println("嘎嘎嘎");
    }
    public  class Master{
public Animal domateAnmal(String a) {

    if (a.equals("dog")) {
        Animal dog1 = new dog();
        return dog1;
    } else if (a.equals("dunck")) {
        Animal dunck1 = new dunck();
        return dunck1;
    }

    else {
        Animal cat1=new cat();
        return cat1;
    }

}
}
public class TestAnimal {

    public static void main(String[] args) {
        String a="dog";
        Master m1=new Master();
      Animal animal=  m1.domateAnmal(a);
      animal.cry();
    }

}

遇到的问题

1.堆区与栈区的区别

堆区和栈区上本质上都是内存，只是生命周期不同而已

栈区：当函数变量的为局部变量函数运行完后释放内存，先分配内存的后释放顺序和栈相同

特点：大小固定容量有限

堆区：当函数的变量生命周期超过了本函数，内存的释放由程序员决定

2.==比较两个对象的内存地址是否相同

3.instanceof:判断变量类型是否相等

4.equals比较字符串的内容时，String类对equals方法进行重写，使其比较的是字符串的内容

5.带返回值的函数加入条件判断后，无论什么结果最后都要返回一个相应的值

栈区的区别

堆区和栈区上本质上都是内存，只是生命周期不同而已

栈区：当函数变量的为局部变量函数运行完后释放内存，先分配内存的后释放顺序和栈相同

特点：大小固定容量有限

堆区：当函数的变量生命周期超过了本函数，内存的释放由程序员决定

2.==比较两个对象的内存地址是否相同

3.instanceof:判断变量类型是否相等

4.equals比较字符串的内容时，String类对equals方法进行重写，使其比较的是字符串的内容

5.带返回值的函数加入条件判断后，无论什么结果最后都要返回一个相应的值

6.异常 ClassCastException 类型转换异常