Java SE 封装 static详细讲解

在面向对象的语言有几个比较重要的特征分别是：封装，继承，多态（并不是只有java有面向对象）

1.什么是封装为什么要进行封装

1.1.1什么是封装

1.套壳屏蔽细节。

2.可以理解为我们使用电脑我们并不用造电脑，直接拿来用就行，所以就可以说，封装就是将类进行封装，我们通过接口进行访问它的功能。

2.如何用java代实现封装

2.1 private 关键字

1.private关键字加上以后这个修饰的语句的权限就缩小到了这个类里面。

2.1.1 如何使用被private修饰的成员变量和方法。

这时候我们就引出一个问题，如果我们需要在类外调用private这个关键字修饰的成员变量或者方法，我们该如何使用呢？

1.我们可以使用两个公共的方法进行对这个私有方法或者变量进行调用。

2.第一个方法是用来修改private修饰私有变量和私有方法，是set方法(修改)。

3.第二个方法是用来调用被private修饰的私有变量和私有方法，是get方法（调用）。

4.代码实现。

class Person{

    private String name ;
    //一个name的私有变量//

    public  Person(String name ){
        this.name = name ;
    }//构造方法初始化//


    public String getName() {
        return this.name;
    }//get方法用来调用私有变量//



    public void setName(String name) {
        this.name = name;
    }//set方法用来修改私有变量//


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

}
public class Frank {

    public static void main(String[] args) {
        Person per = new Person("张三");//实例化一个对象//
        System.out.println(per.getName());//调用私有变量//
        per.setName("Frank");//修改私有变量
        per.eat(per.getName());//调用eat方法//
    }
}

(在类中你不用构造方法这个成员就会自己初始化）

（同学们会问如果我写了好几个私有变量那么我要一个一个写get方法和set方法吗，idea中给人我们提供了快捷键是 alt+instent 我们点了以后可以用ctrl键来选择成员实现get和set方法）

5.构造方法也是可以进行私有化的，只要把public改成peivate，一般情况下我们不对构造方法进行私有化。

3.2java访问修饰符

1.public公开的全部都可以访问。（被public修饰的）

2.peivate私有的 只有在当前类中可以访问。

3.defult 是什么都不写，只能再同一个包中的类中才能使用。（默认情况）

4.protected 不同包的子类可以使用。

4.3java包的概念

1.为了更好的管理类我们把一些类放到一个共同的文件夹中，可以理解为把类放到文件夹中更好的进行管理。（在包中我们会把类和接口等等进行组织）

4.3.1如何创建一个包

1.命名规则:com.bit.www(创建了三个包分别是com，bit，www，（bit在com下面，www在bit下面）)     在不同包中建相同名称的类是不冲突的，但是相同包下建相同名称的类是冲突的。

2.在类的代码的最上面会有一个package代码来告诉你是哪个文件夹下面

如果没有就是这个类在默认的src这个文件夹下面。（可以先建包再建类）

4.3.2使用包的技巧

1.java中的所有类都是放到util类中

2.import导入包

import java.util.Date;//告诉idea date包是从哪导入的
Date time = new Date();

3.如果想写麻烦一点假如我想使用Date类我不用import语句可以这样写

java.util.Date Date= new java.util.Date() ;

（这个你用一次date类就要用一次太麻烦不建议用）（java包中的until文件夹下的date文件夹中的date类代码意思)

4.有没有更好的方法要哪一个就匹配哪一个

import.java.until.*

（有，当然有（土拨鼠叫）不建议用容易出问题）

5.还有一个impor static 我提一嘴感兴趣可以了解建议不用，使用起来对强迫症不是很舒服。（不建议写，这叫静态导入）。

4.4 static 静态关键字

4.4.1 static作用

1.没用static和用了static的对比。

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

    public String getName() {
        return name;
    }

    public int getClassroom() {
        return classroom;
    }

    public int getAge() {
        return age;
    }


    public Student(String name,int classroom,int age) {
        this.name = name;
        this.classroom = classroom;
        this.age = age ;
    }
}
public class Frank {

    public static void main(String[] args) {
        Student  number_1  = new Student("lili",202,19);
        Student  number_2  = new Student("Frank",202,21);
        Student  number_3  = new Student("Frank_son",202,24);
        System.out.println(number_1.getClassroom());
        System.out.println(number_2.getClassroom());
        System.out.println(number_3.getClassroom());


    }
}

