java 内部类，包装类，Object常用方法，一点点String

最新推荐文章于 2024-10-06 20:16:20 发布

../Aleister

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量80

点赞数

文章标签： java

本文链接：https://blog.csdn.net/resistancealex/article/details/119442427

版权

本文介绍了内部类的四种形式：成员内部类、静态内部类、局部内部类和匿名内部类。讲解了它们的定义、访问规则，以及在实际场景中的应用。重点突出了如何根据需要选择合适的内部类类型，如静态内部类用于静态属性和方法，成员内部类访问外部属性和方法等。

摘要由CSDN通过智能技术生成

内部类：

一个类内部嵌套另一个类，使得内部的类可以跟外部的类共享一些资源

内部类一共分为四种形式：
成员内部类
静态内部类
局部内部类
匿名内部类

成员内部类
在类中，可以定义成员方法、成员变量，除此之外，还可以定义成员内部类

//外部类
public class MemberOuterClass{
	//外部类的属性
	private String name;
	private static int age;
	//外部类的方法
	public void run(){}
	public static void go(){}
    
	/* 成员内部类 声明开始 */
	public class MemberInnerClass{
		private String name;
		private int age;
		public void run(String name){}
	}
	/* 成员内部类 声明结束 */
}

注意，成员内部类中，【不能】编写静态的属性和方法

注意，当前这个代码，编译成功后，会生成俩个class文件，一个对应外部类，一个对应内部类编译生成的俩个class文件的名字分别为：

MemberOuterClass.class

MemberOuterClass$MemberInnerClass.class

成员内部类和外部类的相互访问：

成员内部类访问外部的属性和方法

public class MemberOuterClass {
	//外部类的属性
	private String name;
	private static int age;
	//外部类的方法
	public void run(){}
	public static void go(){}
    
	/* 成员内部类 声明开始 */
	public class MemberInnerClass{
		private String name;
		private int age;
		public void run(String name){
		//访问当前run方法中的参数name
		System.out.println(name);
		//访问内部类自己的属性name
		System.out.println(this.name);
   	 	//访问外部类的非静态属性
	 	System.out.println(MemberOuterClass.this.name);
		//访问外部类的静态属性
		System.out.println(MemberOuterClass.age);
		//访问外部类的非静态方法
		MemberOuterClass.this.run();
		//访问外部类的静态方法
		MemberOuterClass.go();
		}
	}
	/* 成员内部类 声明结束 */
}

如果内部类使用外部类的实例属性时：外部类.this.外部类属性名

int name = MemeberOuter.this.name;
int age = MemeberOuter.age;

外部类访问成员内部类的属性和方法

public class MemberOuterClass {
	//外部类的方法，访问成员内部类的属性和方法
	public void test(){
	//需要创建内部类对象，然后才可以访问
	MemberInnerClass t = new MemberInnerClass();
	System.out.println(t.name);
	System.out.println(t.age);
	t.run("tom");
	}
	/* 成员内部类 声明开始 */
	public class MemberInnerClass{
		private String name;
		private int age;
		public void run(String name){
		}
	}
	/* 成员内部类 声明结束 */
}

在其他类中使用这个内部类(创建对象)：

如果这个成员内部类不是private修饰的，那么在其他类中就可以访问到这个内部类

public class Test {
	public static void main(String[] args) {
   		MemberOuterClass moc = new MemberOuterClass();
		MemberInnerClass mic = moc.new MemberInnerClass();
		mic.run("tom");
	}
}

在其他类中，使用这个非private修饰的成员内部类的时候，需要注意以下几点：

这个内部类需要import导入，并且是外部类.内部类的形式导入。
在创建对象的时候，需要先创建出外部类对象，然后使用外部类对象再创建内部类对象。
形式为：外部类对象.new 内部类对象();

类的内部除了嵌套另一个类之外，是否还可以嵌套接口？
可以，不仅类中可以嵌套接口，接口的内部也可以嵌套其他接口。
例如，参考java.util.Map接口中的内部接口Entry

