多态介绍。

@Override 规范上 推荐加上 帮你校验是否是方法重写

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

特点：

1. 方法名相同
2. 参数列表相同
3. 返回值类型不能大于父类
4. 访问修饰符不能严于父类
5. 不能抛出比父类更大的异常

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

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

Arrays.toString();

String的equals();

为什么要进行重写equals()和hashcode()

String类重写了equals方法
为什么要重写equals()方法。Java 类都继承自Object 类，而Object 类提供的用于比较对象是否相等的方法equals()，通常只是比较两个引用是否指向内存中的同一个对象。我们在定义类时，我们经常会希望两个不同对象的某些属性值相同时就认为他们相同，所以我们要重写equals()方法，按照原则，我们重写了equals()方法，也要重写hashCode()方法。

重点要注意的是：

a. 在java应用程序运行时，无论何时多次调用同一个对象时的hashCode()方法，这个对象的hashCode()方法的返回值必须是相同的一个int值；

b. 如果两个对象equals()返回值为true，则他们的hashCode()也必须返回相同的int值；

c. 如果两个对象equals()返回值为false，则他们的hashCode()返回值也必须不同；
现在，我们到这里可以看出，我们重写了equals()方法也要重写hashCode()方法，这是因为要保证上面所述的b,c原则；所以java中的很多类都重写了这两个方法，例如String类

两个对象的HashCode相同，并不一定表示两个对象就相同，即equals()不一定为true

equals()和==的区别：

== 表是判断是否相等，如果比较基本数据类型，比较的是值的内容。而如果比较引用数据类型，比较的是内存地址。
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 + "]";
	}

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

public static void main(String[] args) {
		String[] a = {"1","2","3"};
		String b="1";
		if(b==(a[0])) {
			System.out.println("a=b");
		}else {
			System.out.println("a!=b");
		}
		
		String c =new String("1");
		if (c==a[0]) {
			System.out.println("a=c");
		}else {
			System.out.println("a!=c");
		}
	}

输出a=b
a!=c

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

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

1. 父类的引用作为方法的形参

   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();
      }
      

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

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

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

   2. 缘由：未来可能宠物店有更多的宠物可以被领养，那么就需要编写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;
              }
          }
      }
      

   3. 编写测试类进行领养测试

      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. 向上类型转型和向下类型转型

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

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

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