JavaSE-day08

重写

如果子类继承了父类的方法并且对父类的方法不满意时，可以重写父类的方法

重写的原则：两同 两小 一大

两同：子类方法的 方法名与参数列表 和父类方法的相同

一大：子类方法的 方法修饰符权限>=父类方法的

两小：子类方法的返回值类型<=父类方法的返回值类型

注意：这里的<=是指子类的返回值类型是父类返回值类型的子类

或者与父类的返回值类型一致，如果父类方法的返回值类型是void或基本数据类型，那子类保持一致即可

静态代码块

格式：static{}

位置：类里方法外

执行时机：静态代码块也属于静态资源，随着类的加载而加载，优先于对象加载

并且静态资源只会加载一次

作用：用于加载那些需要第一时间就加载，并且只加载一次的资源，常用来初始化

基本案例：

/*本类用于测试代码块*/
public class TestBlock {
    public static void main(String[] args) {
        Apple a=new Apple();
        Apple a1=new Apple();
    }
}
//1.创建类
class Apple{
    //6.创建本类的静态代码块
    /*格式：static{}
    位置：类里方法外
    执行时机：静态代码块也属于静态资源，随着类的加载而加载，优先于对象加载
            并且静态资源只会加载一次
    作用：用于加载那些需要第一时间就加载，并且只加载一次的资源，常用来初始化*/
    static {
        System.out.println("我是一个静态代码块");
    }
    //2.创建本类的构造代码块
    /*位置：类里方法外
    执行时机：创建对象时执行，并且优先于构造代码块执行
    作用：用于提取所有构造方法的共性功能*/
    {
        System.out.println("我是构造代码块");
    }
    //3.创建本类的无参构造
    public Apple(){
        System.out.println("无参构造");
    }
    //4.创建本类的普通方法
    public void clean(){
        System.out.println("我是一个普通方法");
        //5.创建本类的局部代码块
        /*位置：方法里
        执行时机：调用所处方法时才会执行
        作用：用于控制变量的作用范围*/
        {
            System.out.println("我是局部代码块");
        }
    }
}

Final关键字

1. final可以用来修饰类，被final修饰的类是最终类，不可以被继承。（可以把被final修饰的类看成树结构中的叶子结点）

2. final可以用来修饰方法，被final修饰的这个方法是这个方法的最终实现，不可以被重写

3. 被final修饰的常量，不可以再次赋值

注意：不管成员变量还是局部变量，常量定义的时候必须赋值

注意：常量的名称必须是全大写，单词与单词之间要用下划线分开

static关键字

1. 被static修饰的资源统称为静态资源

2. 静态资源是随着类的加载而加载到内存中的，比对象优先加载，所以静态资源可以通过类名直接调用，即使没有创建对象，也可以调用

3. 可以用static修饰属性，也可以用static修饰方法

4. 静态资源在内存中只有一份，而且被全局所有对象所共享。所以：当我们通过任意一种方式修改了静态变量的值以后，不管用何种方式查看，静态变量的值都是刚刚修改后放入值

以下是基本案例

/*本类用于静态static的入门案例*/
public class TestStatic1 {
    public static void main(String[] args) {
        Fruit.clean();//我们可以通过类名直接调用静态方法，这个IDEA会提示
        System.out.println(Fruit.kind);//类名直接调用静态属性

        Fruit f=new Fruit();
        Fruit f2=new Fruit();
        f.grow();
        f.clean();//没有提示需要自己写

        System.out.println(f.weight);
        System.out.println(f.kind);

        /*3.静态资源在内存中只有一份，而且被全局所有对象所共享
        所以：当我们通过任意一种方式修改了静态变量的值以后
        不管用何种方式查看，静态变量的值都是刚刚修改后放入值*/
        Fruit.kind="苹果";
        System.out.println(Fruit.kind);
        System.out.println(f.kind);
        System.out.println(f2.kind);

        f.kind="香蕉";
        System.out.println(Fruit.kind);
        System.out.println(f.kind);
        System.out.println(f2.kind);

        f.kind="猕猴桃";
        System.out.println(Fruit.kind);
        System.out.println(f.kind);
        System.out.println(f2.kind);
    }
}
/*0.被static修饰的资源统称为静态资源
静态资源是随着类的加载而加载到内存中的，比对象优先加载
所以静态资源可以通过类名直接调用，即使没有创建对象，也可以调用*/
//1.创建水果类
class Fruit{
    //2.定义属性
    /*1.可以用static修饰属性*/
    static String kind;//品种
    double weight;//重量

