类与对象（二）

接上一篇，这里主要讲述的是类与对象当中的封装，static成员、代码块、内部类、对象的打印。

目录

一、封装

1.1 访问限定符

1.2 包

1.2.1 导入包中类：

1.2.2 自定义包

二、static

2.1 static修饰成员变量

2.2 static修饰成员方法

 三、代码块

四、作者声明：

---

一、封装

概念：

面对对象程程序三大特征：封装、继承、多态。而类和对象阶段，主要研究的是封装特性。简单的来说，封装就是套壳屏蔽细节。

1.1 访问限定符

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

No	范围	private	defauft	protected	public
1	同一包中的同一类	✔	✔	✔	✔
2	同一包中的不同类		✔	✔	✔
3	不同包中的子类			✔	✔
4	不同包中的非子类				✔

public:公开的，谁都可以使用，可以看到。

default:在同有个包中不是秘密，对于其他的就看不到了。

private:只有自己知道，其他人不知道。

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

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

public class Computer {
    private String cpu;//cpu
    private String memory;//内存
    public String screen;//屏幕
    String brand;//default属性，品牌

    public Computer(String cpu, String memory, String brand, String screen) {
        this.cpu = cpu;
        this.memory = memory;
        this.brand = brand;
        this.screen = screen;
    }
    public void Boot(){
        System.out.println("开机~~~");
    }
    public void PowerOff(){
        System.out.println("关机~~~");
    }
    public void SurfInternet(){
        System.out.println("上网~~~");
    }
}

public class test {
    public static void main(String[] args) {
        Computer p = new Computer("HW", "i7", "8G", "13*14");
        System.out.println(p.brand); // default属性：只能被本包中类访问
        System.out.println(p.screen); // public属性： 可以任何其他类访问
// System.out.println(p.cpu); // private属性：只能在Computer类中访问，不能被其他类访问
    }

1.2 包

简单理解：相当于一个文件夹，为了更好的管理类，把多个类收集在一起成为一组，称为软件包

包是对类和接口等的封装机制的体现，是一种对类或者接口等很好的组织方式。包还有一个重要作用：在同一个工程中允许存在相同的类名，只要储存在不同的包中即可。

在Java中已经提供了许多现成的类供我们使用，那如何导入类呢？

1.2.1 导入包中类：

比如要导一个Date类

import java.util.Date;

java.util 是类所在的包名

Date 是包名

import 是导入包的语句

1.2.2 自定义包

基本规则：

1、在文件的最上方加上一个 package 语句指定该代码在哪个包中

2、包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式

3、包名要和代码路径相匹配 . 例如创建 com.baidu.demo1 的包 , 那么会存在一个对应的路径 com/baidu/demo1 来存储

代码 .

4、如果一个类没有 package 语句 , 则该类被放到一个默认包中 .

操作步骤：

1. 在 IDEA 中先新建一个包 : 右键 src -> 新建 -> 包

常见的包：

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。

2. java.lang.reflect:java 反射编程包;

3. java.net:进行网络编程开发包。

4. java.sql:进行数据库开发的支持包。

5. java.util:是java提供的工具程序包。(集合类等) 非常重要

6. java.io:I/O编程开发包

二、static

2.1 static修饰成员变量

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

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

享的 。

【静态成员变量特性】

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

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

3. 类变量存储在方法区当中

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

class Student{
    public String name;
    public String gender;
    public int age;
    public double score;
    public static String classRoom = "113";

    public Student(String name, String gender, int age, double score) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.score = score;
    }
}
public class Test {
    public static void main(String[] args) {
        //静态成员可以通过类名来访问
        System.out.println(Student.classRoom);
        Student student1 = new Student("lisi","man",18,89);
        Student student2 = new Student("zhaosi","man",19,67);
        System.out.println(student1.name+" "+ student1.gender+" "+student1.age+" "+student1.score);
        System.out.println(student2.name+" "+ student1.gender+" "+student2.age+" "+student2.score);
        //静态成员也可以通过对象来访问,但不推荐
        /*System.out.println(student1.classRoom);
        System.out.println(student2.classRoom);*/
    }
}

由此可见，static修饰了一个成员变量classRoom，而这个成员变量是这两个学生对象的共同属性，既然是共享的，就不需要另外开辟两个空间来储存classRoom，于是可以用static来修饰静态成员变量，单独储存在方法区中，而不是储存在某个对象的空间中

2.2 static修饰成员方法

一般类中的数据成员都设置成private，成员方法设置成public，如果将classRoom设置成private,那如何在类外访问classRoom的属性呢

class Student{
    private static String classRoom = "113";
}
public class Test {
    public static void main(String[] args) {       
        System.out.println(Student.classRoom);
//编译失败：java: classRoom 在 Student 中是 private 访问控制

那 static 属性应该如何访问呢？

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

class Student{
    private static String classRoom = "113";

    public static String getClassRoom() {
        return classRoom;
    }

    public static void setClassRoom(String classRoom) {
        Student.classRoom = classRoom;
    }
}
public class Test {
    public static void main(String[] args) {
        System.out.println(Student.getClassRoom());//113

【 静态方法特性 】

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

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

3. 不能在静态方法中访问任何非静态成员变量

public static String getClassRoom(){
System.out.println(this);
return classRoom;
}
// 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
public static String getClassRoom(){
age += 1;
return classRoom;
}
// 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age

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

public static String getClassRoom(){
doClass();
return classRoom;
}
// 编译报错：Error:(35, 9) java: 无法从静态上下文中引用非静态 方法 doClass()

 三、代码块

概念：使用{}定义的一段代码称为代码块

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

构造代码块：也叫实例代码块，构造代码块一般用于初始化实例成员变量jin

class Student{
    private String name;
    private String gander;
    private int age;
    //实例代码块
    {
        this.name = "lisi";
        this.gander = "man";
        this.age = 18;
    }
}
public class Test {
    public static void main(String[] args) {
       Student student = new Student();
    }
}

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

class Student{
    private static String classRoom;
   static{
       classRoom = "113";
   }
}

注意事项

1.静态代码块不管生成多少个对象，其只会执行一次

2.静态成员变量是类的属性，因此是在 JVM 加载类时开辟空间并初始化的

3.如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行 ( 合并 )

4.实例代码块只有在创建对象时才会执行

四、作者声明：

 感谢各位佬们的阅读，若各位发现不足之处或知识点有误的地方，欢迎大家在评论区纠正！！！十分感谢！！！！