Java学习第八章总结

柔光的暖阳◎ 2023-09-26 22:19 111阅读 0赞

#### 文章目录 ####

*  类包
 *   *  类路径
     *  指定包名(package)
     *  导包
 *  内部类
 *   *  成员内部类
     *  匿名内部类
 *  End

## 类包 ##

在Java中，我们可以使用**class关键字**来进行定义一个类，在程序被编译后就会产生一个.class文件。类的定义是规定类名不能重复的，如果程序内只定义了少量的类，那自然不用担心这个问题。  
但是，随着类的数量增多，那么难免会出现这个问题，如果根据需求需要定义两个名字相同但是程序逻辑不同的类时，那么该如何解决呢，最好的方法就是将这个两个类放置在不同的包下面。

**类的定义规定，在同一个类包下面不允许出来同名的类，但是在不同类包下面就允许出现这种情况，相当于将两个同名的类放入了不同的盒子内，避免出现这个问题。**

包和类的关系  
![在这里插入图片描述][8c2d49910fd54ea18afbaadf456777db.png]

### 类路径 ###

如果一个程序内存在多个同名不同包的max类，那么该如何使用指定包的类呢？  
**在使用该类时使用该类的类路径，也成为绝对路径**。

java.util.Date date=new java.util.Date();		// 选择Java.util包下的Date类
    java.sql.Date date2=new java.sql.Date(100)	// 选择Java.sql包下的Date类

### 指定包名(package) ###

在进行创建包的时候需要注意的是，Java包的命名规则建议使用全小写字母进行命名。  
需要了解的是如果一个类没有被定义在一个指定的包内，那么该类就被归纳到默认包(**default package**)中。

在某个包下面创建一个类的话，需要在这个类的开头加上表达式 **package 包名**，该表达式需要放置在程序的第一行，使用package关键字指定包名之后，包名也会成为类名的一部分，在不同包下使用该类的话，需要使用 **import 包名.类名** 的格式。

package test;	//指定包名，表示该类在本包内
    public class dome{
        
    }

### 导包 ###

在Java中，如果需要使用到其它包内的类的话，除了使用该类的绝对路径之外，我们还可以使用Java中 **import** 关键字来指定。例如，如果在其它包内也定义了一个Math，那么假如我们只想使用该Math类的话，那么我们可以使用import关键字进行导包。

**例如：**

package test;
    
    import Number_5.Math;   //导包，导入其它包内的Math类
    
    public class Demo_4 {
        
        public static void main(String[] args) {
        
            int max = Math.max(4, 6);	// 进行导包后，再使用时，直接使用包名.类名的方法进行使用
            System.out.println(max);
        }
    }

在进行导包后，我们在使用该包下的Math类后，可以看到，java.lang包下有一个Java给定的Math类，还有一个我们刚刚进行导的包下的Math类。

![在这里插入图片描述][0ae46e0f39a24cba908e8f2a0b4754ff.png]

**需要注意的是，刚刚我们已经导入了Number\_5包下的Math类，如果需要使用java.lang包下的Math类的话，需要使用java.lang.Math类的完整路径的方式使用该类。因为如果在之前导入了Number\_5包下的Math类的话，程序中如果使用Math类中的方法，编译器只会去Number\_5.Math类内进行寻找该方法，如果没有找到则报错。**

![在这里插入图片描述][ef8093af83a54d7bb1d3d36a4e0ff2a4.png]

如果需要使用java.lang包下的Math类的话，需要使用全名格式，指定编译器去那个包下寻找min方法。  
![在这里插入图片描述][d55eaf2a672542e6894b1cd89344b581.png]

需要注意的是，如果使用import导入某个包下的所有类时，这些类并不包括该包下的子包的类。如果需要使用子包中的类时，需要对子包进行单独引用。

import 包名.子包名.*;	//导入所有类
    import 包名.子包名.类名;	//导入指定类