    //3.定义普通方法
    /*2.可以用static修饰方法*/
    public static void clean(){
        System.out.println("洗水果");
    }
    public void grow(){
        System.out.println("这个果子长得一看就很好吃");
    }
}

静态的调用关系总结：

1.普通资源既可以调用普通资源，也可以调用静态资源

2.静态资源只能调用静态资源

5. 静态区域内不允许使用this和super关键字

以下是基本案例

/*本类用于测试静态的调用关系
总结：
1.普通资源既可以调用普通资源，也可以调用静态资源
2.静态资源只能调用静态资源
3.静态区域内不允许使用this和super关键字*/
public class TestStatic2 {
    public static void main(String[] args) {

    }
}
//1.创建老师类
class Teacher{
    //2.定义老师类的普通属性和方法
    String name;//姓名
    public void teach(){
        /*1.普通资源能调用静态资源*/
        ready();
        System.out.println(id);
        System.out.println("授课中....");
    }
    //3.定义老师类的静态属性和方法
    static int id;//工号
    public static void ready(){
        System.out.println("正在备课中...");
        /*2.静态资源不能调用普通资源*/
//        System.out.println(name);
    }
    public static void eat(){
        /*3.静态资源可以调用静态资源*/
        System.out.println("吃肉");
        System.out.println(id);
        ready();
    }
}

面向对象的三大特征----多态

1. 多态的前提：继承+重写

2. 父类对象不可以使用子类的特有功能

3. 口诀1：父类引用指向子类对象

解释：创建出来的子类对象的地址值，交给父类类型的引用类型变量来保存

4. 口诀2：编译看左边，运行看右边

解释：必须要在父类定义这个方法，才能通过编译，编译时，把多态对象看做是父类类型

必须要在子类重写这个方法，才能满足多态，实际干活的是子类

5. 多态中，成员变量使用的是父类的

6. 多态中，方法的声明使用的是父类的，方法体使用的是子类的

7. 多态中，调用的静态方法是父类的，因为多态对象把自己看作是父类类型。直接使用父类中的静态资源

以下是基本案例

/*本类用于测试多态成员的使用情况*/
public class TestDemo2 {
    public static void main(String[] args) {
        //7.创建一个“纯纯的”子类对象
        Dog2 d=new Dog2();
        System.out.println(d.sum);//子类自己的属性
        d.eat();//自己的方法

        //8.创建多态对象
        /*口诀1：父类引用指向子类对象
        * 口诀2：编译（保存）看左边，运行（效果）看右边*/
        Animal2 a=new Dog2();
        /*多态中，成员变量使用的是父类的*/
        System.out.println(a.sum);//10
        /*多态中，方法的声明使用的是父类的，方法体使用的是子类的*/
        a.eat();//小狗爱吃肉包子
        /*多态中，调用的静态方法是父类的，因为多态对象把自己看作是父类类型
        * 直接使用父类中的静态资源*/
        a.play();//没有提示

    }
}
//1.创建父类
class Animal2{
    //3.创建父类的成员变量
    int sum=10;
    //4.创建父类的普通方法
    public void eat(){
        System.out.println("吃啥都行—");
    }
    //9.1定义父类的静态方法
    public static void play(){
        System.out.println("小动物玩啥都行");
    }
}
//2.创建子类
class Dog2 extends Animal2{
    //5.定义子类的成员变量
    int sum=20;
    //6.重写父类的方法
    @Override
    public void eat(){
        System.out.println("小狗爱吃肉包子");
    }
    //9.2定义子类的静态方法
//    @Override
    /*这不是一个重写的方法，只是恰巧在两个类中出现了一模一样的两个静态方法
    * 静态资源属于类资源，只有一份，不存在重写的现象
    * 在那个类里定义，就作为那个类的资源使用*/
    public static void play(){
        System.out.println("小狗爱玩皮球");
    }
}