JavaSE 类与对象

已于 2022-10-22 17:00:50 修改
阅读量189 收藏 3
点赞数 6
分类专栏： JavaSE 文章标签： java
于 2022-10-22 17:00:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59954106/article/details/127272812
版权

目录

1、面向对象的初步认知

1.1 什么是面向对象

1.2 面向对象与面向过程

 2、类定义和使用

2.1 简单认识类

2.2 类的定义格式

3、类的实例化

3.1 什么是实例化

3.2 类和对象的说明 

 4.this引用

 4.1 为什么要有this引用

4.2 什么是this引用

4.3 this引用的特性

5、对象的构造及初始化

5.1 如何初始化对象

5.2 构造方法

5.2.1 概念

5.2.2 特性 

5.3 默认初始化

5.4 就地初始化

6、封装（降低代码的耦合度）

6.1 封装的概念

6.2 访问限定符

6.3 封装扩展之包

6.3.1 包的概念

6.3.2 导入包中的类

6.3.3 常见的包

7、static成员

7.1 再谈学生类

 7.2 static修饰成员变量

8、代码块

8.1 代码块概念以及分类

8.2 普通代码块

8.3 实例(构造)代码块

8.4 静态代码块 

9、内部类

9.1 内部类的分类

9.1.1 实例内部类（成员内部类）

9.1.2 静态内部类

9.2 局部内部类（基本不用）

9.3 匿名内部类

10、对象的打印

【本节目标】

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

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

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

4、掌握封装特性

5、掌握代码块

6、掌握内部类

【正文】

1、面向对象的初步认知

1.1 什么是面向对象

面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。

1.2 面向对象与面向过程

举个例子：洗衣服

以前的方式：

 注重的是洗衣服的过程，少了一个环节都不行。按照这种方式写代码，不好维护。

现在的方式：

以面向对象方式来进行处理，就不关注洗衣服的过程，具体操作是通过对象之间的交互来完成的。

 2、类定义和使用

对对象（实体）进行抽象（对一个复杂事物的重新认知）

2.1 简单认识类

类是用来对一个实体（对象）来进行描述的

2.2 类的定义格式

在java中定义类时需要用到class关键字：

//创建类
class ClassName{
  field;   //成员变量
  method;    //成员方法
}

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。类中一般包含成员变量（字段或者属性）和成员方法（行为）

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

采用java语言将洗衣机类在计算机中定义完成，经过javac编译之后形成.class文件，在JVM的基础上计算机就可以识别了。

【注】：

  1. 类名注意采用大驼峰定义
  2. 成员前写法统一为public，后面会详细解释
  3. 此处写的方法不带static关键字

3、类的实例化

3.1 什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型 ，与 int ， double 类似，只不过 int 和 double 是 java 语言自带的内置类型，而类是用户自定义了一个新的类型，比如上述的：PetDog 类和 Student 类。它们都是类 ( 一种新定义的类型) 有了这些自定义的类型之后，就可以使用这些类来定义实例 ( 或者称为对象 ) 。 用类类型创建对象的过程，称为类的实例化 ，在 java 中 采用new关键字 ，配合类名来实例化对象。 
public static void main(String[] args){
    //类名 变量 = new 类名()    实例化对象，创建一个对象
    Student student = new Student();
    public String name;
    public int age;
    public double score;
    public String sex;
}

当成员变量没有赋初值的时候，每个成员变量都是他所对应的0值。

引用类型对应的是null，boolean对应的是false，char对应的是'\u0000'（代表空格）。

【问题】什么是实例化对象？

  答：通过new关键字实例化一个对象。只要new就会给这个对象分配一块内存。

【总结1】

  •  如何定义一个类？
  • class Person{
  •       public String name;
  • }
  • 如何通过这个类来实例化对象？
  • Person person1 = new Person();
  • Person person2 = new Person();
  • 怎么去访问实例化出来的对象的方法和属性？
  •  通过对象的引用：person1.属性 或者 person1.方法

