java学习之路-类和对象

前言

本文内容：

类的定义及其使用

this的引用

对象的构造及初始化

封装

static成员

代码块讲解

内部类

文章目录

 1.类定义和使用

1.1了解什么是面向对象

 1.2简单认识类

1.3定义类

1.4栗子

2.类的使用-类的实例化

2.1什么是实例化

2.2类和对象的说明

3.this引用

3.1为何要用this引用

 3.2什么是this引用

3.3this引用特性

​编辑 4.对象的构造及初始化

4.1初始化对象

4.2构造方法

4.2.1概念

4.2.2特性

4.3对象的不同初始化方式

4.3.1默认初始化

4.3.2就地初始化

5.封装

5.1封装概念

5.2访问限定符

 public

protected

 default

 private

6. static成员

6.2static修饰成员变量

6.3 static修饰成员方法 

6.4static成员变量初始化

1.就地初始化

2.静态代码块初始化

7.代码块

7.1代码块概念

7.2普通代码块

7.3构造代码块

7.4 静态代码块

8.内部类

 8.1 内部类的分类

 8.2实例内部类

8.3静态内部类

 8.4局部内部类

---

【本节目标】

1. 掌握类的定义方式以及对象的实例化

2. 掌握类中的成员变量和成员方法的使用

3. 掌握对象的整个初始化过程

4. 掌握封装特性

5. 掌握代码块

6. 掌握内部类

 1.类定义和使用

1.1了解什么是面向对象

Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，一切皆为对象。面 向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人 们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。

 1.2简单认识类

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干 啥)，描述完成后计算机就可以识别了。

比如：洗衣机，它是一个品牌，在Java中可以将其看成是一个类别。
属性：产品品牌，型号，产品重量，外观尺寸，颜色...
功能：洗衣，烘干、定时....

那java如何定义类呢

1.3定义类

具体语法如下：

// 创建类
class ClassName{  
f
 ield;       
// 字段(属性) 或者 成员变量
method;      
}

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类 具有哪些功能，称为类的成员方法。

class WashMachine{
    public String brand;   // 品牌
    public String type;    // 型号
    public double weight;  // 重量
    public double length;  // 长
    public double width;  // 宽
    public double height;  // 高
    public String color;   // 颜色
    
    public void washClothes(){   // 洗衣服
        System.out.println("洗衣功能");
    }
    
    public void dryClothes(){    // 脱水
        System.out.println("脱水功能");
    }
    
    public void setTime(){       // 定时
        System.out.println("定时功能");
    }
 }

注意，类名注意采用大驼峰定义

1.4栗子

class PetDog {
 public String name;//名字
public String color;//颜色
// 狗的属性
public void barks() {
 System.out.println(name + ": 旺旺旺~~~");
 }
 // 狗的行为
public void wag() {
 System.out.println(name + ": 摇尾巴~~~");
 }
 }

1. 一般一个文件当中只定义一个类
2. main方法所在的类一般要使用public修饰
(注意：Eclipse默认会在public修饰的类中找main方法)
 3. public修饰的类必须要和文件名相同
4. 不要轻易去修改public修饰的类的名称

2.类的使用-类的实例化

2.1什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自 带的内置类型，而类是用户自定义了一个新的类型，比如上述的：PetDog类和Student类。它们都是类(一种新定 义的类型)有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。

用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

根据上面定义好的，狗狗类，现在进行实例化类。

public class Main{
    public static void main(String[] args) {
        PetDog dogh = new PetDog();     //通过new实例化对象
        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
        dogh.wag();
        
        PetDog dogs = new PetDog();
        dogs.name = "阿黄";
        dogs.color = "黑黄";
        dogs.barks();
        dogs.wag();
    }
 }
 
输出结果：
阿黄: 旺旺旺~~~
阿黄: 摇尾巴~~~
赛虎: 旺旺旺~~~
赛虎: 摇尾巴~~~

new 关键字用于创建一个对象的实例.

使用 . （点）来访问对象中的属性和方法.