什么情况下会使用内部类？
在对事物进行抽象的时候，若一个事物内部还包含其他事物，就可以考虑使用内部类这种结构。
例如，汽车（Car）中包含发动机（Engine），这时， Engine 类就可以考虑（非必须）使用内部类来描述，定义在Car类中的成员位置。
这样设计，既可以表示Car和Engine的紧密联系的程度，也可以在Engine类中很方便的使用到Car里面的属性和方法

静态内部类

静态内部类和成员内部类是类似的，只是这个内部类，多了static关键字进行修饰。

注意，静态内部类中，【可以】编写静态的属性和方法，另外在四种内部类中，只有静态内部类可以编写静态属性和方法

静态内部类和外部类的相互访问：

静态内部类访问外部的属性和方法

public class StaticOuterClass {
	//外部类的属性
	private String name;
	private static int age;
	//外部类的方法
	public void run(){}
	public static void go(){}
    
	/* 静态内部类 声明开始 */
	public static class StaticInnerClass{
		private String name;
		private static int age;
		public void run(String name){
		//访问当前run方法中的参数name
		System.out.println(name);
		//访问内部类自己的属性name
		System.out.println(this.name);
		//访问内部类自己的静态属性age
		System.out.println(age);
		//静态内部类中，无法访问外部类的非静态属性和方法
		//System.out.println(StaticOuterClass.this.name);
		//StaticOuterClass.this.run();
		//访问外部类的静态属性和方法
		System.out.println(StaticOuterClass.age);
		StaticOuterClass.go();
	}
}
    
/* 静态内部类 声明结束 */
}

注意，在静态内部类中访问不了外部类中的非静态属性和方法，非要使用只能先创建对象

外部类访问静态内部类的属性和方法

public class StaticOuterClass {
	public void test(){
	//外部类中，访问静态类中的静态属性
	System.out.println(StaticInnerClass.age);
	//外部类中，访问静态内部类中的非静态属性和方法
	StaticInnerClass sic = new StaticInnerClass();
	System.out.println(sic.name);
	sic.run("tom");
}
    
/* 静态内部类 声明开始 */
	public static class StaticInnerClass{
		private String name;
   	 	private static int age;
		public void run(String name){
		}
	}
/* 静态内部类 声明结束 */
}

注意，在静态外部类中访问不了内部类中的非静态属性和方法，非要使用只能先创建对象

可以使用静态导入（import）导入

局部内部类（内部定义，内部使用）

局部内部类，是另一种形式的内部，在声明在外部类的方法中，相当于方法中的局部变量的位置，它的作用范围只是在当前方法中。

局部内部类是最不常用的一种内部类。

局部内部类和外部类的相互访问：

局部内部类访问外部的属性和方法

public class LocalOuterClass {
	//外部类的属性
	private String name;
	private static int age;
	//外部类的方法
	public void run(){}
	public static void go(){}
	public void sayHello(String name){
		/* 局部内部类 声明开始 */
		class LocalInnerClass{
			private String name;
			public void test(String name){
			//访问当前test方法中的参数name
			System.out.println(name);
			//访问内部类自己的属性name
			System.out.println(this.name);
            /*注意，sayHello方法的参数name，无法访问，因为实在没有办法表示了，换成其他
            名字后，就可以访问了，不要叫name就行*/
            //访问外部类的非静态属性
            System.out.println(LocalOuterClass.this.name);
            //访问外部类的非静态方法
            LocalOuterClass.this.run();
            //访问外部类的静态属性和方法
            System.out.println(LocalOuterClass.age);
            LocalOuterClass.go();
		}
	}
	/* 局部内部类 声明结束 */
	}
}

局部内部类中，访问当前方法中的变量，这个变量必须是final修饰的

public void sayHello(final String name){
    final int num = 1;
    /* 局部内部类 声明开始 */
    class LocalInnerClass{
        public void test(){
        System.out.println(name);
        System.out.println(num);
        //编译报错，final修饰的变量，只能赋值一次
        //name = "tom";
        //num = 2;
        }
    }
        /* 局部内部类 声明结束 */
}

在JDK1.8中，一个局部变量在局部内部类中进行方法了，那么这个局部变量自动变为final修饰

外部类访问局部内部类的属性和方法