**导入静态方法或静态成员**

使用import关键字还可以对静态方法与静态变量进行导包。

import java.lang.max;
    import java.lang.System.out;
    
    public class Demo{
        
    	public static void main(String[] args){
        
    		out.println("较大值为："+(max(1,4)));	// 导入后可直接使用
    	}
    }

## 内部类 ##

**内部类顾名思义，就定义在一个类内部的类。**

![加粗样式][db9c8776b0904252b8e62f219c7cddf9.png]

### 成员内部类 ###

定义在一个类成员位置的内部类，称为成员内部类，在成员内部类中可以使用外部类的的任意成员变量与成员方法，即使该外部类成员变量被private所修饰。

package test;
    
    public class Demo_4 {
        
        private int num;
        static int i=0;
        
        // 内部类
         class test{
        
            public void show(){
        
            	// 内部类调用外部类的成员变量
                System.out.println(num);
                System.out.println(i);
            }
        }
    }

**因为private等权限修饰符是针对外界的调用而进行权限判断的，但是成员内部类定义在该类的内部，那么相对于该类的一部分，就像该类的方法也是可以调用被private修饰的成员变量一般，成员内部类属于外部类的成员之一。**

**内部类是依赖于外部类的存在而存在。除非程序中已经有了一个外部类的对象，否则内部类一般不会单独存在。**

`内部类也可以被权限修饰符进行修饰，如果内部类被private修饰，那么外界无法创建内部类的对象，只能在外部类中创建内部类的对象。`

该如何获取内部类的对象呢？

两种方法：

1.  对外部类编写get方法，对外提供内部类的对象
2.  如果内部类没有被private修饰，那么可以在外界创建一个内部类的对象；

**方法二：直接创建内部类对象**

成员内部类创建对象格式：

> 外部类.内部类 类名 = 外部类对象.new 内部类构造方法();

public class Demo_4{
        
        public static void main(String[] args) {
        
            W.N j=new W().new N();	// 链式法创建内部类对象
        }
    }
    
    // 外部类
    class W {
        
        // 内部类
         class N {
          
        }
    }

**方法一：通过get方法对外提供成员内部类对象**  
这个方法多用于成员内部类被private修饰时，才使用这个方法。

> 但是如果成员内部类被private修饰了，那么外界也无法使用成员内部类的变量来接收这个返回值，只能使用多态的方式，让成员内部类的父类进行接收，如果该成员内部类没有继承其它类，那么只能使用Object来接收这个返回值

public class Demo_4{
        
        public static void main(String[] args) {
        
            Object a = new W().getN();
        }
    }
    class W {
        
        private class N {
        
        }
        public N getN(){
        
            return new N();
        }
    }

**外部类与内部类之间也可使用this关键字，如果在内部类中需要使用到外部类的成员变量，那么可以使用外部类.this.变量名的方式使用。**

例如：

public class Demo_4{
        
        public static void main(String[] args) {
        
            W.N a=new W().new N();
            a.show();
        }
    }
    class W {
        
        private int i=10;
        class N {
        
            private int i=20;
            public void show(){
        
                int i=30;
                System.out.println(i);          // 方法内的i
                System.out.println(this.i);     // 内部类的i
                System.out.println(W.this.i);   // 外部类的i
            }
        }
    }

![在这里插入图片描述][fdaba90f8c5646f6b707196a0d687dd9.png]

### 匿名内部类 ###

匿名内部类本质是一个隐藏了名字的内部类。匿名类是只有在创建时才会编写类体的一种写法。

语法格式：

new 继承/实现(){
        
    	//重写的方法
    };

**匿名内部类在一对大括号 \{ \} 的范围内是一个类，整体却是一个new出来的对象。**

**例如：**

public class Demo_4{
        
        public static void main(String[] args) {
        
        	// 匿名内部类
            new Swit(){
        
                @Override
                public void swit(){
        
                    System.out.println("重写了swit方法");
                }
            };
        }
    }
    interface Swit{
        
        public void swit();
    }