同一个类可以创建对个实例.

2.2类和对象的说明

1. 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.

2. 类是一种自定义的类型，可以用来定义变量.

3. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量

4. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东 西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空 间

3.this引用

3.1为何要用this引用

看下面栗子

public class Date {
    public int year;
    public int month;
    public int day;
 
    public void setDay(int y, int m, int d){
        year = y;
        month = m;
        day = d;
    }
 
    public void printDate(){
        System.out.println(year + "/" + month + "/" + day);
    }
 
    public static void main(String[] args) {
        // 构造三个日期类型的对象 d1 d2 d3
        Date d1 = new Date();
        Date d2 = new Date();
        Date d3 = new Date();
 
        // 对d1，d2，d3的日期设置
        d1.setDay(2020,9,15);
        d2.setDay(2020,9,16);
        d3.setDay(2020,9,17);
         // 打印日期中的内容
        d1.printDate();
         d2.printDate();
         d3.printDate();
         }
        }
        

以上代码定义了一个日期类，然后main方法中创建了三个对象，并通过Date类中的成员方法对对象进行设置和打 印，代码整体逻辑非常简单，没有任何问题。

但是细思之下有以下两个疑问：

1. 形参名不小心与成员变量名相同：

public void setDay(int year, int month, int day){
 year = year;
 month = month;
 day = day;
 }

那函数体中到底是谁给谁赋值？成员变量给成员变量？参数给参数？参数给成员变量？成员变量参数？估计 自己都搞不清楚了。

2. 三个对象都在调用setDate和printDate函数，但是这两个函数中没有任何有关对象的说明，setDate和 printDate函数如何知道打印的是那个对象的数据呢？

 3.2什么是this引用

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该 引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

public class Date {
 public int year;
 public int month;
 public int day;
 public void setDay(int year, int month, int day){
 this.year = year;
 this.month = month;
 this.day = day;
 }
 }
 public void printDate(){
 System.out.println(this.year + "/" + this.month + "/" + this.day);
 }

this是当参数跟变量同名的时候使用。

3.3this引用特性

1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
2. this只能在"成员方法"中使用
3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象
4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法
对象的引用传递给该成员方法，this负责来接收

在代码层面来简单演示--->注意：下图右侧中的Date类也是可以通过编译的

 4.对象的构造及初始化

4.1初始化对象

在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败。

public static void main(String[] args) {
 Date d = new Date();
 d.printDate();
 d.setDate(2021,6,9);
 d.printDate();
 }

4.2构造方法

4.2.1概念

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且 在整个对象的生命周期内只调用一次。

public class Date {
    public int year;
    public int month;
    public int day;
 
    // 构造方法：
    // 名字与类名相同，没有返回值类型，设置为void也不行
    // 一般情况下使用public修饰
    // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
    public Date(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("Date(int,int,int)方法被调用了");
    }
 
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
 
    public static void main(String[] args) {
        // 此处创建了一个Date类型的对象，并没有显式调用构造方法
        Date d = new Date(2021,6,9);   // 输出Date(int,int,int)方法被调用了
        d.printDate();    // 2021-6-9
    }
 }

构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

4.2.2特性

1. 名字必须与类名相同
2. 没有返回值类型，设置为void也不行
3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
 4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

 public class Date {
    public int year;
    public int month;
    public int day;
    
    // 无参构造方法
    public Date(){
        this.year = 1900;
        this.month = 1;
        this.day = 1;
    }
    // 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
 
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
 
    public static void main(String[] args) {
        Date d = new Date();
        d.printDate();
    }
 }

上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载。

如果用户没有显示定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。

注意：一旦用户定义，编译器则不再生成。

还可以通过this来调用其他构造方法

 public class Date {
    public int year;
    public int month;
    public int day;
    
    // 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
    // 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
    // 但是this(1900,1,1);必须是构造方法中第一条语句
    public Date(){
        //System.out.println(year);   注释取消掉，编译会失败
        this(1900, 1, 1);
        
        //this.year = 1900;
        //this.month = 1;
        //this.day = 1;
    }
 
    // 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
 }

