匿名对象

概述

没有名字的对象，是对象的一种简化表示形式

特性

一次性，每次使用都是一个新的对象

使用情景

1、对象调用方法仅使用一次，然后等待销毁

2、作为实际参数传递

public class TestDog{
    public static void main(String[] args) {
        // 对象调用方法仅使用一次
        new Dog().sleep();
        
        // 作为实际参数传递
        useDog(new Dog());
    }
    
    public static void useDog(Dog dog) {
        dog.sleep();
    }
}

class Dog {
    String name;
    int age;
    
    public void sleep() {
        System.out.println("小狗睡觉.....");
    }
}

优点

提高开发效率，简化代码结构

继承

概念

把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，这多个类就具备了这些内容。这个关系叫继承。

关键字：extends

格式:
    class Son extends Father {
    
    }

一个孩子只能有一个父亲
一个父亲可以有多个孩子

特点

1、Java为单继承，一个类只能有一个直接父类，但可以多级继承，属性和方法逐级叠加
2、构造方法只可服务于本类，不可继承，子类执行构造方法前会默认调用父类的无参构造方法。可以通过super()去访问父类的构造方法
3、private 修饰的属性和方法不能被继承

extends

public class Demo {
    public static void main(String[] args) {
        // 创建一个父类对象
        Father father = new Father();
        
        // 父类调用父类的属性和方法
        father.name = "父";
        System.out.println(father.name);
        father.game();
        
        System.out.println("-------------");
        
        // 创建一歌子类对象
        Son son = new Son();
        
        // 子类调用子类的属性和方法
        son.age = 16;
        System.out.println(son.age);
        son.study();
        
        // 子类调用父类的属性和方法(public修饰)
        son.name = "子";
        System.out.println(son.name);
        son.game();
        
        
        /*
         * 子类调用父类private修饰的属性和方法
         * 
         * 报错
         * The field Father.suffer is not visible
         * The method cook() from the type Father is not visible
         * 
         * 由此可知子类不能调用父类私有化的属性和方法
         */
//        son.suffer = 10;
//        son.cook();
    }
}

public class Father {
    public String name;
    
    private int suffer;
    
    public void game() {
        System.out.println("下棋");
    }
    
    private void cook() {
        System.out.println("做饭");
    }
}

public class Son extends Father{
    public int age;
    
    public void study() {
        System.out.println("子类 -- 学习");
    }
}

子类构造方法执行前默认先执行父类的无参构造方法

class Father {
    String name;

    public Father() {
        System.out.println("Father's Constrator be performed");
    }
}

class Son extends Father {
    int age;

    public Son() {
        System.out.println("Son's Constrator be performed");
    }
}

public class TestSon {
    public static void main(String[] args) {
        Son son = new Son();
    }
}

结果

Father's Constrator be performed
Son's Constrator be performed

【注意】Son 的构造方法中编译器默认生成 super(); 用来调用父类的构造方法，目的是为了初始化父类字段，因为子类可能会用到

继承内存分析图

优点

1、提高了代码的复用性
2、提高了代码的维护性
3、让类与类之间产生了一个关系，是多态的前提

缺点

1、让类的耦合性增强。这样某个类的改变，就会影响到其他和该类相关的类
2、打破了封装性

总结

Java中只有单继承

子类可以继承父类的非私有属性和方法（非private修饰的）

执行子类的构造方法前会默认执行父类的无参构造方法

方法重写【Override】

引言

开发中父类的方法不一定适用于子类，因为父类方法不能更改，在子类中新增方法会造成代码的冗余，而且不符合逻辑

要求

1、应用于继承和实现接口
2、返回值类型，方法名，形参列表与父类一致
3、使用@Override注解来标识
4、重写方法的访问修饰符权限不能低于父类
    private < 默认(什么都不写) < protected < public

public class Son extends Father{
    public int age;
    
    @Override
    public void game() {
        System.out.println("玩红色警戒");
    }
    
    public void study() {
        System.out.println("子类 -- 学习");
    }
}

public class Father {
    public String name;
    
    private int suffer;
    
    public void game() {
        System.out.println("下棋");
    }
    
    private void cook() {
        System.out.println("做饭");
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Son son = new Son();
        son.game();
    }
}

优点

既沿袭了父类的方法名，又实现了子类的扩展

总结

1、方法的重写能够在不新增方法的情况下实现子类的扩展

2、方法重写要求方法声明格式和父类完全一致（访问修饰符不能小于父类）

3、@Override关键字用来开启格式检测，如果不一致就会报错