1、方法的重写和方法重载的区别
方法重写:
两个类有继承关系;
父类和子类方法名相同,参数列表相同,参数定义入口,返回值定义出口
返回值类型要保持一致(子类的返回值类型和父类的一致)
访问修饰符不能严于父类
方法重载
必须在同一个类中
方法名相同;
参数列表不同(参数个数,类型,顺序不同)
与访问修饰符和返回值无关
2、多态
多态 是指同一种方法具有不同的表现形式
子类引用父类类型,
父类有子类的多种形态,建立于方法重写的基础上
3、类型转换
向上转型:<父类><引用变量名>=new <子类型>();
父类的引用指向子类对象,自动进行类型转换
向下转型: <子类型><引用变量名>=(<子类型>)<弗雷西的引用变量>;
将一个指向子类对象的父类引用赋给一个子类的引用
即:父类类型转换为子类类型,需要强制类型转换
4、比如有宠物、猫、狗和企鹅等,宠物就可以看成另外三种动物的父类
public class Pets {
private String name; //私有的(不能为马化腾)
private int health;
private int love; //范围0-100.默认值是20
public void setName(String name) {
if (name == "马化腾") {
System.out.println("输入的值错误");
}
this.name = name;
}
public String getName() {
return this.name;
}
// 公共的访问接口
public void setHealth(int health) { //setter 入口
if (health < 0 || health > 100) {
System.out.println("健康值的范围为0-100,默认值60");
health = 60;
}
this.health = health;
}
public int getHealth() { //getter 标记出口
return this.health;
}
public void setLove(int love) {
if (love < 0 || love > 100) {
System.out.println("亲密值是0-100,默认值是20");
love = 20;
}
this.love = love;
}
public int getLove() {
return this.love;
}
void print() {
System.out.println("宠物的自白:");
System.out.print("我叫" + name + ",我的健康值:" +
health + ",亲密度" + love);
}
void show(){}
// public Pets() {
// System.out.println("父类无参");
// }
}
public class Dog extends Pets{
private String strain; //没有封装逻辑
public void setStrain(String strain){
this.strain=strain;
}
public String getStrain(){
return this.strain;
}
public Dog(){} //快捷方式 alt+Fn+insert-->
// constructor(右键 Generate )
public Dog(String name, int health, int love, String strain) {
// this.name = name;
// this.health = health;
// this.love = love;
// this.strain = strain;
setName(name); //用set上锁,
setHealth(health);
setLove(love);
setStrain(strain);
}
// private void say(){
// System.out.println("汪汪汪");
// }
// public void getSay(){
// say();
// }
void print(){
// print(); //递归调用,必须有条件的退出,否则会栈溢出
super.print(); //super代表父类对象
System.out.println(",品种是:"+strain);
}
// Pets aaa(){
// return new Pets();
// }
void show(){
super.show();
System.out.println("狗正在接飞盘");
}
}
public class Penguins extends Pets{
private String gender;
public void setGender(String gender) {
if(gender=="Q仔") {
System.out.println("Q仔");
}
else if(gender=="Q妹"){
System.out.println("Q妹");}
else {
System.out.println("性别错误,默认是Q妹");
gender="Q妹";
}
this.gender = gender;
}
public String getGender() {
return gender;
}
void print() {
super.print();
System.out.println("我的性别是"+gender);
}
void show(){
super.show();
System.out.println("企鹅可以在南极游泳");
}
}
public class Cat extends Pets {
public Cat() {
System.out.println("子类无参");
}
public Cat(int a) {
System.out.println("子类有参");
}
public static void main(String[] args) {
Cat c=new Cat();
}
}
public class TestDag {
public static void main(String[] args) {
Dog d=new Dog();
d.setName("欧欧");
d.setHealth(100);
d.setLove(0);
d.setStrain("雪娜猎犬");
d.print();
// System.out.println(d.getHealth());
// Cat c=new Cat();
// c.setName("楠楠");
// c.setHealth(100);
// c.setLove(0);
// c.print();
Penguins p=new Penguins();
p.setName("喃喃");
p.setHealth(100);
p.setLove(0);
p.setGender("Q");
p.print();
p.show();
}
}
狗狗和企鹅,在引用父类的属性和方法的同时,还有自己特有的方法属性,这就是方法重现
5、 多态就是可以在重写的基础上实现的。
比如狗狗,企鹅,他们都有一样的方法,去医院,可以在父类再写一个方法,类型是宠物。效果是什么宠物进来了,就让它实现这个方法
public class Marster {
void cure(Pet p){
p.toHospital();
}
public static void main(String[] args) {
Marster m = new Marster();
Dog d = new Dog();
m.cure(d);
Cat c = new Cat();
m.cure(c);
Pet p = new Dog(); //子类对象引用父亲类型
if (p instanceof Dog) { //判断对象是否是某类型
Dog dog = (Dog) p; //强制类型转换
dog.stain="小土狗";
System.out.println(dog.stain);
}
if(p instanceof Cat){
Cat cat=(Cat) p;
}
Object o=p;
if(o instanceof Pet) {
System.out.println("是");
}
Penguins p1=new Penguins();
m.cure(p1);
if(p1 instanceof Penguins){
System.out.println("是的");
}
}
}