this(...)必须是构造方法中第一条语句

4.3对象的不同初始化方式

4.3.1默认初始化

 
public Date(){
   this(1900,1,1);
 }
 
public Date(int year, int month, int day) {
   this();
 }
 
/*
无参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用
编译报错：Error:(19, 12) java: 递归构造器调用
*/
 public class Date {
    public int year;
    public int month;
    public int day;
 
    public Date(int year, int month, int day) {
        // 成员变量在定义时，并没有给初始值, 为什么就可以使用呢？
        System.out.println(this.year);
        System.out.println(this.month);
        System.out.println(this.day);
    }
    
    public static void main(String[] args) {
        // 此处a没有初始化，编译时报错：
        // Error:(24, 28) java: 可能尚未初始化变量a
        // int a;
        // System.out.println(a);
        Date d = new Date(2021,6,9);
    }
 }

为什么局部变量在使用时必须要初始化，而成员变量可以不用呢？那就来谈谈

初始化所分配的空间

对象空间被申请好之后，对象中包含的成员已经设置好了初始值

4.3.2就地初始化

即：在声明成员变量时，就直接给出了初始值。

public class Date {
 public int year = 1900;
 public int month = 1;
 public int day = 1;
 public Date(){
 }
 public Date(int year, int month, int day) {
 }
 public static void main(String[] args) {
 Date d1 = new Date(2021,6,9);
 Date d2 = new Date();
 }
 }

代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中

5.封装

5.1封装概念

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

比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器，USB插孔等，让用 户来和计算机进行交互，完成日常事务。但实际上：电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互

5.2访问限定符

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

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

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

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

protected  是一种比较特殊的访问权限修饰符，它表示受保护的意思。被protected修饰的类、方法、变量或者接口只能被相同包或其子类中的类或对象所访问。

 public

public是Java中最常用的访问权限修饰符，它表示公共的意思，被public修饰的类、接口、方法和变量等成员都可以被任何其他类或对象所访问。

具体来说，如果一个类被声明为public，则这个类可以被从任何地方访问，无论是在同一个包内还是在不同的包内。同样地，如果一个方法、变量或者接口被声明为public，则它们也可以被其他类或对象从任何地方访问。

public int myVar;  
public void myMethod() {  //这里就表示此方法是公开的，都可以调用。
    
}

protected

 protected是一种比较特殊的访问权限修饰符，它表示受保护的意思。被protected修饰的类、方法、变量或者接口只能被相同包或其子类中的类或对象所访问。

protected成员只能在定义它的类的子类中被访问，而不能在同一个包中的其他类或对象中被访问。需要注意的是，即使在子类中访问protected成员时不需要使用类名来限定，但在同一个包中的其他类或对象中访问时，仍需要使用类名来限定。

总结，如果要使用protected来修饰成员，那么要实现不同包子类引用的话，要满足一下条件：该类是要引用到类的子类，属于继承关系，然后要用super来引用，并且不能在静态里面使用，比如main函数理由static是不能引用的，只能在main外面引用。

看栗子

//注意这里是在不同的包里面的类

public class AX {
    protected int x=1999 ;
    public int b ;
    public AX(int x) {
        this.x = x;
    }
    
}


//protected可以实现不同包不同子类引用，就是要继承才行
//满足两个条件，必须是继承，然后是子类，加上要用super才能引用
public class Kun extends AX {
    public void fun(){
        
        System.out.println(x);
    }
    public static void main(String[] args) {
        
        Kun kk = new Kun();
        kk.fun();

        
        
    }
}

 default

default是Java中的默认访问权限修饰符，它表示不指定任何访问权限修饰符时所使用的访问权限。如果一个类、方法、变量或接口没有使用任何访问权限修饰符，则这些成员默认为包级别访问权限，也就是说，只能在同一个包内被访问。

就是默认的，不用去写。