【注】

  • new关键字用于创建一个对象的实例
  • 使用 . 来访问对象中的属性和方法
  • 同一个类可以创建多个实例 

3.2 类和对象的说明 

1. 类只是 一个 模型 一样的东西，用来对一个实体进行描述，限定了类有哪些成员 .
2. 类是一种自定义的类型 ，可以用来定义变量，但是 在 java 中用类定义出来的变量我们成为对象 .
3. 一个类可以实例化出多个对象， 实例化出的对象 占用实际的物理空间，存储类成员变量
4. 做个比方。 类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图 ，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

 4.this引用

 4.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 函数如何知道打印的是那个对象的数据呢 ？
由此来引出this引用。

4.2 什么是this引用

java 编译器给每个 “ 成员方法 “ 增加了一个隐藏的引用类型参数，该引用参数指向当前对象 ( 成员方法运行时调用该 成员方法的对象 ) ，在成员方法中所有成员变量的操作，都是通过该引用去访问 。 
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引用的是调用成员方法的对象。

 【总结2】this

  1. 代表当前对象的引用
  2. 可以区别，当参数和成员名字冲突的时候
  3. this本质来说，可以看作一个隐式的参数。

this共有三种应用场景：

1.this.data;//访问成员变量

2.this.func();//访问成员方法

3.this();//调用构造方法

4.3 this引用的特性

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

5、对象的构造及初始化

5.1 如何初始化对象

通过前面知识点的学习知道，在 Java 方法内部定义一个局部变量时，必须要初始化 ，否则会编译失败。 
public static void main(String[] args) {
   int a;
   System.out.println(a);
}
// Error:(26, 28) java: 可能尚未初始化变量a
要让上述代码通过编译，非常简单，只需在正式使用 a 之前，给 a 设置一个初始值即可。如果是对象： 
public static void main(String[] args) {
   Date d = new Date();
   d.printDate();
   d.setDate(2021,6,9);
   d.printDate();
}
// 代码可以正常通过编译

5.2 构造方法

5.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
  }
}

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

5.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();
  }
}
上述两个构造方法：名字相同，参数列表不同，因此构成了 方法重载。
[方法重载]：1.方法名相同 2.参数列表不同 3.和返回值没关系
5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。 
public class Date {
  public int year;
  public int month;
  public int day;

  /*
  Date date(){
     
  }
  */  // 默认提供的

  public void printDate(){
    System.out.println(year + "-" + month + "-" + day);
  }

  public static void main(String[] args) {
    Date d = new Date();
    d.printDate();
  }
}
6. 构造方法中，可以通过 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;
  }
}

【注】：1.this 必须是构造方法中第一段语句

              2.不能形成环

public Date(){
  this(1900,1,1);
}

public Date(int year, int month, int day) {
  this();
}

/*
无参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用
编译报错：Error:(19, 12) java: 递归构造器调用
*/

【总结3】

  1. 构造方法 是没有返回值的方法，方法名和类名是一样的
  2. 构造方法不止一个，可以有多个，多个构造方法之间构成了重载
  3. 当我们写了一个类之后，没有写构造方法的时候，编译器会帮我们默认生成一个不带参数的构造方法、
  4. 当我们写了任何一个构造方法之后，编译器就不再为我们提供不带参数的构造方法
  5. 一个类至少会有1个构造方法就算你没有写！！！
  6. 构造方法本质就是实例化对象的时候。(1)分配内存 (2)调用合适的构造方法
  7. this可以用来调用本类中的其他的构造方法（构造方法当中使用）。必须放在第一行！！！所以，只能在当前构造方法当中，调用一个
  8. this的用法：(1)this.data;  //访问属性   (2)this.func();  // 访问方法  (3)this(); //调用本类中其他的构造方法
  9. this不能形成环。

5.3 默认初始化

