java面向对象（四）

• **一、static关键字**
• • • 1.static能用来干什么
    • 2.怎么使用static
    • • 1.修饰属性
      • 2.修饰方法
      • 3扩展：静态代码块
    • 3.使用static注意事项
• 二、多态
• • • 1.多态概述
    • 2.多态使用的条件
    • 3.多态的案例
    • 4.多态的注意事项
    • 5.多态的作用及使用场景

static能用来干什么

怎么用static呢？

我们为什么要这么用

static是java内部规定的一个关键字，并且它在java内部的作用是作为修饰符使用的

• 修饰成员变量
• 修饰方法
• 修饰代码块

static String name;	//静态属性

被static定义的静态属性，无论实例化出多少个对象，没个对象改属性在内存空间中指向的都是同一个地方即只要有一个对象改变静态属性，其他对象的这个属性也会变化，是共享的

//静态方法
public static void eat(){
    
}

static用于方法的时候能够帮助我们更好的进行封装：

public class Fruit {
    private String name;
    private double price;
    private int store;

    private Fruit() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getStore() {
        return store;
    }

    public void setStore(int store) {
        this.store = store;
    }

    public static void show(){
        System.out.println("我是静态的show方法");
    }
}

测试类：

public class FruitTest {
    public static void main(String[] args) {
        Fruit.show();
    }
}

封装了构造方法和属性，只提供对外接口

父类：

public class Father {
    static {
        System.out.println("我是父类中的静态代码块");
    }
    public Father(){
        System.out.println("我是父类中的构造方法");
    }
   
}

子类：

public class Son extends  Father{
    static {
        System.out.println("我是子类中的静态代码快");
    }
    public Son() {
        System.out.println("我是子类中的构造方法");
    }
   
}

测试类：

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

执行结果：

“我是父类中的静态代码块”

“我是子类中的静态代码快”

“我是父类中的构造方法”

“我是子类中的构造方法”

• 静态代码块随类的加载而被执行，而且只执行一次
• 静态代码块的执行优先级比构造方法的优先级还要高，但子类的优先级要小于父类的（因为随类加载就被执行，而构造方法要实例化对象）

1.被static修饰的方法，只能用类名.方法名使用

2.static里不能使用this关键字

3.被static修饰的方法，在类加载的时候就被创建（而对象没有）

总结：

凡是被static修饰的（方法、属性），都是在类加载的时候就被创建出来

而普通成员变量要实例化对象，方法要入栈才能生存内存空间

并且，static修饰的生命周期长

1.多态是java封装、继承、多态的三大思想之一

2.多态意义的理解

• 现实世界中一个事物或行为具有多种状态。例如学生张三，他既是学生，又是人具有两种形态

1.多态分为编译时的多态和运行时的多态

编译时的多态多指的是在同一个类中，方法名相同而参数不同的方法重载

而运行时的多态发生在子类继承父类中，并且子类对父类的方法进行了重写

• 必须要有子类继承父类
• 子类必须重写父类的方法
• 父类的引用指向子类创建的对象的地址（又叫做向上转型，子类向上转型成父类）

向上转型：父类 对象 = new 子类();

父类A

public class A {

    public void show(){
        System.out.println("我是A");
    }
}

子类B

public class B extends A{

    @Override
    public void show() {
        System.out.println("我是B");
    }
}

测试类

public class Test {
    public static void main(String[] args) {
         A a = new B();	//B类对象向上转型

         a.show();
    }
}

请问，输出的答案是“我是A”还是“我是B”呢？

正确答案是：我是B

即使用A类的引用a的方法后，但表现的是子类B类的行为特征，而不是父类的行为特征，即相同引用类型的引用变量调用同一个方法时会出现多种不同的行为特征这就是多态

还是以上面的A、B为例子

​ A a = new B ();

理解：new B()是在堆内存中开辟出了一个空间，用于存放B类型的对象的值；A a是创建出一个A类的引用

所以，实际上是把A类引用指向了实例化出来的B类对象（）

可以理解为，a里面存放的是实例化出来的B类的地址，所以最终a对象里面的所有属性和方法都是B类里的

还有一点值得注意，A类里面没有的方法，B类里面有的方法，a不能调用

说明A a创建出来的引用虽然指向了B，但是却被父类A修饰了

让一个对象具有了多个行为，大大增强了程序的扩展性

当有多个子类对象，又想统一处理，减少代码量的时候，使用多态