public void sayHello(String name){
  /* 局部内部类 声明开始 */
  class LocalInnerClass{
      private int num;
      public void test(){
  	}
  }
  /* 局部内部类 声明结束 */
  
  //创建局部内部类对象
  LocalInnerClass lic = new LocalInnerClass();
  //对象访问属性
  System.out.println(lic.num);
  //对象调用方法
  lic.test();
}

局部内部类，只能在当前声明的方法中进行使用。

匿名内部类（接口的实现就用一会，就不需要在定义一个类去实现，用匿名内部类就行）
匿名内部类，是一种没有名字的内部类，它是内部类的一种简化写法。在之后的代码中，匿名内部类是
使用最多的一种内部类。（很重要）
在普通的代码中，使用一个接口的步骤如下：
声明一个类，去实现这个接口
实现这个接口中的抽象方法（重写）
在其他代码中，创建这个类的对象
调用类中实现（重写）后的方法
其实，在这个过程中，我们的目的就是把接口中的抽象方法给实现（重写）了，最后再调用到这个实现
后（重写）的方法。
那么，使用匿名内部类，就可以把这个过程给给简化了，让我们更加方法的调用到实现（重写）后的方
法！
格式：

父类或者接口类型 变量名 = new 父类或者接口(){
    // 方法重写
    @Override
    public void method() {
        // 执行语句
    }
};
//调用实现（重写）后的方法
变量名.method();

匿名内部类的俩种形式：
利用一个父类，进行声明并创建匿名内部类对象，这个匿名内部类默认就是这个父类的子类型
利用一个接口，进行声明并创建匿名内部类对象，这个匿名内部类默认就是这个接口的实现类
匿名内部类因为没有类名：
匿名内部类必须依托于一个父类型或者一个接口
匿名内部类在声明的同时，就必须创建出对象，否则后面就没法创建了
匿名内部类中无法定义构造器
例如，利用父类型来声明并创建匿名内部类对象

public abstract class Animal {
    public abstract void run();
}

class Test{
    public static void main(String[] args) {
        Animal animal = new Animal(){
             @Override
             public void run() {
                System.out.println("匿名内部类中的默认实现");
             }
        };
    animal.run();
    }
}

注意，如果利用父类型声明这个匿名内部类，那么这个匿名内部类默认就是这个父类型的子类

例如，利用接口来声明并创建匿名内部类对象

public interface Action {
	void run();
}

class Test{
    public static void main(String[] args) {
        Action a = new Action(){
            @Override
            public void run() {
            	System.out.println("匿名内部类中的默认实现");
            }
        };
        a.run();
    }
}

注意，如果利用接口声明这个匿名内部类，那么这个匿名内部类默认就是这个接口的实现类

内部类的选择：
假设现在已经确定了要使用内部类，那么一般情况下，该如何选择？

考虑这个内部类，如果需要反复的进行多次使用（必须有名字）
在这个内部类中，如果需要定义静态的属性和方法，选择使用静态内部类
在这个内部类中，如果需要访问外部类的非静态属性和方法，选择使用成员内部类
考虑这个内部类，如果只需要使用一次（可以没有名字）
选择使用匿名内部类
局部内部类，几乎不会使用

包装类：针对八种基本类型提供的对应类类型

基本类型包装类型
boolean java.lang.Boolean
byte java.lang.Byte
short java.lang.Short
int java.lang.Integer
long java.lang.Long
float java.lang.Float
double java.lang.Double
char java.lang.Character

自动装箱/拆箱

JDK1.5或以上，可以支持基本类型和包装类型之间的自动装箱、自动拆箱

//JKD1.5 之前
Integer o = new Integer(1);
Integer o = Integer.valueOf(1);

//JDK1.5 之后
//自动装箱，这里会自动把数字1包装成Integer类型的对象
Integer o = 1;

//JKD1.5 之前
Integer o = new Integer(1);
int i = o.intValue();

//JDK1.5 之后
Integer o = new Integer(1);
//自动拆箱，这里会自动把对象o拆箱为一个int类型的数字，并把数字赋值给int类型的变量i
int i = o;