在上文中提出的第二个问题：为什么局部变量在使用时必须要初始化，而成员变量可以不用呢？ 
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);
  }
}
要搞清楚这个过程，就需要知道 new 关键字背后所发生的一些事情： 
Date d = new Date(2021,6,9);
在程序层面只是简单的一条语句，在 JVM 层面需要做好多事情，下面简单介绍下：
    1. 检测对象对应的类是否加载了，如果没有加载则加载
    2. 为对象分配内存空间
    3. 处理并发安全问题，比如：多个线程同时申请对象，JVM 要保证给对象分配的空间不冲突
    4. 初始化所分配的空间
    即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值，比如：
数据类型默认值
byte0
char'\u0000'
short0
int0
long0L
booleanfalse
float0.0f
double0.0
referencenull 
    5. 设置对象头信息 ( 关于对象内存模型后面会介绍 )
    6. 调用构造方法 <> ，给对象中各个成员赋值

5.4 就地初始化

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

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();
  }
}
注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中

 右击鼠标选择“Generate”-->>"toString()",就可以构造方法，而且还可以在main函数中调用并打印出来。此时打印出来的是值，而不是地址，正常来说应该打印地址（名称@哈希值地址），这里是因为toString原码里面重写了该方法，所以打印出值。

6、封装（降低代码的耦合度）

6.1 封装的概念

面向对象程序三大特性：封装、继承、多态 。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节 。 对类的实现的细节进行隐藏，对外只提供公开的方法来供你实体。

6.2 访问限定符

Java 中主要通过类和访问权限来实现封装： 类可以将数据以及封装数据的方法结合在一起 ，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用 。Java中提供了四种访问限定符： 
public class Computer {
  private String cpu; // cpu
  private String memory; // 内存
  public String screen; // 屏幕
  String brand; // 品牌---->default属性

  public Computer(String brand, String cpu, String memory, String screen) {
    this.brand = brand;
    this.cpu = cpu;
    this.memory = memory;
    this.screen = screen;
  }

  public void Boot(){
    System.out.println("开机~~~");
  }

  public void PowerOff(){
    System.out.println("关机~~~");
  }

  public void SurfInternet(){
    System.out.println("上网~~~");
  }
}
public class TestComputer {
  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类中访问，不能被其他类访问
  }
}

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

6.3 封装扩展之包

6.3.1 包的概念

为了更好的管理类，把多个类收集在一起成为一组，称为软件包。包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式。 在同一个工程中允许存在相同名称的类， 只要处在不同的包中即可。

6.3.2 导入包中的类

我们可以 使用import语句导入包： 
import java.util.Date;
public class Test {
  public static void main(String[] args) {
    Date date = new Date();
    // 得到一个毫秒级别的时间戳
    System.out.println(date.getTime());
  }
}
如果需要使用 java.util 中的其他类 , 可以使用 import java.util.* 
import java.util.*;
public class Test {
  public static void main(String[] args) {
    Date date = new Date();
    // 得到一个毫秒级别的时间戳
    System.out.println(date.getTime());
  }
}
但是我们 更建议显式的指定要导入的类名 . 否则还是容易出现冲突 的情况： 
import java.util.*;
import java.sql.*;
public class Test {
  public static void main(String[] args) {
    // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
    Date date = new Date();
    System.out.println(date.getTime());
  }
}

// 编译出错
Error:(5, 9) java: 对Date的引用不明确
java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

【注】import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要. import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using

6.3.3 常见的包

1. java.lang: 系统常用基础类 (String 、 Object), 此包从 JDK1.1 后自动导入。
2. java.lang.reflflect:java 反射编程包 ;
3. java.net: 进行网络编程开发包。
4. java.sql: 进行数据库开发的支持包。
5. java.util: 是 java 提供的工具程序包。 ( 集合类等 ) 非常重要
6. java.io:I/O 编程开发包。

7、static成员

7.1 再谈学生类

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

 7.2 static修饰成员变量