在这段代码中有重复的三个值是classroom，都是202，所以输出的三个结果都是202，但是呢我要分别输出三次调用三次这样是不是十分的繁琐，我们是不是想把这个重复的步骤去掉，这时候就可以体现出static的作用了。

class Student{
    private String name ;

    private int age ;

    public static String Classroom_2 ;

    public String getName() {
        return name;
    }

//    public int getClassroom() {
//        return classroom;
//    }

    public int getAge() {
        return age;
    }
    public Student(String name,int age) {//int classroom在（）去了
        System.out.println("name"+name+ "age"+age);
    }

    public static int classroom(){
        return  202 ;
    }

}
public class Frank {

    public static void main(String[] args) {
//        Student  number_1  = new Student("lili",202,19);
//        Student  number_2  = new Student("Frank",202,21);
//        Student  number_3  = new Student("Frank_son",202,24);
//        System.out.println(number_1.getClassroom());
//        System.out.println(number_2.getClassroom());
//        System.out.println(number_3.getClassroom());
        Student  number_1  = new Student("lili",19);
        Student  number_2  = new Student("Frank",21);
        Student  number_3  = new Student("Frank_son",24);
        System.out.println("lili 教师是"+Student.classroom());//静态方法的使用
        Student.Classroom_2 = "202" ;//访问static修饰的变量
        number_1.Classroom_2 = "202";//第二种访问方法不推荐
    }
}

4.4.2 static的特性

1.从上面的代码可以看出static的作用，它可以从类当中直接调用，记住是类而不是对象，被static所修饰的变量和方法是脱离对象的。记住完全脱离对象不依附于对象的这是十分重要的！！！！！

2.static的一些问题！！！

在4.4.1中的第二张图中为什么在最后一行代码number_1调用了classroom_2这个静态成员变量，他不是不依附于对象吗？

答案是，这些静态成员变量和静态成员方法都存入了方法区中可以理解为number_1，这个对象调用方法区中的方法（这是很不推荐的用法！！！）我们还是建议通过类来对静态方法和静态变量进行调用，因为如果是按红字的方法进行，那么编译器会给你一个警告！！！

3.总结

1.在类中有两种成员变量分别是

（1）.静态成员变量

（2）.非静态成员变量

2.被static修饰的是静态的，完全不依赖对象。

3.静态的当类加载的时候会加载，类销毁的时候会消失（在后面jvm文章会来进行讲解）

4.静态的只能是全局变量。（语法，不知道为什么）！！

5.在静态方法内部不能使用非静态，也就是不能出现this，总的来说就是不能使用依赖对象的而this依赖了对象。

6.main方法理论上可以不是静态的但是在java虚拟机中给他变成静态的了。

5.代码块

5.1 实例代码块

1.第二个被执行的代码块。

2.模板

{
   // 代码块中的代码
}

public class Main {
    public static void main(String[] args) {
        int x = 10;
        {
            int y = 20;
            System.out.println("x: " + x);
            System.out.println("y: " + y);
        }

        // 在这个作用域内无法访问变量y
        System.out.println("x: " + x);
    }
}

5.2静态代码块

1.优先执行静态代码块，两个静态代码块先执行上面的静态代码块。

2.不依赖于对象只要类被加载就会执行

3.模板

static {
   // 代码块中的代码
}

public class MyClass {
    static int count;

    static {
        count = 0;
        System.out.println("Static block initialized.");
    }

    MyClass() {
        count++;
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj1 = new MyClass();
        MyClass obj2 = new MyClass();
        MyClass obj3 = new MyClass();

        System.out.println("Count : " + MyClass.count);
    }
}

3.最后被执行的是构造方法！！

4.静态代码块和静态变量之间是可以结合使用的。静态变量是在类加载时初始化的，而静态代码块可以在初始化静态变量之前执行一些其他的操作。这两者通常一起使用来初始化静态变量，也可以在静态代码块中进行其他的静态操作。

public class MyClass {
    static int count;
    static int defaultValue;

    // 静态代码块用于初始化静态变量
    static {
        count = 0;
        defaultValue = 100;
        System.out.println("Static block initialized.");
    }

    MyClass() {
        count++;
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj1 = new MyClass();
        MyClass obj2 = new MyClass();
        MyClass obj3 = new MyClass();

        System.out.println("Count: " + MyClass.count);
        System.out.println("Default Value: " + MyClass.defaultValue);
    }
}