interface Person {
    default void show() {
        System.out.println("this is show");
    }
}

 private

private是一种最严格的访问权限修饰符，它表示私有的意思，只有在定义该成员的类内部才能被访问。被private修饰的类、方法、变量或接口只能在自己的类中被调用，无法被同一个包内或者其他包中的其他类或对象所访问。

就是只能在一个类里面使用，私有的。

class Demo {
    //用private修饰成员变量
    private int num = 10;
    
    public void show() {
        System.out.println(num);
    }
    
    private void method() {
        System.out.println("method");
    }
    
    public void fucntion() {
        method();
    }
}

测试

class privateDemo {
    public static void main(String[] args) {
        Demo d = new Demo();
        //不能访问私有的成员变量
        //System.out.println(d.num);
        d.show();
        //不能访问私有的成员方法
        //d.method();
        d.fucntion();
    }
}

6. static成员

使用前文中介绍的学生类实例化三个对象s1、s2、s3，每个对象都有自己特有的名字、性别，年龄，学分绩点等成 员信息，这些信息就是对不同学生来进行描述的，如下所示：

public class Student{
 // ...
 public static void main(String[] args) {
 Student s1 = new Student("Li leilei", "男", 18, 3.8);
 Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
 Student s3 = new Student("Jim", "男", 18, 2.6);
 }
 }

假设三个同学是同一个班的，那么他们上课肯定是在同一个教室，那既然在同一个教室，那能否给类中再加一个成 员变量，来保存同学上课时的教室呢？答案是不行的。

之前在Student类中定义的成员变量，每个对象中都会包含一份(称之为实例变量)，因为需要使用这些信息来描述 具体的学生。而现在要表示学生上课的教室，这个教室的属性并不需要每个学生对象中都存储一份，而是需要让所 有的学生来共享。在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对 象，是所有对象所共享的。

6.2static修饰成员变量

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

【静态成员变量特性】

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

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

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

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

public class Student{
    public String name;
    public String gender;
    public int  age;
    public double score;
    public static String classRoom = "Bit306";
    
    // ...
    
    public static void main(String[] args) {
        // 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
 
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
 
        // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
  }
 }

6.3 static修饰成员方法 

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

public class Student{
    // ...
    
    private static String classRoom = "Bit306";
    
    // ...
    
    public static String getClassRoom(){
        return classRoom;
    }
 }
 
public class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student.getClassRoom());
    }
 }

【静态方法特性】
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()

5. 静态方法无法重写，不能用来实现多态。

6.4static成员变量初始化

静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化。

1.就地初始化

就地初始化指的是：在定义时直接给出初始值

public class Student{
    private String name;
    private String gender;
    private int  age;
    private double score;
    private static String classRoom = "Bit306";  
    
    // ...
 }

2.静态代码块初始化

知识点在下面，看下面回头看这个就看懂了

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

 // 静态代码块
static {
 classRoom = "bit306";
 
 }

7.代码块

7.1代码块概念

使用{}定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块
构造块
静态块
同步代码块（后续会讲解到）

7.2普通代码块

普通代码块就是定义在方法中的代码块

 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);
    }
 }

7.3构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

public class Student{
    //实例成员变量
    private String name;
    private String gender;
    private  int age;
    private double score;
    
    public Student() {
        System.out.println("I am Student init()!");
    }
    
    //实例代码块
    {
        this.name = "bit";
        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 Main {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.show();
    }
 }

7.4 静态代码块

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

 // 静态代码块
static {
 classRoom = "bit306";
 System.out.println("I am static init()!");
 }

 总结

静态代码块不管生成多少个对象，其只会执行一次
静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
实例代码块只有在创建对象时才会执行

8.内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服 务，那么这个内部的完整结构最好使用内部类。在 Java 中，可以将一个类定义在另一个类或者一个方法的内部， 前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

public class OutClass {
 class InnerClass{
 }
 }
 // OutClass是外部类
// InnerClass是内部类

1. 定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类

2. 内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