static 修饰的成员变量，称为静态成员变量 ，静态成员变量最大的特性： 不属于某个具体的对象，是所有对象所共 享的 。
【静态成员变量特性】
1. 不属于某个具体的对象， 是类的属性，所有对象共享的 ，不存储在某个对象的空间中
2. 既可以通过对象访问，也可以通过类名访问，但一般 更推荐使用类名访问
3. JDK7 及以前， HotSpot(Java 虚拟机 ) 中存储在方法区， JDK8 及之后，类变量存储在 Java 堆中
4. 类变量存储在方法区当中
5. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)
6.对于第3点，其实方法区和堆属于同一个等级的东西，只不过在JVM当中的实现这个东西的时候，把他放到了堆里。 
public class Student{
  public String name;
  public String gender;
  public int age;
  public double score;
  public static String classRoom = "666";

  // ...

  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);
   }
}
public static void main(String[] args){
  Student student1 = null;  //student1不指向任何对象

  student1.classes = "666";   //这个又属于哪个对象呢？
  
  System.out.println(student.classes);   //可以访问，但是不建议，规规矩矩用类名区访问

}

【注】：

  1. 静态的成员变量和静态的成员方法，都不依赖于对象。因为他们是类变量。
  2. 普通的成员方法当中，是可以使用静态的成员变量的。
  3. 静态的成员方法当中，不能访问非静态成员。非静态成员是依赖于对象的。
【静态成员变量特性】
1. 不属于某个具体的对象，是类方法
2. 可以通过对象调用，也可以通过类名 . 静态方法名 (...) 方式调用，更推荐使用后者
3. 静态方法没有隐藏的 this 引用参数，因此不能在静态方法中访问任何非静态成员变量
4. 静态方法中不能调用任何非静态方法，因为非静态方法有 this 参数，在静态方法中调用时候无法传递 this 引用 
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

public static String getClassRoom(){
  doClass();
  return classRoom;
}

// 编译报错：Error:(35, 9) java: 无法从静态上下文中引用非静态 方法 doClass()

8、代码块

8.1 代码块概念以及分类

使用 {} 定义的一段代码称为代码块 。根据代码块定义的位置以及关键字，又可分为以下四种：
  • 实例代码块/构造代码块
  • 静态代码块
  • 本地代码块/普通代码块
  • 同步代码块（多线程）

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

// 执行结果
x1 = 10
x2 = 100

8.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) {
    Person p1 = new Person();
    p1.show();
  }
}

// 运行结果
I am instance init()!
I am Person init()!
name: bit age: 12 sex: man

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

8.4 静态代码块 

使用 static 定义的代码块称为静态代码块。 一般用于初始化静态成员变量。 
public class Student{
  private String name;
  private String gender;
  private int age;
  private double score;
  private static String classRoom;

  //实例代码块
  {
    this.name = "ft";
    this.age = 12;
    this.gender = "man";
    System.out.println("I am instance init()!");
  }

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

  public Student(){
    System.out.println("I am Student init()!");
  }

  public static void main(String[] args) {
    Student s1 = new Student();
    Student s2 = new Student();
  }
}

【注】

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

静态代码块优先于实例代码块优先于构造方法执行

9、内部类

在 Java 中， 可以将一个类定义在另一个类或者一个方法的内部， 前者称为内部类，后者称为外部类 。内部类也是封装的一种体现。 
public class OutClass {
  class InnerClass{

  }
}

// OutClass是外部类
// InnerClass是内部类

【注】

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

}
class B{

}

// A 和 B是两个独立的类，彼此之前没有关系
2. 内部类和外部类共用同一个 java 源文件，但是经过编译之后，内部类会形成单独的字节码文件

9.1 内部类的分类

public class OutClass { 
  // 成员位置定义：未被static修饰 ---> 普通内部类
  public class InnerClass1{

  }

  // 成员位置定义：被static修饰 ---> 静态内部类
  static class InnerClass2{

  }

  public void method(){
  // 方法中也可以定义内部类 ---> 局部内部类：几乎不用
    class InnerClass5{

    }
  }
}
1. 成员内部类 ( 普通内部类：未 static 修饰的成员内部类 和 静态内部类：被 static 修饰的成员内部类 )
2. 局部内部类 ( 不谈修饰符 ) 、匿名内部类

