static、final、多态_public static final eat(){}-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_45932374/article/details/120794969

1.static

1.1概念

是java中的一个关键字
用于修饰成员（成员变量和成员方法）

1.2特点

1.static可以修饰成员变量和方法
2.被static修饰的资源称为静态资源
3.静态资源随着类的加载而加载，最先加载，优先于对象进行加载
4.静态资源可以通过类名直接调用，也被称作类资源
5.静态被全局所有对象共享，值只有一份
6.静态资源只能调用静态资源
7.静态区域内不允许使用this与super关键字

1.3练习：static入门案例

package cn.tedu.oop;
/**本类用于静态static的入门案例*/
public class TestStatic1 {
    public static void main(String[] args) {
        Fruit.clean();//我们可以通过类名直接调用静态方法       类名.方法    调用静态方法
        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);//没提示

        /**静态资源在内存中只有一份，而且被全局所有对象共享
         * 所以：当我们通过任意一种方式修改了静态变量的值以后
         * 不管用何种方式查看，静态变量的值都是刚刚修改后的值*/
        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);

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

    //3.定义普通方法
    /**可以用static修饰方法吗？可以*/
    public static void clean(){
        System.out.println("洗水果~~");
    }
    public void grow(){
        System.out.println("水果长得好，很好吃~~");
    }
}

1.4练习：static静态调用关系

package cn.tedu.oop;
/**本类用于测试静态的调用关系
 * 总结：
 * 1.普通资源可以调用普通资源，也可以调用静态资源
 * 2.静态资源只能调用静态资源*/
public class TestStatic2 {
    public static void main(String[] args) {

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

1.5静态代码块、构造代码块、局部代码块

静态资源随着类的加载而加载，并且只被加载一次，一般用于项目的初始化
特点: 被static修饰,位置在类里方法外

1.5.1三种代码块的比较

静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化
构造代码块：在创建对象时会自动调用，每次创建对象都会被调用,提取构造共性
局部代码块：方法里的代码块,限制局部变量的范围

1.5.2练习：几种代码块的关系

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

2.final

2.1 概念

是java提供的一个关键字
final是最终的意思
final可以修饰类，方法，字段(属性)
初衷：java出现继承后，子类可以更改父类的功能，当父类功能不许子类改变时,可以利用final关键字修饰父类。

3.2 特点

被final修饰的类，不能被继承
被final修饰的方法，不能被重写
被final修饰的字段是个常量，值不能被修改
常量的定义形式：final 数据类型常量名 = 值

3.3练习：final入门案例

package cn.tedu.oop;
/**本类用于测试final关键字*/
public class TestFinal {
    public static void main(String[] args) {

    }
}

//1.定义父类
/**1.final可以用来修饰类，被final修饰的类是最终类，不可以被继承
 * 可以把被final修饰的类看成树结构中的叶子节点
 * */
//3.测试类被final修饰
//final class Father2{
class Father2{
    //4.定义父类的普通方法
    /**2.final可以用来修饰方法，被final修饰的方法是这个方法的最终实现，不可以被重写*/
    //public final void  work(){
    public void  work(){
        System.out.println("在工厂上班~~");
    }
}
//定义子类
class Son2 extends Father2{
    final int C = 66;//
    //5.重写父类的方法
    @Override//这个注解用来标记这是一个重写的方法
    public void work(){
        /**3.被final修饰的常量。常量的值不可以被修改
         * 注意：不管是成员位置还是局部位置，常量定义的时候必须赋值
         * 注意：常量的名称必须是全大写，单词与单词之间使用 _ 分割*/
        final int B = 100;
        //B = 200; //错，常量的值不可以被修改
        System.out.println("在互联网大厂上班~~");
        System.out.println(Integer.MAX_VALUE);
    }
}

3.多态

1. 概念

多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。

2.特点

多态的前提1：是继承
多态的前提2：要有方法的重写
父类引用指向子类对象,如：Animal a = new Cat();
多态中，编译看左边，运行看右边

3.多态的好处

多态可以让我们不用关心某个对象到底具体是什么类型,就可以使用该对象的某些方法
提高了程序的可扩展性和可维护性

4.多态的使用

前提:多态对象把自己看做是父类类型

成员变量: 使用的是父类的
成员方法: 由于存在重写现象,所以使用的是子类的
静态成员: 随着类的加载而加载,谁调用就返回谁的

5.设计汽车综合案例

package cn.tedu.oop2;

import javax.jws.soap.SOAPBinding;

/**本类用于完成汽车设计案例*/
public class DesignCar {
    public static void main(String[] args) {

        //9.创建一个纯纯的父类对象测试
        Car c = new Car();
        System.out.println(c.getColor());//null
        c.start();
        c.stop();
        //c.swim();//父类对象不可以调用子类的特有功能

        //10.创建一个纯纯的子类对象测试
        BMW b = new BMW();
        System.out.println(b.color);//黑色
        System.out.println(b.getColor());//null
        b.start();
        b.stop();

        //11.创建多态对象测试
        Car c2 = new TSL();
        System.out.println(c2.getColor());
        c2.stop();
        c2.start();
        //c2.swim();//把自己看成父类，所以不能使用子类特有功能



    }
}

//1.通过分析，抽象形成一个汽车类
class Car{
    //2.定义并封装汽车类的属性--成员变量
    private String brand;
    private String color;
    private int id;
    private double price;

    //3.1创建父类普通方法
    public void start(){
        System.out.println("我的车启动了~~");
    }
    public void stop(){
        System.out.println("我的车熄火了~~");
    }
    //get  set
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
}

//4.创建子类
class BMW extends Car{
    String color = "黑色";
    //6.重写父类方法
    @Override
    public void start(){
        System.out.println("我的车开的飞快~~");
    }
}
//5.创建子类
class TSL extends Car{
    //7.重写父类方法
    @Override
    public void stop(){
        System.out.println("刹车失灵");
    }
    //8.添加子类的特有功能
    public void swim(){
        System.out.println("我还是个潜水艇~！~！~！~！~！");
    }
}