一：匿名对象

        只能使用一次，每一次使用都会创建一个新的对象，默认值和数组的默认值的规则相同。所以适用于调用一次对象的情况：

public class ClassAnonymous {
    String name;
    public void show(){
        System.out.println(name+"真厉害");
    }
}

public class AnonymousDemo {
    public static void main(String[] args) {
        new ClassAnonymous().name="刘备";
        new ClassAnonymous().show();
    }
}

C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=5773:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo AnonymousDemo
null真厉害

进程已结束,退出代码0

        我明明输入了姓名，可是在我调用的时候输出的确是 null， 这是因为每一次 new 都相当于创建了一次对象；

二：继承

继承是多态的前提：

继承所要解决的就是：共性问题；

被继承的称为 父类（基类/超类）；需要继承的是 子类（派生类）

（1）特点

子类可以拥有父类的内容；

子类也可以拥有自己特殊的内容：

（2）关键字：extends 

        我们使用关键字 extends 使子类“继承父类”，在使用时，就将子类当作父类使用；

        我们可以看到，子类 Mangay 里面什么都没有，但是创建它的对象时，却可以调用 父类的 earn方法。因此我们说，子类在使用时，就将当作父类使用；

public class Manpeople {
    private String name;
    private int age;
    
    public void earn(){
        System.out.println("好好挣钱！");
    }
}

public class Mangay extends Manpeople{

}

public class Mandemo {
    public static void main(String[] args) {
        Mangay m=new Mangay();
        m.earn();
    }
}

三：成员变量调用特点

1.一般的继承

父类也是一般类，也可以拥有自己的对象，来调用自己的方法；

子类的对象可以调用自己的方法，也可以调用父类的方法；

public class Fu {
    String name;
    int age;
    public void life(){
        System.out.println("生活" + "很美好");
    }
}

public class Zi extends Fu{
    String sex;
    public void eat(){
        System.out.println("活得好就行！");
    }
}

public class FuZiDemo {
    public static void main(String[] args) {
        Fu fu=new Fu();
        fu.life();  //父类自己的方法
        System.out.println("===========");

        Zi z=new Zi();
        z.eat();    //子类自己的方法
        z.life();   //子类继承父类的方法
    }
}

C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=11226:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo FuZiDemo
生活很美好
===========
活得好就行！
生活很美好

进程已结束,退出代码0

 2.父类子类的成员变量重名

2.1使用对象直接调用重名的成员变量：

子类有该成员变量，优先调用子类的成员变量，没有再从父类中找；

public class Fu {
    String name;
    int age=100;
    public void life(){
        System.out.println("生活" + "很美好");
    }
}

public class Zi extends Fu{
    String sex;
    int age=10;

    public void eat(){
        System.out.println("活得好就行！");
    }
}

public class FuZiDemo {
    public static void main(String[] args) {
        Fu fu=new Fu();
        System.out.println(fu.age);

        Zi z=new Zi();
        System.out.println(z.age);//子类有，优先调用子类的变量，没有往上找
    }
}

C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=11822:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo FuZiDemo
100
10

2.2使用成员方法间接调用重名的成员变量：

毫无疑问，父类的对象调用自己的成员方法时使用的是自己的成员变量；子类的对象调用自己的成员方法时使用的是自己的成员变量；

但是，子类的对象调用父类的方法时，使用的是父类的成员变量，即方法属于谁，就使用谁的成员变量；

public class Fu {
    String name;
    int age=100;
    public void life(){
        System.out.println("生活" + age+"很美好");
    }
}

public class Zi extends Fu{
    String sex;
    int age=10;

    public void eat(){
        System.out.println(age+"活得好就行！");
    }
}

public class FuZiDemo {
    public static void main(String[] args) {
        Fu fu=new Fu();
        System.out.println(fu.age);

        Zi z=new Zi();
        System.out.println(z.age);//子类有，优先调用子类的变量，没有往上找

        fu.life();//父类自己的方法
        z.eat();//子类自己的方法
        z.life();//子类父亲中的方法
    }
}

C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=11916:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo FuZiDemo
100
10
生活100很美好
10活得好就行！
生活100很美好

进程已结束,退出代码0

（3）总结 

我们来总结一下：

对于使用对象直接调用重名的成员变量时，关键看谁有，即子类有就调用子类的，没有就往父类中找；

对于使用方法间接调用重名的成员变量时，成员变量属于谁，就调用谁中的成员变量；

四：子类、父类和子类局部变量重名

局部变量的调用：直接输出 ；

本类成员变量的输出：this.成员变量 ;

父类成员变量的输出：super. 成员变量；

public class Fu01 {
    String name="刘备备";
}

public class Zi01 extends Fu01 {
    String name="曹操操";
    public void life(){
        String name="吕小布";
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

public class Demo01 {
    public static void main(String[] args) {
        Zi01 z=new Zi01();
        z.life();
    }
}

 五：成员方法的调用

成员方法重名时，子类有，调用子类的成员方法；子类没有，再往上找；

public class Fu01 {
    String name="刘备备";
    public void life(){
        System.out.println("这是父类的成员方法");
    }
}

public class Zi01 extends Fu01 {
    String name="曹操操";
    public void life(){
        System.out.println("这是子类的成员方法");
    }
}

public class Demo01 {
    public static void main(String[] args) {
        Zi01 z=new Zi01();
        z.life();//子类有，优先调用子类的成员方法
    }
}

C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=12667:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo Demo01
这是子类的成员方法

进程已结束,退出代码0