9.1.1 实例内部类（成员内部类）

无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. 外部类中，不能直接访问内部类中的成员，如果要访问必须先要创建外部类的对象。

9.1.2 静态内部类

有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(); // 编译失败，因为methodA()不是类成员方法
      methodB();
    }
  }

  public static void main(String[] args) {
    // 静态内部类对象创建 & 成员访问
    OutClass.InnerClass innerClass = new OutClass.InnerClass();
    innerClass.methodInner();
  }
}

【注】

1. 在内部类中只能访问外部类中的静态成员
2. 创建内部类对象时，不需要先创建外部类对象
3. 成员内部类，经过编译之后会生成独立的字节码文件，命名格式为：外部类名称 $ 内部类名称

9.2 局部内部类（基本不用）

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; 编译失败
  }
}

9.3 匿名内部类

在接口处介绍

10、对象的打印

public class Person {
  String name;
  String gender;
  int age;

  public Person(String name, String gender, int age) {
    this.name = name;
    this.gender = gender;
    this.age = age;
  }

  public static void main(String[] args) {
    Person person = new Person("Jim","男", 18);
    System.out.println(person);
  }
}

// 打印结果：day20210829.Person@1b6d3586

要想打印对象内容只需重写toString方法

public class Person {
  String name;
  String gender;
  int age;

  public Person(String name, String gender, int age) {
    this.name = name;
    this.gender = gender;
    this.age = age;
  }

  @Override
  public String toString() {
    return "[" + name + "," + gender + "," + age + "]";
  }

  public static void main(String[] args) {
    Person person = new Person("Jim","男", 18);
    System.out.println(person);
  }
}

// 输出结果：[Jim,男,18]

「已注销」
关注
  • 6
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
JavaSE---面向对象
qq_44125413的博客
01-22 572
面向过程和面向对象 面向过程：procedure oriented programming 缩写 POP 分析出解决问题所需要的步骤，然后把步骤一步一步实现。 面向过程直接关注流程。 面向对象：object oriented programming 缩写 OOP 面向对象的编程语言以分类的方式进行思考和解决问题。 面向对象先对整体关系作出分类，然后根据不同的类深入细节的处理。 面向对象的思想符合人类的认知习惯。 JAVA类 什么是类？ 类是一个模板，它是描述一类事物(具体的对象，具体的存在)的属性和行为
JAVA类和对象
阿辉爱睡觉的博客
02-23 469
面向对象 面向对象是一种思想 类的定义和使用 将实体抽象为类 定义格式 使用class关键字 //创建类 class ClassName{ field; //字段（属性） 或者 成员变量 method; //行为 或者 成员方法 } class:类的关键字 ClassName：类名 { }：类主体 class washMachine{ //属性 public String brand; //品牌 pu
Java编程思想学习笔记二（1）：static关键字的四种用法
CHENXY
03-13 533
    前文中说到了static关键字，在Java中这是一个很重要的关键字，它有很多的用法，并且在某些特定的情况下使用可以优化程序的性能。本文学习static关键字的应用场景。在这之前了解变量的类型，变量按作用域分为成员变量和局部变量，成员变量也就是全局变量，它是在类中声明的，不属于类中任何一个方法。而局部变量是在类中的方法体中声明的，作用域只是这个方法体。接下来说一下static的作用。一、修饰...