上述匿名内部类处的语法解读。  
![在这里插入图片描述][1fa2715c3506429f9b52284caf7bb4b3.png]

`整体来说就是，使用空参构造创建一个实现了Swit接口的匿名内部类的对象`，就是说，创建匿名内部类的地方是创建了一个对象。

匿名内部类编译后会产生一个以 “外部类名$序号“ 为名称的 .class文件，序号以1-n排列，分别代表1-n个匿名内部类。那么我们可以找到这个.class文件，并对其进行反编译来查看我的结论是否正确。

**匿名内部类产生的.class文件**  
![在这里插入图片描述][6df7d9d8b1374033a77eb71ac72f61cd.png]  
**javap 命令，可以对.class文件进行反编译，将字节码文件进行反编译，会打印出该字节码文件包含的信息**

**反编译的结果：被圈起来的是虚拟机自行添加的空参构造与重写的接口方法。**  
![在这里插入图片描述][8325ad160e2f493489d27bb611f1d930.png]

上述反编译的结果可以说明，使用匿名内部类的格式创建的是一个匿名内部类的对象，而大括号内\{\}的才是匿名内部类的类体。

1.  匿名内部类的对象如果没有赋值给任何引用变量的话，该对象会在使用后被Java虚拟机自动销毁。
2.  匿名类不能写构造方法。
3.  匿名类不能定义静态的成员。

那么匿名内部类对象可以赋值给那些引用变量呢？**可以被赋值给被继承的接口或者父类对象**。形成多态。

**父类对象调用子类方法**

public class Demo_4{
        
        public static void main(String[] args) {
        
            Swit s=new Swit(){
        
                public void swit(){
        
                    System.out.println("重写了swit方法");
                }
            };
            s.swit();	// 父类对象调用子类重写的方法
        }
    }
    interface Swit{
        
        public void swit();
    }

**运行过程**

![在这里插入图片描述][c10881b6c8c94495828c2d3dac337b3c.png]

**匿名内部类的那个整体是一个对象，只有大括号内的才是那个具体的匿名内部类。**

## End ##

上述代码如有错误，还请指出。

[8c2d49910fd54ea18afbaadf456777db.png]: https://img-blog.csdnimg.cn/8c2d49910fd54ea18afbaadf456777db.png
[0ae46e0f39a24cba908e8f2a0b4754ff.png]: https://img-blog.csdnimg.cn/0ae46e0f39a24cba908e8f2a0b4754ff.png
[ef8093af83a54d7bb1d3d36a4e0ff2a4.png]: https://img-blog.csdnimg.cn/ef8093af83a54d7bb1d3d36a4e0ff2a4.png
[d55eaf2a672542e6894b1cd89344b581.png]: https://img-blog.csdnimg.cn/d55eaf2a672542e6894b1cd89344b581.png
[db9c8776b0904252b8e62f219c7cddf9.png]: https://img-blog.csdnimg.cn/db9c8776b0904252b8e62f219c7cddf9.png
[fdaba90f8c5646f6b707196a0d687dd9.png]: https://img-blog.csdnimg.cn/fdaba90f8c5646f6b707196a0d687dd9.png
[1fa2715c3506429f9b52284caf7bb4b3.png]: https://img-blog.csdnimg.cn/1fa2715c3506429f9b52284caf7bb4b3.png
[6df7d9d8b1374033a77eb71ac72f61cd.png]: https://img-blog.csdnimg.cn/6df7d9d8b1374033a77eb71ac72f61cd.png
[8325ad160e2f493489d27bb611f1d930.png]: https://img-blog.csdnimg.cn/8325ad160e2f493489d27bb611f1d930.png
[c10881b6c8c94495828c2d3dac337b3c.png]: https://img-blog.csdnimg.cn/c10881b6c8c94495828c2d3dac337b3c.png