JAVA基础【day07】:面向对象(2)

这辈子没办法做太多事情，所以每一件都要做到精彩绝伦。 --------史蒂夫.乔布斯

代码块

(1)用{}括起来的代码。
(2)分类：
    A:局部代码块
        用于限定变量的生命周期，及早释放，提高内存利用率。
    B:构造代码块
        把多个构造方法中相同的代码可以放到这里，每个构造方法执行前，首先执行构造代码块。
    C:静态代码块
        对类的数据进行初始化，仅仅只执行一次。
(3)静态代码块,构造代码块,构造方法的顺序问题?
    静态代码块 > 构造代码块 > 构造方法

/*
    代码块：在Java中，使用{}括起来的代码被称为代码块。
    根据其位置和声明的不同，可以分为
        局部代码块:局部位置,用于限定变量的生命周期。
        构造代码块:在类中的成员位置,用{}括起来的代码。每次调用构造方法执行前，都会先执行构造代码块。
            作用：可以把多个构造方法中的共同代码放到一起，对对象进行初始化。
        静态代码块:在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。
            作用：一般是对类进行初始化。
            
    面试题?
        静态代码块,构造代码块,构造方法的执行顺序?
        静态代码块 -- 构造代码块 -- 构造方法
        静态代码块：只执行一次
        构造代码块：每次调用构造方法都执行
*/
class Student {
    static {
        System.out.println("Student 静态代码块");
    }
    
    {
        System.out.println("Student 构造代码块");
    }
    
    public Student() {
        System.out.println("Student 构造方法");
    }
}

class StudentDemo {
    static {
        System.out.println("小源同学都21了，我很伤心");
    }
    
    public static void main(String[] args) {
        System.out.println("我是main方法");
        
        Student s1 = new Student();
        Student s2 = new Student();
    }
}
/*
    写程序的执行结果。
    
    小源同学都21了，我很伤心
    我是main方法
    Student 静态代码块
    Student 构造代码块
    Student 构造方法
    Student 构造代码块
    Student 构造方法
*/

继承

(1)把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，
      这多个类就具备了这些内容。这个关系叫继承。
(2)Java中如何表示继承呢?格式是什么呢?
    A:用关键字extends表示
    B:格式：
        class 子类名 extends 父类名 {}
(3)继承的好处：
    A:提高了代码的复用性
    B:提高了代码的维护性
    C:让类与类产生了一个关系，是多态的前提
(4)继承的弊端：
    A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。
        原则：低耦合，高内聚。
        耦合：类与类的关系
        内聚：自己完成某件事情的能力
    B:打破了封装性
(5)Java中继承的特点
    A:Java中类只支持单继承
    B:Java中可以多层(重)继承(继承体系)
(6)继承的注意事项：
    A:子类不能继承父类的私有成员
    B:子类不能继承父类的构造方法，但是可以通过super去访问
    C:不要为了部分功能而去继承
(7)什么时候使用继承呢?
    A:继承体现的是：is a的关系。
    B:采用假设法
(8)Java继承中的成员关系
    A:成员变量
        a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单
        b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢?
            子类的方法访问变量的查找顺序：
                在子类方法的局部范围找，有就使用。
                在子类的成员范围找，有就使用。
                在父类的成员范围找，有就使用。
                找不到，就报错。
    B:构造方法
        a:子类的构造方法默认会去访问父类的无参构造方法
            是为了子类访问父类数据的初始化
        b:父类中如果没有无参构造方法，怎么办?
            子类通过super去明确调用带参构造
            子类通过this调用本身的其他构造，但是一定会有一个去访问了父类的构造
            让父类提供无参构造
    C:成员方法
        a:子类的成员方法和父类中的成员方法名称不一样，这个太简单
        b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问呢?
            通过子类对象访问一个方法的查找顺序：
                在子类中找，有就使用
                在父类中找，有就使用
                找不到，就报错
(9)两个面试题：
    A:Override和Overload的区别?Overload是否可以改变返回值类型?
        Override：方法重写
        Overload：方法重载
        方法重写：在子类中，出现和父类中一模一样的方法声明的现象。
        方法重载：同一个类中，出现的方法名相同，参数列表不同的现象。
        方法重载能改变返回值类型，因为它和返回值类型无关。
            
    B:this和super的区别和各自的作用?
        this:代表当前类的对象引用
        super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员)  
        场景：
            成员变量：
                this.成员变量
                super.成员变量
            构造方法：
                this(...)
                super(...)
            成员方法：
                this.成员方法
                super.成员方法
                