 8.1 内部类的分类

根据内部类定义的位置不同，一般可以分为以下几种形式：

1. 成员内部类(普通内部类：未被static修饰的成员内部类 和 静态内部类：被static修饰的成员内部类)

2. 局部内部类(不谈修饰符)、匿名内部类

内部类都可以在一个类的那些位置进行定义

public class OutClass {
    // 成员位置定义：未被static修饰 --->实例内部类
    public class InnerClass1{
    }
 
    // 成员位置定义：被static修饰 ---> 静态内部类
    static class InnerClass2{
 
    }
 
 
    public void method(){
        // 方法中也可以定义内部类 ---> 局部内部类：几乎不用
        class InnerClass5{
 
        }
    }
 }

 8.2实例内部类

在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类。

即未被static修饰的成员内部类。

public class OutClass {
    private int a;
    static int b;
    int c;
    public void methodA(){
        a = 10;
        System.out.println(a);
    }
 
    public static void methodB(){
        System.out.println(b);
    }
 
    //  实例内部类：未被static修饰
    class InnerClass{
        int c;
        public void methodInner(){
            // 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
            a = 100;
            b =200;
            methodA();
            methodB();
 
            // 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
            c = 300;
            System.out.println(c);
 
            // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
            OutClass.this.c = 400;
            System.out.println(OutClass.this.c);
        }
    }
 
    public static void main(String[] args) {
        // 外部类：对象创建 以及 成员访问
        OutClass outClass = new OutClass();
        System.out.println(outClass.a);
        System.out.println(OutClass.b);
        System.out.println(outClass.c);
        outClass.methodA();
        outClass.methodB();
 
        System.out.println("=============实例内部类的访问=============");
        // 要访问实例内部类中成员，必须要创建实例内部类的对象
        // 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
 
        // 创建实例内部类对象
        OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
 
        // 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
        OutClass.InnerClass innerClass2 = outClass.new InnerClass();
        innerClass2.methodInner();
    }


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

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

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

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

5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用

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

8.3静态内部类

被static修饰的内部成员类称为静态内部类。

}
 public class OutClass {
    private int a;
    static int b;
    public void methodA(){
        a = 10;
        System.out.println(a);
    }
 
    public static void methodB(){
        System.out.println(b);
    }
 
    // 静态内部类：被static修饰的成员内部类
    static class InnerClass{
        public void methodInner(){
            // 在内部类中只能访问外部类的静态成员
            // a = 100;      // 编译失败，因为a不是类成员变量
            b =200;
            // methodA();    // 编译失败，因为methodB()不是类成员方法
            methodB();
        }
    }
 
    public static void main(String[] args) {
        // 静态内部类对象创建 & 成员访问
        OutClass.InnerClass innerClass = new OutClass.InnerClass();
        innerClass.methodInner();
    }
 }

1. 在静态内部类中只能访问外部类中的静态成员
如果确实想访问，我们该如何做？
2. 创建静态内部类对象时，不需要先创建外部类对象

 8.4局部内部类

定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用

public class OutClass {
    int a = 10;
    public void method(){
        int b = 10;
 
        // 局部内部类：定义在方法体内部
        // 不能被public、static等访问限定符修饰
        class InnerClass{
            public void methodInnerClass(){
                System.out.println(a);
                System.out.println(b);
            }
        }
 
        // 只能在该方法体内部使用，其他位置都不能用
        InnerClass innerClass = new InnerClass();
        innerClass.methodInnerClass();
    }
 
    public static void main(String[] args) {
        // OutClass.InnerClass innerClass = null; 编译失败
    }
 }

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

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

3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class

4. 几乎不会使用

8.5匿名内部类

interface Jko{
    void test();
}
public class NeiBu {
    public static void main(String[] args) {
 //匿名内部类的使用
       Jko jk = new Jko(){
            @Override
            public void test() {
                System.out.println("重写接口方法");
            }
        };
       jk.test();


        new Jko(){
            @Override
            public void test() {
                System.out.println("重写接口方法");
            }
        }.test();



    }