多态，封装，包，static，初始化块

目录

一.多态

二.封装

三.包

四.static

 五.初始化块

---

一.多态

        相同类型的变量，调用同一个方法时呈现出多种不同的行为特征。

前提：继承与覆写

出现：向上转型

判断：左为编译类型，右为运行类型

#意义：允许添加更多类型的子类实现功能扩展，却不需要修改基于父类的代码。

public class Main {
    public static void main(String[] args) {
        Animal A=new Cat();
        Animal B=new Dog();
        A.Call();//喵喵喵
        B.Call();//汪汪汪
    }
}
class Animal{
    String name;
    public void Call(){

    }
}
class Cat extends Animal{
    public void Call()
    {
        System.out.println("喵喵喵");
    }
}
class Dog extends Animal{
    public void Call()
    {
        System.out.println("汪汪汪");
    }
}

二.封装

        指将对象的状态信息隐藏在内部，不允许外部直接访问，而是通过该类中的方法操作/访问

意义：

1. 隐藏实现细节
2. 避免逻辑混乱
3. 对数据进行检查，保证信息的完整
4. 便于修改，提高代码的可维护性

 实现：

依赖于三个访问控制符：private,protect,public

不加默认为default

控制级别表：

 外部类 只能被public与default修饰

对于一个封装良好的类，使用setter与getter方法来操作与访问成员变量

setter方法中常常包含控制逻辑

public class Main {
    public static void main(String[] args) {
        Person p=new Person();
        p.setName("Elysia");
        p.setAge(18);
        p.setSex("Female");
        System.out.println(p.getName()+"\n"+p.getSex()+"\n"+p.age());
    }
}

class Person{
    private int age;
    private String name;
    private String sex;
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getSex(){
        return sex;
    }
    public void setSex(String sex){
        if(sex.equals("Man")||sex.equals("Female")) {
            this.sex = sex;
        }
    }
    public int age(){
        return age;
    }
    public void setAge(int age){
        if(age>=0&&age<=150){
            this.age=age;
        }
    }
}

三.包

        理解：包即文件夹，其中存放了类，不同的包中类可以重名。

        意义：解决了类的命名冲突、类文件管理等问题

（一）package

1.使用package将类放于指定包中

        package packageName;//第一行

2.规定：位于包中的类，在文件系统中也必须有与包名层次相同的目录结构

        即java文件的目录结构与class的目录结构相一致

 3.先给java源文件建包，再使用package声明

        执行package命令时，将自动在相应的位置建立class文件

（二）import

        导入指定包层次下的某个类或全部类

1.使用：

1. 导入单个类： import pack.sub. ... .Classname;
2. 导入指定包下的全部类： import pack.sub. ... .*;

2.意义：

        简化代码

可将        pack.sub. ... .ClassName x=new  pack.sub. ... .ClassName();

//import package1.name1;
//import package2.name2;
public class Main {
   public static void main(String[] args) {
        System.out.println("Hello world!");
        //name1 x1=new name1();
       package1.name1 x1=new package1.name1();
        //name2 x2=new name2();
       package2.name2 x2=new package2.name2();
        x1.test();//package1下的类
        x2.test();//package2下的类
    }
}

 简化为 ClassName x=new ClassName();

import package1.name1;
import package2.name2;
public class Main {
   public static void main(String[] args) {
        System.out.println("Hello world!");
        name1 x1=new name1();
       //package1.name1 x1=new package1.name1();
        name2 x2=new name2();
       //package2.name2 x2=new package2.name2();
        x1.test();//package1下的类
        x2.test();//package2下的类
    }
}

即省略文件路径

3.java默认导入java.lang包

（三）import static

        导入指定类的单个/全部静态成员、方法

1.使用：

        import static pack.sub. ... .Class.field|method;

        import static pack.sub. ... .*;

（四）java源文件大体结构

package ...;
import|import static ...;
public class|interface|enum{}
class|interface|enum{}

四.static

        可用与修饰成员变量、方法等成员。

static修饰的成员属于类本身，不独属于该类的单个实例

（一）静态变量

1.理解：又称类变量，是所有该类实例共享的。

2.区别：

1. jvm只会为类变量分配一次内存，在加载类信息时完成
2. 在类的内部，任意成员可直接访问类变量；静态成员不能直接访问实例变量，须通过实例对象访问。
3. 在其他类中，既可以通过实例对象，也可以通过类名 访问类变量；实例变量通过实例对象访问。

public class Main {
    public static void main(String[] args) {
        System.out.println(Family.F_property);//输出这个家庭的总资产
        Family Dad=new Family("Dad",80000);
        Family.F_cost(200);
        System.out.println(Family.F_property);
    }
}
class Family{
    static double F_property=200000;//家庭总资产
    double personal;//个人资产
    String identify;//家庭身份
    public Family(String identify,double personal){
        this.identify=identify;
        this.personal=personal;
    }
    public void increase(double income){
        F_property+=income;
    }
    public void get_living(int get){
        personal+=get;
        F_property-=get;
    }
    public static void F_cost(double cost){
        F_property-=cost;//家庭开销
        personal+=cost;//企图占据家庭资产，报错,F_cost,无法访问personal
    }
}

3.意义： 

1. 实例之间共享静态变量，增加实例之间的交互性
2. 节省内存
3. 可当作全局变量使用，标记状态book，flag

 （二）静态方法  类方法

1. 可通过类名直接调用，不需要new一个对象
2. 在类的内部，任意成员可直接调用类方法；静态成员不能直接调用实例方法
3. 静态方法中，不能使用this，super关键字，二者与实例有关

意义：1.使用方便        2. 用于工具类中的方法定义，类似于函数 

在类的内部：任意成员可以访问静态成员，静态成员不能直接访问非静态成员

（三）静态代码块

        用static修饰的代码块{ }

1. 不可存在于方法内
2. 加载类时执行，只执行一次
3. 不能访问非静态成员
4. 用static修饰初始化块，就是静态初始化块

 五.初始化块

1.格式        [修饰符]{

                        //可执行语句

                }        //修饰符要么不加，要么只能加static

2.执行顺序

初始化块和声明时赋的值，谁在前，谁先执行。

二者都先于构造器执行（编译后，初始化代码会“还原”到构造器中的前面）

先执行父类，在执行子类。

普通在创建对象时执行，静态在加载类时执行。

3.意义：将多个构造器中的相同无参初始化代码  提取到初始化块中。让代码更简洁，提高可维护性。

public class Main {
    public static void main(String[] args) {
        new SubClass();
        new SubClass();
    }
}
class SuperClass{
    {
        System.out.println("SuperClass的普通初始化块，创建对象时执行");//2次
    }
    static{
        System.out.println("SuperClass的静态初始化块，加载类时只执行一次");//一次
    }
    public SuperClass(){
        System.out.println("SuperClass的构造器");//2次
    }
}
class SubClass extends SuperClass{
    {
        System.out.println("SubClass的普通初始化块，创建对象时执行");//2
    }
    static{
        System.out.println("SubClass的静态初始化块,加载类时只执行一次");//1
    }
    public SubClass(){
        System.out.println("SubClass的构造器");//2
    }
}