1.修饰符

1.1包和导包

概述：包就是文件夹。分开放类，对类管理和整理
定义格式：
package（包名） 多级包用.分开
手动导包：(了解)
导包：import 包名

1.2修饰符

1.2.1权限修饰符

在这里插入图片描述

1.2.2final

final关键字，最终的意思，可以修饰成员方法，成员变量，类
特点：

修饰方法：最终方法，不能被重写
修饰变量：表明变量是常量，不能再次被赋值
修饰类：最终类，不能被继承

final修饰局部变量

变量类型是基本变量：数据值不能改变
变量类型是引用变量：地址值不能改变，但是地址内容可以改变

public class helloworld {
    public static void main(String[] args) {

        final int price = 20;
        System.out.println(price);//20


        //final引用变量
        final Phone p = new Phone();
        p.price = 1000;
        System.out.println(p.price);//1000
        }
}

1.2.3static

static是静态的意思，可以修饰成员变量、成员方法

被类的所有对象共享使用，这也是判断是否使用static关键字的条件

public class Student {
    public String name;
    public int age;
    public static String school;
    public void show(){
        System.out.println(name+","+age+","+school);
    }


public class StudentDemo {
    public static void main(String[] args) {
        //static静态
        Student.school = "cczu";

        Student s1 = new Student();
        s1.name = "wts";
        s1.age = 21;

        Student s2  = new Student();
        s2.name = "ccy";
        s2.age = 30;

        s1.show();//wts,21,cczu
        s2.show();//ccy,30,cczu
    }
}

静态访问特点
静态成员方法只能访问静态成员

2.多态

2.1概述和前提

概述：同一对象，在不同时刻表现出的不同状态。
多态的前提和体现：

有继承/实现关系
有方法重写
有父类的引用指向子类对象（eg：动物 Animal = new 猫（））

2.2多态中的成员访问特点和利弊

成员变量：编译看左边，运行看左边
成员方法：编译看左边，运行看右边（因为成员方法重写，而成员变量没有）

多态的利弊：

好处：提高扩展性
具体体现：定义方法的时候，使用父类作为参数，将在使用的时候，使用具体子类型参与操作

案例：动物吃东西（猫吃鱼，狗吃骨头，猪吃白菜）的动态，狗看门不能使用。

package catanddog;

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

package catanddog;

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

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

package catanddog;

public class Dog extends Animal {

    public Dog() {
    }

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

    public void lookDoor() {
        System.out.println("狗看门");
    }
}

package catanddog;

public class AnimalOpter {
    public void useAnimal(Animal a) {
        //Animal a = new Cat();
        //Animal a = new Dog();
        a.eat();
    }
}

package catanddog;

public class AnimalDemo {
    public static void main(String[] args) {
        AnimalOpter ao = new AnimalOpter();
        Cat c = new Cat();
        ao.useAnimal(c);//猫吃鱼

        Dog d = new Dog();
        ao.useAnimal(d);//狗吃骨头
    }
}

小结：子类们共有的特性（吃东西）由父类整合，再用一个类引用父类，从而引用所有的共性的子类的动作，纯属个人小理解

2.3多态的转型

向上转型
从子类到父，父类引用指向子类对象
向下转型
从父到子，父类引用转为子类

package catanddog;

public class Dog extends Animal {

    public Dog() {
    }

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

    public void lookDoor() {
        System.out.println("狗看门");
    }
}

package catanddog;

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

package catanddog;

public class AnimalDemo {
    public static void main(String[] args) {

        Animal a = new Dog();//向上转型
        a.eat();//狗吃骨头

/*        Dog d = new Dog();
        d.eat();//狗吃骨头
        d.lookDoor();//狗看门
        */

        Dog d = (Dog) a;//向下转型
        d.eat();//狗吃骨头
        d.lookDoor();//狗看门

    }
}

多态转型内存图解