Java编程语言多态

方法重写：在子类继承了父类的方法之后，如果发现在当前的需求下，父类的方法不够强大，所以在子类中就可以对此方法进行重写。

特点：

方法名相同
参数列表相同
返回值类型不能大于父类
访问修饰符不能严于父类

**方法重载：**在同一个类中，方法名相同，参数列表不同(类型，个数，顺序)，与方法的返回值类型和访问修饰符无关。

Object：超类，顶级父类。Java中的所有类都直接或者间接继承自它。

Arrays.toString();

String的equals();

equals()和==的区别：

== 表是判断是否相等，如果比较基本数据类型，比较的是值的内容。而如果比较引用数据类型，比较的是内存地址。

equals（）默认情况下在Object中的实现和==是一致的。但是例如String类型就对equals()做了重写。（最终的最终比较的是两个字符串中字符数组而已）

    public boolean equals(Object obj) {
        return (this == obj);
    }

toString()

    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

cn.kgc.demo1.User@7852e922

重写了对应类的toString()之后：

	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + "]";
	}

面向对象的三大特性之一。

1. 掌握为什么要使用多态？(初级的使用)

2. 掌握如何使用多态？(初级的使用)

父类的引用作为方法的形参
1. 编写宠物主人类，在宠物主人类给不同的宠物喂食.
```
public class Master{
    
    public void feedDog(Dog dog){
        dog.eat();
    }
    public void feedPenguin(Penguin penguin){
        penguin.eat();
    }
    
}
```
2. 缘由：发现如果未来还要领养更多的宠物，那么肯定要增加更多的喂食方法！
  
  使用多态来进行优化。父类的引用作为方法的形参。
```
public class Master{
    // 父类的引用可以传入子类的对象
    public void feedDog(Pet pet){ 
        pet.eat();
    }
}
```
3. 导致的缘由(牵连)：因为这时候调用的是Pet这个父类中的通用方法，所以导致不同的宠物，吃食是一样的，但是显然不可能。
  
  父类的方法不够强大时，子类要进行方法重写！
  
  在多态的场景下，如果调用方法，实际执行的是子类重写后的方法。
```
public class Pet{
    public void eat(){
        
    }
}
public class Dog{
	@Override
    public void eat(){
        syso("吃骨头！");
    }
}
public class Penguin{
    @Override
    public void eat(){
        syso("吃鱼！");
    }
}
```
4. 牵连导致！我们发现父类中的eat()方法，根本就没有必要再进行实现！里面多一行代码都是浪费。
  
  但是这个方法是不能被删除的，因为父类的引用要调用，子类还要进行重写。
  
  将此方法定义为抽象方法。
  
  由它又导致，这个类变为了抽象类。
```
public abstract class Pet{
	// 抽象方法没有方法体   而且 必须被子类重写
    public abstract void eat();
}
```

父类的引用作为方法的返回值类型

编写宠物商店类，宠物商店有不同宠物的领养方法。

public class PetStore {
	/**
	 * 领养狗
	 * @return
	 */
	public Dog getDog() {
		Dog dog = new Dog();
		return dog;
	}
	
	/**
	 * 领养企鹅
	 * @return
	 */
	public Penguin getPenguin() {
		Penguin penguin = new Penguin();
		return penguin;
	}
}

缘由：未来可能宠物店有更多的宠物可以被领养，那么就需要编写N多个方法用于不同宠物的领养。

使用多态来优化，因为最终无论是返回什么宠物，它们都是Pet类的子类。]

public class PetStore{
    // 父类的引用作为方法的返回值类型。
    public Pet getPet(int choose){
        if(choose == 1){
            return new Dog();
        }else if(choose == 2){
            return new Penguin();
        }else{
            return null;
        }
    }
}

编写测试类进行领养测试

public class Test{
    public static void main(String[] args){
        PetStore petStore = new PetStore();
        // Pet pet = new Dog();
        Pet pet = petStore.getPet(1);
        pet.setName("小哈");
        pet.eat();
    }
}

3. 关键词 instanceof

判断某个对象是否是某个类型的实例。

语法：对象名 instanceof 类型

4. 向上类型转型和向下类型转型

之所以要进行类型转换，原因就是因为父类的引用无法访问子类特有的内容，所以才需要进行转换。

**类型转换：**强制类型转换和自动类型转换

**自动类型转换：**Pet pet = new Dog(); // double num = 10;
**强制类型转换：**Dog dog = (Dog)pet; // int num = (int)10.1;