多态

同类型的对象，表相出的不同形态

有继承关系

有父类引用指向子类对象

有方法的重写

举个例子狗继承动物

Animal a = new Dog();

Dog a = new Dog();有利于下面的理解

Aniaml类

package duotai;

public class Animal {
    String color;
    int age;

    public Animal() {
    }

    public Animal(String color, int age) {
        this.color = color;
        this.age = age;
    }

    public void eat(String something){
        System.out.println("吃"+something);
    }


    public String getColor() {
        return color;
    }


    public void setColor(String color) {
        this.color = color;
    }


    public int getAge() {
        return age;
    }


    public void setAge(int age) {
        this.age = age;
    }


}

Dog类

package duotai;

public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String color, int age) {
        super(color, age);
    }
    public void lookHome() {
        System.out.println("Dog is looking home");
    }
}

Cat类

package duotai;

public class Cat extends Animal {
    public Cat() {
    }

    public Cat(String color, int age) {
        super(color, age);
    }
    public void catchMouse() {
        System.out.println("Cat is catching mouse");
    }
}

Person类

package duotai;

public class Person {
    String name;
    int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }


    public int getAge() {
        return age;
    }


    public void setAge(int age) {
        this.age = age;
    }
    public void keepPet(Animal a, String something) {
        if (a instanceof Cat) {
            Cat c = (Cat) a;
            System.out.println("年龄为" + age + "姓名为" + name + "的人养了一只" + c.getColor() + "颜色的猫，它今年" + c.getAge() + "岁，它在吃" + something);
        } else if (a instanceof Dog) {
            Dog d = (Dog) a;
            System.out.println("年龄为" + age + "姓名为" + name + "的人养了一只" + d.getColor() + "颜色的狗，它今年" + d.getAge() + "岁，它在吃" + something);
        }
    }
}

Test测试类

package duotai;

public class Test {
    public static void main(String[] args) {
       Person p1 = new Person("老王",20);
       Dog d1 = new Dog(    "黄色",3);
       p1.keepPet(d1,"骨头");

       Person p2 = new Person("老张",30);
       Cat c1 = new Cat("黑色",1);
       p2.keepPet(c1,"鱼");
    }
}

特点

变量调用：编译看左边，运行也看左边，编译代码的时候先看左边父类中有没有这个变量，有编译成功，没有失败。运行，实际获取的就是左边父类中成员变量的值。

方法调用：编译看左边，运行看右边，实际运行的是子类的方法。

优势：

右边对象可以实现解耦合，便于扩展和维护。定义方法的时候，使用父类型作为参数，可以接受所有子类对象，体现多态的扩展性与便利性。

弊端：

不能使用子类的特有功能（通过强制类型转换，从而调用子类独有功能，转换类型与真是对象类型不一致会报错，转换的时候用instanceof关键字进行判断）

包、fianl、权限修饰符、代码块

包就是文件夹，用来管理各种不同功能的Java类，方便后期代码维护。

包名规则：公司域名反写+包的作用，需要全部英文小写，见名知意

使用其他类的规则：

使用同一个包中的类时，不需要导包

使用Java.lang包中的类时，不需要导包

其他情况都需要导包

如果同时使用两个包中的同名类，需要用全类名

final

可以修饰方法，类和变量

修饰方法，表明是最终方法，不能被重写

修饰类，表明不能被继承

修饰变量，表示不可再被修改，是常量

常量

实际开发中，常量一般作为系统的配置信息，方便维护，提高可读性

命名规范：单个单词，全部大写；多个单词全部大写，单词之间用下划线隔开

细节：

final修饰的变量是基本类型：那么变量存储的数据值不能发生改变

final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，对象内部的可以改变

权限修饰符

用来控制一个成员能够被访问的范围的

可以修饰成员变量，方法，构造方法，内部类

有四种作用范围由小到大

private<不写<protected<public

private只有同一个类中可以访问

默认不写在同一个包中其他类可以访问

protected在不同包下的子类也可以访问

public不同报下的无关类也可以访问

一般只用private和public

成员变量私有，方法公开

如果方法中的代码是抽取其他方法中共性代码，这个方法一般也私有

代码块

局部代码块：提前结束变量生命周期

构造代码块：写在成员位置的代码块，可以把多个构造方法中重复的代码抽取出来，在创建本类对象时会先执行构造代码块再执行构造方法

静态代码块：static{}特点：需要通过static修饰，随着类的加载而加载，并且自动触发，只执行一次

在类加载的时候，做一些初始化的时候用