目录

1. 封装

1.1 什么是封装

1.2 访问限定符（private、default、protected、public）

2. 包

2.1 导入Java提供的现成的包中的类

2.2 自定义包

2.3 常见的包

3. static成员

3.1 static修饰成员变量

3.2 成员变量有无static的 赋值 对比

3.2.1 给static修饰的静态成员变量进行赋值：

3.2.2 给对象中的成员变量进行赋值：

3.2.3 成员变量既有非静态的又有静态的​​​​​​​

3.2 static修饰成员方法

4. 代码块

5. 内部类

5.1 实例内部类

5.2 静态内部类

5.3 局部内部类

6. 对象的打印

1. 封装

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

1.1 什么是封装

对类内部的实现细节进行隐藏/封装，对外只提供一些公开的接口，供其他的用户进行访问

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

1.2 访问限定符（private、default、protected、public）

可以修饰成员变量，成员方法，构造方法

---

private：私有的 ->只能在当前类的内部进行访问【同一个包中的同一个类】

default：默认的 ->只能在【同一个包中】进行访问【什么限定符都不加，就是default权限：默认权限】

protected：受保护的【同一个包中和不同包中的子类】

public：公开的 ->不管在哪里都可以访问它

一般情况下成员变量设置为private，成员方法设置为public。

---

2. 包

为了更好的管理类，把多个类收集在一起成为一组，称为包

2.1 导入Java提供的现成的包中的类

可以使用 import导入一个包中具体的类，使用import static导入包中静态的方法和字段。

用到哪个类，就导入这个包中的这个类，如用到 java.util.Date这个类就导入 java.util 这个包中的 Date 类（ java.util.Date->完整的类名、Date->不完整的类名，当没有和别的包下的类名产生冲突时，可以直接使用）

如下：先进行实例化，再通过【引用点号】来访问类中的成员

但是我们会发现，有些类中成员的访问不需要实例化，直接【类名.方法名】就可以，如下：

这是为什么呢？ 

因为java.lang.Math和java.util.Arrays这两个类中提供了大量的静态方法，所以在使用的时候，直接【类名.方法名】使用即可。

2.2 自定义包

通过类外的 package 语句确定该类在哪个包中

如果一个类外没有 package 语句, 则该类被放到一个默认包（src）中

src里的类可以实例化src里的其他类 以及 src里的包中的类，而src里的包中的类却不能实例化src里的类。【即只能实例化同等级及以下的类。】

详解private访问限定符

2.3 常见的包

1. java.lang:系统常用基础类(String、Object)，此包不需要我们导入，编译器会自己导入

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

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

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

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

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

3. static成员

1. 在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。类变量存储在方法区当中，只有一份。

2. .通过【类名.属性/方法】去访问，若处于同一个类下，类名可以省略

（ 虽然也可以通过引用来访问，语法上没错，但不要这样用）

3. 静态成员变量未初始化默认是初始值。

4. static修饰的是成员变量或成员方法，不能修饰方法中的局部变量

5. 生命周期伴随类的一生【随着类的创建而产生，随着类的销毁而销毁】

3.1 static修饰成员变量

再谈学生类，若这些学生是同一个班的，就可以定义一个静态成员变量classes

通过【类名.成员变量】进行访问

那么如何给静态成员变量进行初始化呢？

3.2 成员变量有无static的 赋值 对比

3.2.1 给static修饰的静态成员变量进行赋值：

1. 定义时就直接赋值

2. 在main函数中通过【类名.成员变量】进行赋值

3. 使用静态成员方法

4. 使用静态代码块

public class Peo {
    private static String name;
    private static int age;
    private static String sex = "男";//就地初始化
    private static String lover;

    
    public static void setPeople1(String name,int age){
        Peo.name = name;
        Peo.age = age;
    }

    

    static{
        lover = "骆闻舟";
    }
    public static void printPeople1() {
        System.out.println(Peo.name+" "+Peo.age +" "+Peo.sex+" 爱人："+Peo.lover);
    }
    public static void main(String[] args) {

        Peo.setPeople1("费渡",22);
        Peo.printPeople1();

    }
}

3.2.2 给对象中的成员变量进行赋值：

1. 定义时就直接赋值

2. 在main函数中通过【引用.成员变量】进行赋值

3. 使用成员方法

4. 使用构造方法

（有参数的构造方法、调用本类当中的其他构造方法）

public class People {
    private String name;
    private int age;
    private String sex = "男";//就地初始化
    private String lover;

    
    public void setPeople1(String name,int age,String lover){
        this.name = name;
        this.age = age;
        this.lover = lover;
    }
    public void printPeople1() {
        System.out.println(this.age+"岁的"+this.name+"救赎了他的宝贝"+this.lover);
    }

    
    public People(String name,int age,String lover){
        this.name = name;
        this.age = age;
        this.lover = lover;
    }
    public void printPeople2(){
        System.out.println(this.age+"岁的"+this.name+"爱上了只属于他的"+this.lover);
    }

    
    public People(){
        this("陶然",29,"常宁");//this();调用本类中的其他构造方法
    }
    public void printPeople3(){
        System.out.println(this.age+"岁的"+this.name+"追上了它的女神"+this.lover);
    }

    public static void main(String[] args) {
        People people1 = new People();//调用无参构造方法
        people1.setPeople1("骆闻舟",29,"费渡");//重新初始化
        People people2 = new People("费渡",22,"骆闻舟");调用有2个参数的构造方法
        People people3 = new People();//调用无参构造方法

        people1.printPeople1();
        people2.printPeople2();
        people3.printPeople3();
    }
}

