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 类型转换异常
标签：Java,String,继承,多态,class,int,student,public,name From： https://blog.csdn.net/whc15059539669/article/details/140232880