• 【详识JAVA语言】面向对象程序三大特性之一：封装

    封装的概念

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

    比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器，USB插孔等，让用 户来和计算机进行交互，完成日常事务。

    但实际上：电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

    对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户 只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳 子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

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

    访问限定符 

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

    比如：

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

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

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

    说明

    protected主要是用在继承中，继承部分详细介绍

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

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

    1. public class Computer {
    2.  
    3. private String cpu; // cpu
    4.  
    5. private String memory; // 内存
    6.  
    7. public String screen; // 屏幕
    8.  
    9. String brand; // 品牌---->default属性
    10.  
    11. public Computer(String brand, String cpu, String memory, String screen) {
    12.  
    13. this.brand = brand;
    14.  
    15. this.cpu = cpu;
    16.  
    17. this.memory = memory;
    18.  
    19. this.screen = screen;
    20.  
    21. }
    22.  
    23. public void Boot(){
    24.  
    25. System.out.println("开机~~~");
    26.  
    27. }
    28.  
    29. public void PowerOff(){
    30.  
    31. System.out.println("关机~~~");
    32.  
    33. }
    34.  
    35. public void SurfInternet(){
    36.  
    37. System.out.println("上网~~~"); }
    38.  
    39. }
    40.  
    41. public class TestComputer {
    42.  
    43. public static void main(String[] args) {
    44.  
    45. Computer p = new Computer("HW", "i7", "8G", "13*14");
    46.  
    47. System.out.println(p.brand); // default属性：只能被本包中类访问
    48.  
    49. System.out.println(p.screen); // public属性： 可以任何其他类访问
    50.  
    51.  //  System.out.println(p.cpu);  // private属性：只能在Computer类中访问，不能被其他类访问
    52.  
    53. }
    54.  
    55. }

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

    封装扩展之包

    包的概念

    在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。有点类似于目录。比如：为了更好的管理电脑中的歌曲，一种好的方式就是将相同属性的歌曲放在相同文件 下，也可以对某个文件夹下的音乐进行更详细的分类。

    在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一 个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

    导入包中的类 

    Java 中已经提供了很多现成的类供我们使用. 例如Date类：可以使用类. java.util.Date 导入java.util 这个包中的 Date类

    1. public class Test {
    2.  
    3. public static void main(String[] args) {
    4.  
    5. java.util.Date date = new java.util.Date();
    6.  
    7. // 得到一个毫秒级别的时间戳
    8.  
    9. System.out.println(date.getTime());
    10.  
    11. }
    12.  
    13. }

    但是这种写法比较麻烦一些, 可以使用 import语句导入包.

    1. import java.util.Date; public class Test {
    2.  
    3. public static void main(String[] args) {
    4.  
    5. Date date = new Date(); // 得到一个毫秒级别的时间戳
    6.  
    7. System.out.println(date.getTime());
    8.  
    9. }
    10.  
    11. }

    如果需要使用 java.util 中的其他类, 可以使用 import java.util.*

    1. import java.util.*;
    2.  
    3. public class Test {
    4.  
    5. public static void main(String[] args) {
    6.  
    7. Date date = new Date(); // 得到一个毫秒级别的时间戳
    8.  
    9. System.out.println(date.getTime());
    10.  
    11. }
    12.  
    13. }

    但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.

    1. import java.util.*;
    2.  
    3. import java.sql.*;
    4.  
    5. public class Test {
    6.  
    7. public static void main(String[] args) {
    8.  
    9. // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
    10.  
    11. Date date = new Date();
    12.  
    13. System.out.println(date.getTime());
    14.  
    15. }
    16.  
    17. }
    18.  
    19. // 编译出错 Error:(5, 9) java: 对Date的引用不明确 java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

    在这种情况下需要使用完整的类名

    1. import java.util.*;
    2.  
    3. import java.sql.*;
    4.  
    5. public class Test {
    6.  
    7. public static void main(String[] args) {
    8.  
    9. java.util.Date date = new java.util.Date();
    10.  
    11. System.out.println(date.getTime());
    12.  
    13. }
    14.  
    15. }

    可以使用import static导入包中静态的方法和字段 

    注意事项: import 和 C++ 的 #include import 只是为了写代码的时候更方便.

    1. import static java.lang.Math.*;
    2.  
    3. public class Test {
    4.  
    5. public static void main(String[] args) {
    6.  
    7. double x = 30;
    8.  
    9. double y = 40;
    10.  
    11. // 静态导入的方式写起来更方便一些.
    12.  
    13. // double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
    14.  
    15. double result = sqrt(pow(x, 2) + pow(y, 2));
    16.  
    17. System.out.println(result);
    18.  
    19. }
    20. }

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

    自定义包

    基本规则

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

    2. 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1).

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

    com/bit/demo1 来存储代码.

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

    操作步骤

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

    2. 在弹出的对话框中输入包名, 例如 com.bit.demo1 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可.

    4. 此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了

     

    5. 同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句

     包的访问权限控制举例

    Computer类位于com.bit.demo1包中，TestComputer位置com.bit.demo2包中：

    1. package com.bit.demo1;
    2.  
    3. public class Computer {
    4.  
    5. private String cpu; // cpu 
    6. private String memory; // 内存 
    7. public String screen; // 屏幕 
    8. String brand; // 品牌
    9.  
    10. public Computer(String brand, String cpu, String memory, String screen) { this.brand = brand; 
    11. this.cpu = cpu; 
    12. this.memory = memory; 
    13. this.screen = screen; 
    14. }
    15.  
    16. public void Boot(){ 
    17. System.out.println("开机~~~"); 
    18. }
    19.  
    20. public void PowerOff(){ 
    21. System.out.println("关机~~~"); 
    22. }
    23.  
    24. public void SurfInternet(){ 
    25. System.out.println("上网~~~"); 
    26. } 
    27. }
    28.  
    29. /// package com.bite.demo2;
    30.  
    31. import com.bite.demo1.Computer;
    32.  
    33. public class TestComputer { public static void main(String[] args) {
    34.  
    35. Computer p = new Computer("HW", "i7", "8G", "13*14");
    36.  
    37. System.out.println(p.screen); 
    38. // System.out.println(p.cpu); // 报错：cup是私有的，不允许被其他类访问 // System.out.println(p.brand); // 报错：brand是default，不允许被其他包中的类访问
    39.  
    40. }
    41.  
    42. }
    43.  
    44. // 注意：如果去掉Computer类之前的public修饰符，代码也会编译失败

    常见的包 

    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成员

    再谈学生类

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

    1. public class Student{
    2.  
    3. // ...
    4.  
    5. public static void main(String[] args) {
    6.  
    7. Student s1 = new Student("Li leilei", "男", 18, 3.8);
    8.  
    9. Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
    10.  
    11. Student s3 = new Student("Jim", "男", 18, 2.6); }
    12.  
    13. }

     

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

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

    static修饰成员变量

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

    【静态成员变量特性】

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

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

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

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

    1. public class Student{
    2.  
    3. public String name; 
    4. public String gender; 
    5. public int age; 
    6. public double score; 
    7. public static String classRoom = "Bit306";
    8.  
    9. // ...
    10.  
    11. public static void main(String[] args) {
    12.  
    13. // 静态成员变量可以直接通过类名访问 
    14. System.out.println(Student.classRoom);
    15.  
    16. Student s1 = new Student("Li leilei", "男", 18, 3.8); 
    17. Student s2 = new Student("Han MeiMei", "女", 19, 4.0); 
    18. Student s3 = new Student("Jim", "男", 18, 2.6);
    19.  
    20. // 也可以通过对象访问：但是classRoom是三个对象共享的 
    21. System.out.println(s1.classRoom); 
    22. System.out.println(s2.classRoom);
    23. System.out.println(s3.classRoom); 
    24. }
    25.  
    26. }

    大家以调试方式运行上述代码，然后在监视窗口中可以看到，静态成员变量并没有存储到某个具体的对象中。

    static修饰成员方法

    一般类中的数据成员都设置为private，而成员方法设置为public，那设置之后，Student类中classRoom属性如何 在类外访问呢？

    1. public class Student{
    2. private String name; 
    3. private String gender; 
    4. private int age; 
    5. private double score; 
    6. private static String classRoom = "Bit306";
    7.  
    8. // ...
    9.  
    10. }
    11.  
    12. public class TestStudent { 
    13. public static void main(String[] args) { 
    14. System.out.println(Student.classRoom); 
    15. } 
    16. }
    17.  
    18. 编译失败：
    19.  
    20. Error:(10, 35) java: classRoom 在 extend01.Student 中是 private 访问控制

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

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

    1. public class Student{ 
    2.  
    3. // ...
    4.  
    5. private static String classRoom = "Bit306";
    6.  
    7. // ...
    8.  
    9. public static String getClassRoom(){ 
    10. return classRoom; 
    11. }
    12.  
    13. }
    14.  
    15. public class TestStudent {
    16.  
    17. public static void main(String[] args) { System.out.println(Student.getClassRoom()); 
    18.  
    19. }
    20.  
    21. } 
    22. 输出：Bit306

    【静态方法特性】

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

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

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

    1. public static String getClassRoom(){ 
    2. System.out.println(this); 
    3. return classRoom; 
    4. }
    5.  
    6. // 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
    7.  
    8. public static String getClassRoom(){
    9.  
    10. age += 1;
    11.  
    12. return classRoom;
    13.  
    14. }
    15.  
    16. // 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age

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

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

    static成员变量初始化

    注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性 静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化。

    1. 就地初始化

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

    1. public class Student{
    2.  
    3. private String name;
    4.  
    5. private String gender;
    6.  
    7. private int age;
    8.  
    9. private double score;
    10.  
    11. private static String classRoom = "Bit306";
    12.  
    13. // ...
    14.  
    15. }

    2. 静态代码块初始化

    那什么是代码块呢？继续往后看 :) ~~~

    代码块

    代码块概念以及分类

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

    普通代码块

    构造块

    静态块

    同步代码块（后续讲解多线程部分再谈）

    普通代码块

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

    1. public class Main{
    2.  
    3. public static void main(String[] args) { 
    4. { //直接使用{}定义，普通方法块
    5.  
    6. int x = 10 ;
    7.  
    8. System.out.println("x1 = " +x);
    9.  
    10. }
    11.  
    12. int x = 100 ;
    13.  
    14. System.out.println("x2 = " +x);
    15.  
    16. }
    17.  
    18. }
    19.  
    20. // 执行结果
    21.  
    22. x1 = 10
    23.  
    24. x2 = 100

    这种用法较少见

    构造代码块

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

    1. public class Student{
    2.  
    3. //实例成员变量
    4.  
    5. private String name;
    6.  
    7. private String gender;
    8.  
    9. private int age;
    10.  
    11. private double score;
    12.  
    13. public Student() {
    14.  
    15. System.out.println("I am Student init()!");
    16.  
    17. }
    18.  
    19. //实例代码块
    20.  
    21. {
    22.  
    23. this.name = "bit";
    24.  
    25. this.age = 12;
    26.  
    27. this.sex = "man";
    28.  
    29. System.out.println("I am instance init()!");
    30.  
    31. }
    32.  
    33. public void show(){
    34.  
    35. System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    36.  
    37. }
    38.  
    39. }
    40.  
    41. public class Main {
    42.  
    43. public static void main(String[] args) {
    44.  
    45. Student stu = new Student(); stu.show();
    46.  
    47. }
    48.  
    49. }
    50.  
    51. // 运行结果
    52.  
    53. I am instance init()!
    54.  
    55. I am Student init()!
    56.  
    57. name: bit age: 12 sex: man

    静态代码块

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

    1. public class Student{
    2.  
    3. private String name;
    4.  
    5. private String gender;
    6.  
    7. private int age; private double score;
    8.  
    9. private static String classRoom;
    10.  
    11. //实例代码块
    12.  
    13. {
    14.  
    15. this.name = "bit";
    16.  
    17. this.age = 12;
    18.  
    19. this.gender = "man";
    20.  
    21. System.out.println("I am instance init()!");
    22.  
    23. }
    24.  
    25. // 静态代码块
    26.  
    27. static {
    28.  
    29. classRoom = "bit306";
    30.  
    31. System.out.println("I am static init()!");
    32.  
    33. }
    34.  
    35. public Student(){
    36.  
    37. System.out.println("I am Student init()!");
    38.  
    39. }
    40.  
    41. public static void main(String[] args) {
    42.  
    43. Student s1 = new Student();
    44.  
    45. Student s2 = new Student();
    46.  
    47. }
    48.  
    49. }

    注意事项

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

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

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

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

    内部类

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

    1. public class OutClass { 
    2. class InnerClass{
    3.  
    4. }
    5.  
    6. }
    7.  
    8. // OutClass是外部类 
    9. // InnerClass是内部类

    【注意事项】

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

    1. public class A{
    2.  
    3. }
    4.  
    5. class B{
    6.  
    7. }
    8.  
    9. // A 和 B是两个独立的类，彼此之前没有关系

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

    内部类的分类

    先来看下，内部类都可以在一个类的那些位置进行定义

    1. public class OutClass {
    2.  
    3. // 成员位置定义：未被static修饰 --->实例内部类 
    4. public class InnerClass1{ }
    5.  
    6. // 成员位置定义：被static修饰 ---> 静态内部类 
    7. static class InnerClass2{
    8.  
    9. }
    10.  
    11. public void method(){
    12.  
    13. // 方法中也可以定义内部类 ---> 局部内部类：几乎不用 
    14. class InnerClass5{
    15.  
    16. }
    17.  
    18. }
    19.  
    20. }

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

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

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

    注意：内部类其实日常开发中使用并不是非常多，大家在看一些库中的代码时候可能会遇到的比较多，日常开始中 使用最多的是匿名内部类。

    内部类

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

    实例内部类

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

    1. public class OutClass {
    2.  
    3. private int a; 
    4. static int b; 
    5. int c; 
    6.  
    7. public void methodA(){
    8.  
    9. a = 10;
    10.  
    11. System.out.println(a);
    12.  
    13. }
    14.  
    15. public static void methodB(){ 
    16.  
    17. System.out.println(b); 
    18.  
    19. }
    20.  
    21. // 实例内部类：未被static修饰 
    22.  
    23. class InnerClass{
    24.  
    25. int c; public void methodInner(){ 
    26.  
    27. // 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
    28.  
    29. a = 100;
    30.  
    31. b =200;
    32.  
    33. methodA(); 
    34.  
    35. methodB();
    36.  
    37. // 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
    38.  
    39. c = 300;
    40.  
    41. System.out.println(c);
    42.  
    43. // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字 
    44.  
    45. OutClass.this.c = 400; 
    46.  
    47. System.out.println(OutClass.this.c);
    48.  
    49. }
    50.  
    51. }
    52.  
    53. public static void main(String[] args) {
    54.  
    55. // 外部类：对象创建 以及 成员访问 
    56.  
    57. OutClass outClass = new OutClass(); 
    58.  
    59. System.out.println(outClass.a); 
    60.  
    61. System.out.println(outClass.b); 
    62.  
    63. System.out.println(outClass.c); 
    64.  
    65. outClass.methodA(); 
    66.  
    67. outClass.methodB();
    68.  
    69. System.out.println("=============实例内部类的访问=============");
    70.  
    71. // 要访问实例内部类中成员，必须要创建实例内部类的对象 
    72. // 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
    73.  
    74. // 创建实例内部类对象 
    75. OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
    76.  
    77. // 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象 OutClass.InnerClass innerClass2 = outClass.new InnerClass(); innerClass2.methodInner();
    78.  
    79. } 
    80.  
    81. }

    【注意事项】

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

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

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

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

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

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

    静态内部类

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

    1. public class OutClass {
    2.  
    3. private int a; 
    4. static int b; 
    5. public void methodA(){
    6.  
    7. a = 10;
    8.  
    9. System.out.println(a);
    10.  
    11. }
    12.  
    13. public static void methodB(){ 
    14. System.out.println(b); 
    15.  
    16. }
    17.  
    18. // 静态内部类：被static修饰的成员内部类 
    19. static class InnerClass{
    20.  
    21. public void methodInner(){ 
    22. // 在内部类中只能访问外部类的静态成员 
    23. // a = 100; 
    24.  
    25. // 编译失败，因为a不是类成员变量
    26.  
    27. b =200;
    28.  
    29. // methodA(); methodB();
    30.  
    31. // 编译失败，因为methodB()不是类成员方法
    32.  
    33. }
    34.  
    35. }
    36.  
    37. public static void main(String[] args) { 
    38. // 静态内部类对象创建 & 成员访问 
    39. OutClass.InnerClass innerClass = new OutClass.InnerClass(); innerClass.methodInner(); }
    40.  
    41. }

    【注意事项】

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

    如果确实想访问，我们该如何做？

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

    局部内部类

    定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，一般使用的非常少，此处简单了解下语法格式。

    1. public class OutClass {
    2.  
    3. int a = 10;
    4.  
    5. public void method(){
    6.  
    7. int b = 10;
    8.  
    9. // 局部内部类：定义在方法体内部 // 不能被public、static等访问限定符修饰 
    10. class InnerClass{
    11.  
    12. public void methodInnerClass(){
    13.  
    14. System.out.println(a);
    15.  
    16. System.out.println(b);
    17.  
    18. } 
    19. }
    20.  
    21. // 只能在该方法体内部使用，其他位置都不能用 
    22. InnerClass innerClass = new InnerClass(); 
    23. innerClass.methodInnerClass();
    24.  
    25. }
    26.  
    27. public static void main(String[] args) { 
    28. // OutClass.InnerClass innerClass = null; 编译失败 }
    29.  
    30.  
    31. }

    【注意事项】

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

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

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

    4. 几乎不会使用

    对象的打印

    1. public class Person { 
    2.  
    3. String name; 
    4.  
    5. String gender; 
    6.  
    7. int age;
    8.  
    9. public Person(String name, String gender, int age) { 
    10.  
    11. this.name = name; 
    12.  
    13. this.gender = gender; 
    14.  
    15. this.age = age; 
    16. }
    17.  
    18. public static void main(String[] args) { 
    19.  
    20. Person person = new Person("Jim","男", 18); 
    21.  
    22. System.out.println(person); 
    23.  
    24. }
    25.  
    26. }
    27.  
    28. // 打印结果：day20210829.Person@1b6d3586

    如果想要默认打印对象中的属性该如何处理呢？答案：重写toString方法即可。

    1. public class Person { 
    2.  
    3. String name; 
    4.  
    5. String gender; 
    6.  
    7. int age;
    8.  
    9. public Person(String name, String gender, int age) { 
    10.  
    11. this.name = name; 
    12.  
    13. this.gender = gender; 
    14.  
    15. this.age = age; 
    16. }
    17.  
    18. @Override 
    19. public String toString() { 
    20.  
    21. return "[" + name + "," + gender + "," + age + "]"; 
    22.  
    23. }
    24.  
    25. public static void main(String[] args) { 
    26.  
    27. Person person = new Person("Jim","男", 18); 
    28.  
    29. System.out.println(person); }
    30.  
    31. }
    32.  
    33. // 输出结果：[Jim,男,18]

    ​​​​​​​

  • 相关阅读:
    [Codeforces] number theory (R1600) Part.8
    labview卷积结合律笔记
    使用 Next.js 和 React Router 构建单页应用程序(SPA)
    自学软件测试3个月，成功入职《字节》后的面试心得总结
    浅谈基于物联网的医院消防安全管理
    如何优化网站信息架构
    Spring Boot学习笔记（十一）Druid数据源及动态数据源配置
    js 数组移除指定元素【函数封装】（含对象数组移除指定元素）
    沉浸式视听体验：全景声技术是如何实现的？
    C++初阶（stack+queue）
  • 原文地址：https://blog.csdn.net/caojunjia/article/details/136433157