Java期末考试试题及参考答案(03)
谷哥的小弟
12-11 5505
封装就是隐藏对象的属性和实现细节仅对外提供公有的方法。
Java基础--类
Super菜的专栏
10-06 277
类 package test.java15; /** * 类描述客观世界里某"一类"对象的事物特性（属性和行为）(某一个类事物的集合和抽象),而对象则是类的具体存在。 * 类也模板 * 类-一般来说：构造函数，属性，方法（行为）和代码块。 */ /** * 成员包括：属性和方法 * 类的结构： * 访问修饰符 类名{ * * //构造函数 * 访问修饰符 类
java基础语法练习（第三章）
DecorateCC的博客
04-05 4625
java基础语法练习一级目录二级目录三级目录 一级目录 二级目录 三级目录
西安云工厂xaygc.com_JavaSE_04类与对象_旺旺老师
09-22
学习java,讲的很不错
Java面向对象和工具类
06-26
Java面向对象和工具类 Java面向对象是Java编程语言的基础，它提供了一种强大的编程模型，能够帮助开发者创建更加灵活、可维护、可扩展的软件系统。Java面向对象的核心概念包括类、对象、继承、多态、封装、抽象等。...
JavaSE进阶 面向对象多态
11-12
JavaSE 进阶 面向对象多态 在 JavaSE 中，面向对象多态是指同一个对象可以具有多种形态，例如一个人可以是老师、丈夫、父亲等。这种多态性是通过方法的重写和重载来实现的。 多态的形式有很多，例如： 1. 方法...
JavaSE进阶 面向对象继承
11-12
JavaSE进阶面向对象继承 继承是Java语言中的一种机制，允许一个类继承另一个类的特征和行为。继承的优点是可以提高代码的可重用性，减少代码冗余，提高开发效率。 1. 继承的定义：继承是指一个类继承另一个类的...
5-JavaSE之面向对象编程-类与对象（上）1
08-03
在这个主题中，我们将探讨类与对象的概念，以及与它们相关的其他关键概念。 1. **类与对象**： 类是面向对象编程的基础，它是描述一组具有相同属性和行为的对象的模板或蓝图。在Java中，类定义了数据成员（属性或...
Java（静态加载过程）
Hello 我的
04-01 882
package statics; public class Test { private static Test test = new Test(); public static int count1; public static int count2 = 0; private Test(){ count1++; count2++; }
JVM实探-class文件格式实战（3）
08-21 570
实战演练 先创建一个简单类 package com.weyne.demo.jvm; public class Test { private static String a = "test-a"; public static void main(String[] args) { System.out.println("Hello world"); } } 通过jclasslib可以看到结构体信息 通过Sublime等16进制文件编辑器查看Test.clas
Java--static--用法/使用位置/实例
热门推荐
IT利刃出鞘的博客
10-25 1万+
本文用示例介绍Java中的static的用法。
Java类和对象（二）
m0_65683419的博客
11-14 624
面对对象程序三大特性：封装、继承、多态。🌹基本规则：1.在文件的最上方加上一个package语句指定该代码在哪个包中2.包名需要尽量指定成唯一的名字，通常会用公司的域名的颠倒形式3.包名要和代码路径相匹配，例如创建com.baidu.www的包，那么会存在一个对象的路径com/baidu/www来存储代码4.如果一个类没有package语句，则该类被放在一个默认包中src相当于是java中默认的包。🍓🍓操作步骤。
java编程综合题
m0_63292358的博客
06-16 560
收藏复习题
Java 学生管理系统（黑马程序员）
weixin_62609162的博客
04-23 691
StudentSystem
Lombok的hashCode方法
最新发布
LiZhen314的博客
06-27 437
在继承关系中，父类的hashCode针对父类的所有属性进行运算，而子类的hashCode却只是针对子类才有的属性进行运算，立此贴提醒自己。callSuper = false，根据子类自身的字段值 来生成hashcode， 当两个子类对象比较时，只有子类对象的本身的字段值相同，父类字段值可以不同，callSuper = true，根据子类自身的字段值和从父类继承的字段值 来生成hashcode，当两个子。比较时，只有子类对象的本身的字段值和继承父类的字段值都相同，equals方法的返回值是true。
JavaSE知识点总结(个人整理).docx
02-28
类与类、类与接口、接口与接口之间可以建立关系，如继承、实现等，`final`关键字可以防止这些关系的改变。 多态虽有好处，如提高代码可维护性和扩展性，但也存在弊端，即父类引用无法调用子类特有的方法。 在Java...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值