3.2.3 成员变量既有非静态的又有静态的

public class Character {
    private String name;
    private String lover;
    private static String novel;

    static{
        novel = "默读";
    }
    public Character(String name,String lover){
        this.name = name;
        this.lover = lover;
    }
    public void printCharacter() {
        System.out.println(" "+Character.novel+":"+this.name+"和"+this.lover+"的相遇相知相爱，是梦开始的地方");
    }

    public static void main(String[] args) {
        Character character = new Character("费渡","骆闻舟");
        character.printCharacter();
    }
}

3.2 static修饰成员方法

通过【类名.成员方法】访问

在静态的成员方法内部，不能直接访问非静态的成员变量和成员方法。

因为func是类名调用，不需要new对象，不需要对象的引用，this在静态方法中根本就不存在

反之非静态可以访问静态。

4. 代码块

普通代码块、静态代码块、实例代码块（也叫构造块）、同步代码块。

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

2. 实例代码块，也叫作构造块，一般用于初始化非静态的成员变量。

3. 静态代码块在类加载的时候就被执行了，它不依赖于对象，且只会执行一次

4. 实例代码块和无参数的构造方法只有在创建对象时才会执行，且创建几个对象执行几次

5. 执行顺序：先静态代码块，再实例代码块，再无参数的构造方法

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

public class Stu {
    public String name;
    public int age;
    public String sex;
    public static String classes = "106Java1班";//静态成员变量

    {
        //实例代码块一般用于初始化非静态的成员变量。
        sex = "男";
        System.out.println("这是实例代码块！");
    }
    static{
        //静态代码块，一般用于初始化静态成员变量。
        classes = "106Java2班";//虽然classes已经被赋值成106Java1班，但要按顺序，最终输出106Java2班
        //类加载的时候 就被执行了，且只执行一次
        System.out.println("这是静态代码块！");
    }
    public Stu(){
        System.out.println("这是无参构造方法！");
    }

    public void setStu(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void printStu(){

        System.out.println(this.name+" "+this.age+" "+sex+" "+Stu.classes);
    }

    public static void main(String[] args) {
        Stu stu = new Stu();
        stu.setStu("zhangsan",18);
        stu.printStu();

        Stu stu2 = new Stu();
        stu2.setStu("lisi",19);
        stu2.printStu();


    }
}

5. 内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服 务，那么整个内部的完整结构最好使用内部类。内部类也是封装的一种体现。

分类：

1. 实例内部类（又叫构造内部类、非静态内部类）
2. 静态内部类
3. 局部内部类
4. 匿名内部类

5.1 实例内部类

final - 定义常量

package inner;

class OuterClass {
    public int data1 = 1;
    int data2 = 2;
    public static int data3 = 3;
    public void test(){
        System.out.println("OuterClass:test()");
        InnerClass innerClass = new InnerClass();
        innerClass.func();
    }

    
    class InnerClass{
        public int data1 = 111;
        public int data4 = 4;
        int data5 = 5;
        //public static int data6;//error
        public static final int data6 = 10;
        public void func(){
            System.out.println("InnerClass:func()");
            
            System.out.println(data1);//111(就近原则)
            System.out.println(OuterClass.this.data1);//1//非要输出外部类中的成员变量可以这样
            System.out.println(data2);//2
            System.out.println(data3);//3
            System.out.println(data4);//4
            System.out.println(data5);//5
            System.out.println(data6);//10
            test();
        }
    }
}
public class Test {
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
       
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.func();


        OuterClass.InnerClass innerClass2 = new OuterClass().new InnerClass();
    }
}

1. 实例内部类方法中可以直接访问外部类中的任何成员

2. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象

3. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束

4. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果非要访问外部类同名的成员，必须：【外部类名称.this.同名成员】来访问

5. 实例内部类对象必须在先有外部类对象前提下才能创建

5.2 静态内部类

package inner;

class OuterClass2 {
    public int data1 = 1;
    int data2 = 2;
    public static int data3 = 3;
    public void test(){
        System.out.println("OuterClass:test()");
    }

    
    static class InnerClass2{
        public int data4 = 4;
        int data5 = 5;
        public static int data6 = 6;
        public void func(){
            System.out.println("InnerClass:func()");
            OuterClass2 outerClass2 = new OuterClass2();
            System.out.println(outerClass2.data1);
            System.out.println(outerClass2.data2);
            
            System.out.println(data3);//3
            System.out.println(data4);//4
            System.out.println(data5);//5
            System.out.println(data6);//6
        }
    }
}
public class Test2 {
    OuterClass2.InnerClass2 innerClass2 = new OuterClass2.InnerClass2();
}

1.  在静态内部类中只能访问外部类中的静态成员

2.  创建静态内部类对象时，不需要先创建外部类对象

5.3 局部内部类

定义在外部类的方法体中，只能在其定义的位置使用。几乎不被使用

public class Test {

    public void func(){
        //局部内部类:
        class Inner{
            public void test(){
                System.out.println("hello");
            }
        }
        Inner inner = new Inner();
        inner.test();
        
    }
}

1. 局部内部类只能在所定义的方法体内部使用

2. 不能被public、static等修饰符修饰

6. 对象的打印

重写toString方法

public class Test {
    private String name = "zhangsan";
    private int age = 18;

    @Override
    public String toString() {
        return name + " " +age ;

    }

    public static void main(String[] args) {
        Test test = new Test();

        System.out.println(test);
    }


}