Java之类与对象（二）

目录

 6.封装

6.1封装的概念

6.2访问限定符

7.static成员

8.代码块

8.1普通代码块

8.2构造代码块

8.3静态代码块

---

6.封装

6.1封装的概念

面相对象程序三大特性：封装、继承、多态。

而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节。

对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

• 封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互
• 封装:从语法层次上来说，就是把字段或者方法使用private修饰符进行修饰，这样在类外就不能拿到当前字段或者方法了，起到了封装的作用。就是隐藏内部实现细节，只对外提供特定的公开的，可访问的接口就可以了.
   

6.2访问限定符

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。

Java中提供了四种访问限定符：

public：可以理解为一个人的外貌特征，谁都可以看得到

default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了

private：只有自己知道，其他人都不知道

【说明】

protected主要是用在继承中，继承部分详细介绍

default权限指：什么都不写时的默认权限

访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

7.static成员

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。

class Student{
    private String name;
    private int age;
    private int id;

    public static String school;//学校，成员变量不属于对象，属于类   静态的成员变量
    public Student(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    public Student(int age) {
        this.age = age;
    }
    
    public Student(){
        this.school=school;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student student=new Student();
        Student student1=new Student();
        System.out.println(student.school);//不合理  不合法   不建议这样写
        System.out.println(Student.school);//合理的 建议这样访问静态的成员
    }
}

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3. JDK7及以前，HotSpot(Java虚拟机)中存储在方法区，JDK8及之后，类变量存储在Java堆中

4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

class Test1{
    public int a1;
    public static int a2;

}
public class TestDemo2 {
    public static void main(String[] args) {
        Test1 test1=new Test1();
        test1.a1++;
        test1.a2++;

        Test1 test2=new Test1();
        test2.a1++;
        test2.a2++;
        System.out.println(test1.a1);//1
        System.out.println(Test1.a2);//2----静态成员变量可以直接通过类名访问
    }
}

被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。

【静态方法特性】

1. 不属于某个具体的对象，是类方法

2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者

3. 静态方法没有隐藏的this引用参数，因此不能在静态方法中访问任何非静态成员变量

4. 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

8.代码块

使用 {} 定义的一段代码称为代码块。

根据代码块定义的位置以及关键字，又可分为以下四种：

1.普通代码块

2.构造块

3.静态块

4.同步代码块

8.1普通代码块

普通代码块：定义在方法中的代码块。

public class Main{
public static void main(String[] args) {
{ //直接使用{}定义，普通方法块
int x = 10 ;
System.out.println("x1 = " +x);
}
int x = 100 ;
System.out.println("x2 = " +x);
}
}
// 执行结果
x1 = 10
x2 = 100

8.2构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。

构造代码块一般用于初始化实例成员变量。

class Studentt{
    //实例成员变量
    private String name;
    private int age;
    private String sex;
    public Studentt() {
        System.out.println("I am Student init()!");
    }
    //实例代码块
    {
        this.name = "lll";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}
public class mmmm {
    public static void main(String[] args) {
        Studentt studentt=new Studentt();
        studentt.show();
    }
}

实例代码块优先于构造方法执行，因为编译完成后，编译器会将实例代码块中的代码拷贝到每个构造方法第一条语句前。

8.3静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

class Student{
    private String name;
    private int age;
    private int id;

    public static String school;//学校，成员变量不属于对象，属于类   静态的成员变量

    public Student(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
        System.out.println("带有3个参数的构造方法！");
    }

    {
        this.name="实例代码块！";
        //school="hafu!";//实例代码块的初始化
        System.out.println("实例代码块-》定义在类的内部，和构造方法等方法同级，主要初始化实例的成员");
    }

    static {//
        //this.name="实例代码块！";//报错，不依赖于对象，没有this
        school="hafu!";
        System.out.println("静态代码块-》定义在类的内部，和构造方法等方法同级。主要初始化静态的成员");
    }

    public Student(int age) {
        this.age = age;
    }

    public Student(){
        System.out.println("不带参数的构造方法");
    }

    public String getName() {
        return name;
    }

    public void eat(){
        System.out.println(this.name+"吃饭");
    }

    public void sleep(){
        eat();
    }
    /**
     * 1.不要在静态方法里面使用this
     * 2.不能在静态方法里面 直接调用静态方法
     * @return
     */

    public static String getSchool(){
        Student student=new Student();
        student.eat();//在静态方法里面 利用new调用静态方法
        return school;//静态
        //return this.school;//报错
        //this.name="libai";//报错


    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student student=new Student();//实例化一个对象
    }
}

执行发现

 说明类中执行代码先执行静态代码块

注意事项

1. 静态代码块不管生成多少个对象，其只会执行一次
2. 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
3. Java代码在经过编译器编译之后，如果要运行必须先要经过类加载子系统加载到JVM中才能运行。在加载阶段： 在链接阶段第二步准备中会给静态成员变量开辟空间，并设置为默认值，在初始化阶段，会执行静态代码块中的代码。
4. 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次合并，最终放在生成的 <>方法中，该方法在类加载时调用，并且只调用一次。
5. 实例代码块只有在创建对象时才会执行。

注意：当我们执行下面代码时， 

 结果为

 发现在都是静态的情况下，静态成员变量的取值被后者取代

那交换一下位置，发现

 同样，在都是静态的情况下，静态成员变量的取值被后者取代，说明都是静态的情况下，静态成员变量的取值与顺序是有关的。

总结：

静态static可以修饰：
1、成员变量-“静态的成员变量：通过类名.静态进行访问，属于类，不属于对象.
2、成员方法-“静态成员方法：通过类名.静态进行访问，属于类，不属于对象.
3、修饰代码块->“静态代码块-”>会在实例代码块，构造方法之前执行，且执行1次.