(10)数据初始化的面试题
    A:一个类的初始化过程
    B:子父类的构造执行过程
    C:分层初始化

/*
    继承概述：
        把多个类中相同的内容给提取出来定义到一个类中。
        
    如何实现继承呢?    
        Java提供了关键字：extends
        
    格式：
        class 子类名 extends 父类名 {}
        
    好处：
        A:提高了代码的复用性
        B:提高了代码的维护性
        C:让类与类之间产生了关系，是多态的前提
    
    类与类产生了关系，其实也是继承的一个弊端：
        类的耦合性增强了。
        
        开发的原则：低耦合，高内聚。
        耦合：类与类的关系
        内聚：就是自己完成某件事情的能力
*/

//使用继承前
/*
class Student {
    public void eat() {
        System.out.println("吃饭");
    }
    
    public void sleep() {
        System.out.println("睡觉");
    }
}

class Teacher {
    public void eat() {
        System.out.println("吃饭");
    }
    
    public void sleep() {
        System.out.println("睡觉");
    }
}
*/

//使用继承后
class Person {
    public void eat() {
        System.out.println("吃饭");
    }
    
    public void sleep() {
        System.out.println("睡觉");
    }
}

class Student extends Person {}

class Teacher extends Person {}

class ExtendsDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.eat();
        s.sleep();
        System.out.println("-------------");
        
        Teacher t = new Teacher();
        t.eat();
        t.sleep();
    }
}

/*
    看程序写结果：
        A:成员变量  就近原则
        B:this和super的问题
            this访问本类的成员
            super访问父类的成员
        C:子类构造方法执行前默认先执行父类的无参构造方法
        D:一个类的初始化过程
            成员变量进行初始化
                默认初始化
                显示初始化
                构造方法初始化
                
    结果：
        fu
        zi
        30
        20
        10
*/
class Fu{
    public int num = 10;
    public Fu(){
        System.out.println("fu");
    }
}
class Zi extends Fu{
    public int num = 20;
    public Zi(){
        System.out.println("zi");
    }
    public void show(){
        int num = 30;
        System.out.println(num); //30
        System.out.println(this.num); //20
        System.out.println(super.num); //10
    }
}
class ExtendsTest {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

⭐

/*
    看程序写结果：
        A:一个类的静态代码块,构造代码块,构造方法的执行流程
            静态代码块 > 构造代码块 > 构造方法
        B:静态的内容是随着类的加载而加载
            静态代码块的内容会优先执行
        C:子类初始化之前先会进行父类的初始化
        
    结果是：
        静态代码块Fu
        静态代码块Zi
        构造代码块Fu
        构造方法Fu
        构造代码块Zi
        构造方法Zi
*/
class Fu {
    static {
        System.out.println("静态代码块Fu");
    }

    {
        System.out.println("构造代码块Fu");
    }

    public Fu() {
        System.out.println("构造方法Fu");
    }
}

class Zi extends Fu {
    static {
        System.out.println("静态代码块Zi");
    }

    {
        System.out.println("构造代码块Zi");
    }

    public Zi() {
        System.out.println("构造方法Zi");
    }
}

class ExtendsTest2 {
    public static void main(String[] args) {
        Zi z = new Zi();
    }
}

思考

1:代码块是什么?代码块的分类和各自特点?
2:静态代码块,构造代码块,构造方法的执行流程?
3:继承概述
4:继承的好处
5:Java中继承的特点
6:Java中继承的注意事项?以及我们什么时候使用继承?
7:继承中的成员访问特点
    A:成员变量
        在子类方法中访问一个变量
    B:成员方法
        在测试类中通过子类对象去访问一个方法
8:继承中构造方法的执行流程?假如父类没有无参构造方法，子类应该怎么办?
9:面试题：
    方法重写和方法重载的区别?方法重载能改变返回值类型吗?
    Overload
    Override

    this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。
10:继承案例练习
11:猜数字小游戏练习。
    通过API学习并使用Math类的random()方法。