Java 修饰符和多态

一、修饰符

1. 权限修饰符

2. 状态修饰符

2.1 final

final 关键字是最终的意思可以修饰成员方法、成员变量及类。

//1.修饰成员变量
public final int age = 20; //age的值不允许再改变

//2.修饰成员方法
public final void method() {} //该方法不允许被重写

//3.修饰类
public final class Father {} //该类不允许被继承

final 修饰的特点
① 修饰方法表明该方法是最终方法不能被重写
② 修饰变量表明该变量是常量不能再次被赋值
③ 修饰类表明该类是最终类不能被继承。

final 修饰的是基本类型的变量时变量的数据值不能发生改变当 final 修饰引用类型的变量时变量的地址值不能发生改变但地址里面的内容是可以改变的

2.2 static

static 关键字是静态的意思可以修饰成员方法和成员变量。

//Student.java
public static String university;

//Test.java
Student.university = "太原理工大学"; //直接通过类名为所有对象的公共部分赋值

static 修饰的特点
① 被类的所有对象共享这也是我们判断是否使用静态关键字的条件
② 被 static 修饰的变量和方法可以通过对象名调用也可以直接通过类名来调用推荐使用类名调用。

静态成员方法只能访问静态成员即 static 只能访问 static

二、多态

多态同一个对象在不同时刻表现出来的不同形态。

举例
我们可以说米是米米 rice = new 米()
我们也可以说米是粮食粮食 food = new 米()
这里米在不同的时刻就表现出来了不同的形态这就是多态。

多态的前提和体现
① 有继承或者实现关系
② 有方法重写
③ 有父类引用指向子类对象。

1. 成员访问特点

Animal a = new cat();
System.out.println(a.age);
System.out.println(a.eat());

1Cat 类继承 Animal 类不管是访问 a 的成员变量还是成员方法程序都会先去 Animal 里面找如果找不到该变量或方法程序直接报错即编译看左边。

2如果我们访问的是成员变量 a.age同时在 Animal 类中也找到该变量时我们所访问到的 age 也正是 Animal 中的 age即访问成员变量执行看左边。

3如果我们访问的是成员方法 a.eat()同时在 Animal 类中也找到该方法时我们此时访问到的 eat() 应是 Cat 类中重写父类方法的 eat()即访问成员方法执行看右边。

2. 多态中的转型

① 多态的好处提高了程序的扩展性定义方法的时候使用父类型作为参数将来在使用的时候使用具体的子类型参与操作
② 多态的弊端不能使用子类特有的功能因为编译看左边当多态访问成员变量或方法的时候都是先去父类中寻找的而父类中当然没有子类特有的功能当它找不到的时候编译就会报错。

针对多态的弊端有什么解决办法呢
多态转型分为向上转型和向下转型向上转型即父类引用指向子类对象向下转型是父类引用转为子类对象。
我们通过向下转型的方法解决不能使用子类特有功能的问题。

Animal a;
//向下转型
a = new Cat();
Cat c = (Cat)a;
c.playGame();
//向上转型
a = new Dog();
a.eat();

3. 多态案例

//Animal.java

package com.zxe;

public class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat() {
        System.out.println("动物吃东西");
    }
}

//Cat.java

package com.zxe;

public class Cat extends Animal {
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫爱吃鱼");
    }

    public void call() {
        System.out.println("喵喵喵~");
    }
}

//Dog.java

package com.zxe;

public class Dog extends Animal {
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗爱吃骨头");
    }
}

//Test.java

package com.zxe;

public class Test {
    public static void main(String[] args) {
        //这里仅以Cat为例Dog同理
        Animal a = new Cat();
        a.setName("加菲猫");
        a.setAge(5);
        System.out.println(a.getName() + ", " + a.getAge());
        a.eat();
        //想要用Cat的特有方法向下转型即可
        Cat c = (Cat) a;
        c.call();
    }
}