浅析总结 Java 内部类的一些使用与梳理

最新推荐文章于 2023-02-10 10:51:07 发布
最新推荐文章于 2023-02-10 10:51:07 发布
阅读量321 收藏
点赞数

序

有这篇文章，纯属巧合；那天在使用中突然发现 Java 内部类中还分 static ，说实话平时都在用，但是就是没有注意到；感觉有必要总结一下。

有必要说一下的是本文纯属浅析，如有补充还请在评论中指出，欢迎总结。

内部类的位置

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class A { 
  2.     class B { 
  3.  
  4.     } 
  5.  
  6.     public void pint() { 
  7.         class C { 
  8.         } 
  9.         new C(); 
  10.     } 
  11.  
  12.     public void pint(boolean b) { 
  13.         if (b) { 
  14.             class D { 
  15.             } 
  16.             new D(); 
  17.         } 
  18.     } 
  19. }  
public class A {
	class B {

	}

	public void pint() {
		class C {
		}
		new C();
	}

	public void pint(boolean b) {
		if (b) {
			class D {
			}
			new D();
		}
	}
}
从代码中可以看出，内部类可以定义到很多地方，常用的是成员变量中 （B），方法中也叫局部内部类 （C），作用域中 （D）

从上面来看似乎没有用到过在方法中和作用域中的情况啊，这就错了；再来看看这个：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public interface AInterface { 
  2.     void show(); 
  3. } 
  4. public class B { 
  5.  
  6.     public void show() { 
  7.         class Man implements AInterface { 
  8.             @Override 
  9.             public void show() { 
  10.  
  11.             } 
  12.  
  13.         } 
  14.         Man man = new Man(); 
  15.         man.show(); 
  16.     } 
  17.  
  18. }  
public interface AInterface {
	void show();
}
public class B {

	public void show() {
		class Man implements AInterface {
			@Override
			public void show() {

			}

		}
		Man man = new Man();
		man.show();
	}

}
其中我们定义了两个文件，一个文件是一个接口类，一个是 B文件；在 B类中，的 show()方法中我们使用了局部内部类的方式创建了类 Man ， Man class继承接口并实现方法，随后使用该类。

内部类的权限

为什么要有内部类的存在？

在我看来类主要的就是封装、继承、多态；当然其中的回调思想我认为是很重要的；而内部类的出现就是为了简化多重继承的问题；一个A类，并不能继承多个其他类，但是在使用中又需要使用到其他类的方法，这个时候内部类就发挥作用了；典型的就是事件点击的回调实现。

那么内部类的权限究竟有多大？

至于答案是什么，代码上看看就知道了。

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class C { 
  2.     int a = 1; 
  3.     private int b = 2; 
  4.     protected int c = 3; 
  5.     public int d = 4; 
  6.  
  7.     void a() { 
  8.         System.out.println("A:" + a); 
  9.     } 
  10.  
  11.     private void b() { 
  12.         System.out.println("B:" + b); 
  13.     } 
  14.  
  15.     protected void c() { 
  16.         System.out.println("C:" + c); 
  17.     } 
  18.  
  19.     public void d() { 
  20.         System.out.println("D:" + d); 
  21.     } 
  22.  
  23.     class D { 
  24.  
  25.         void show() { 
  26.             int max = a + b + c + d; 
  27.             a(); 
  28.             b(); 
  29.             c(); 
  30.             d(); 
  31.             System.out.println("Max:" + max); 
  32.         } 
  33.     } 
  34.  
  35.     public static void main(String[] args) { 
  36.         D d = new C().new D(); 
  37.         d.show(); 
  38.     } 
  39. }  
public class C {
	int a = 1;
	private int b = 2;
	protected int c = 3;
	public int d = 4;

	void a() {
		System.out.println("A:" + a);
	}

	private void b() {
		System.out.println("B:" + b);
	}

	protected void c() {
		System.out.println("C:" + c);
	}

	public void d() {
		System.out.println("D:" + d);
	}

	class D {

		void show() {
			int max = a + b + c + d;
			a();
			b();
			c();
			d();
			System.out.println("Max:" + max);
		}
	}

	public static void main(String[] args) {
		D d = new C().new D();
		d.show();
	}
}
运行结果：


可以看出，内部类 D 对类 C 具有完整的访问权限，等于全身脱光了给你看。

那要是反过来呢？

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class C { 
  2.     class D { 
  3.         private int a = 20; 
  4.         private void a(){ 
  5.             System.out.println("D.A:" + a); 
  6.         } 
  7.     } 
  8.      
  9.     void show(){ 
  10.         D d = new D(); 
  11.         d.a(); 
  12.          
  13.         System.out.println("D.A:" + d.a); 
  14.     } 
  15.  
  16.     public static void main(String[] args) { 
  17.         new C().show(); 
  18.     } 
  19. }  
public class C {
	class D {
		private int a = 20;
		private void a(){
			System.out.println("D.A:" + a);
		}
	}
	
	void show(){
		D d = new D();
		d.a();
		
		System.out.println("D.A:" + d.a);
	}

	public static void main(String[] args) {
		new C().show();
	}
}
运行结果：


可见也是完全可行的，也能直接访问私有属性 私有方法，在这里似乎私有的限制已经失效了一般，这个让我想起了以前看见过一个面试：在 Java 中 private 修饰何时会失效。

这完全是两个人互相脱光光了啊~

匿名内部类

这个非常常见，特别是在按钮点击事件绑定中。

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class D { 
  2.     void initButton() { 
  3.         Button b1 = new Button(); 
  4.         b1.setOnClickListener(new OnClickListener() { 
  5.  
  6.             @Override 
  7.             public void onClick(Button v) { 
  8.  
  9.             } 
  10.         }); 
  11.  
  12.         Button b2 = new Button(); 
  13.         b2.setOnClickListener(new OnClickListener() { 
  14.  
  15.             @Override 
  16.             public void onClick(Button v) { 
  17.  
  18.             } 
  19.         }); 
  20.     } 
  21.  
  22. }  
public class D {
	void initButton() {
		Button b1 = new Button();
		b1.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(Button v) {

			}
		});

		Button b2 = new Button();
		b2.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(Button v) {

			}
		});
	}

}
其中的：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1.   new OnClickListener() { 
  2.  
  3.     @Override 
  4.     public void onClick(Button v) { 
  5.  
  6.     } 
  7. }  
    new OnClickListener() {

			@Override
			public void onClick(Button v) {

			}
		}
就是匿名内部类的使用方式，OnClickListener 是一个接口类，接口类是无法直接new 一个实例的；这里也并不是那样，而是new 了一个其他的类，该类是匿名的，也就是没有名字，只不过该类实现了 OnClickListener接口类中的方法。

上面的添加回调部分可等同于：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class D { 
  2.     void initButton1() { 
  3.         Button b1 = new Button(); 
  4.         b1.setOnClickListener(new Listener1()); 
  5.  
  6.         Button b2 = new Button(); 
  7.         b2.setOnClickListener(new Listener2()); 
  8.     } 
  9.  
  10.     class Listener1 implements OnClickListener { 
  11.  
  12.         @Override 
  13.         public void onClick(Button v) { 
  14.  
  15.         } 
  16.     } 
  17.  
  18.     class Listener2 implements OnClickListener { 
  19.  
  20.         @Override 
  21.         public void onClick(Button v) { 
  22.  
  23.         } 
  24.     } 
  25.  
  26. }  
public class D {
	void initButton1() {
		Button b1 = new Button();
		b1.setOnClickListener(new Listener1());

		Button b2 = new Button();
		b2.setOnClickListener(new Listener2());
	}

	class Listener1 implements OnClickListener {

		@Override
		public void onClick(Button v) {

		}
	}

	class Listener2 implements OnClickListener {

		@Override
		public void onClick(Button v) {

		}
	}

}
这里就是先建立类，继承自接口；而后赋值到 Button 中。

要说两者的区别与好处，这个其实看具体的使用情况吧；如果你的按钮很多，但是为了避免建立太多类；那么可以建立一个回调类，然后都赋值给所有的按钮，不过最后就是需要在 onClick方法中进行判断是那个按钮进行的点击。

匿名内部类的使用地方很多；具体的使用应视使用情况而定~

静态内部类/静态嵌套类

这个其实并不应该叫做内部类了，因为其并不具备内部类的完全权限，在使用上与一般的类基本一样；那为什么会有这个的存在？

在我看来这个类的存在是为其包括类服务；意思是可以单独服务，不被外面的类所知晓；如这样：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class E { 
  2.     private void show(){ 
  3.         new A(); 
  4.     } 
  5.      
  6.     private static class A{ 
  7.          
  8.     } 
  9. }  
public class E {
	private void show(){
		new A();
	}
	
	private static class A{
		
	}
}
其中类 A 使用了 static ，所以是 静态嵌套类，在这里使用 private 修饰；那么该类只能在 E 类中进行实例化；无法在 其他文件中实例化。

这样的情况使用外面的类能行么？不行吧？也许你会说在 E.java 文件夹中建立 A.java ，并使用protected修饰；但是在同样的包下，或者继承的类中同样能访问了；这也只是其中一个较为特殊的情况。

我们来看看权限

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class E { 
  2.     int a1 = 0; 
  3.     private int a2 = 0; 
  4.     protected int a3 = 0; 
  5.     public int a4 = 0; 
  6.      
  7.     private void show(){ 
  8.         A a =new A(); 
  9.         System.out.print("b1:"+a.b1); 
  10.         System.out.print("b2:"+a.b2); 
  11.         System.out.print("b3:"+a.b3); 
  12.         System.out.print("b4:"+a.b4); 
  13.          
  14.     } 
  15.      
  16.     private static class A{ 
  17.         int b1 = 0; 
  18.         private int b2 = 0; 
  19.         protected int b3 = 0; 
  20.         public int b4 = 0; 
  21.          
  22.         private void print(){ 
  23.             System.out.print("a1:"+a1); 
  24.             System.out.print("a2:"+a2); 
  25.             System.out.print("a3:"+a3); 
  26.             System.out.print("a4:"+a4); 
  27.  
  28.         } 
  29.     } 
  30. }  
public class E {
	int a1 = 0;
	private int a2 = 0;
	protected int a3 = 0;
	public int a4 = 0;
	
	private void show(){
		A a =new A();
		System.out.print("b1:"+a.b1);
		System.out.print("b2:"+a.b2);
		System.out.print("b3:"+a.b3);
		System.out.print("b4:"+a.b4);
		
	}
	
	private static class A{
		int b1 = 0;
		private int b2 = 0;
		protected int b3 = 0;
		public int b4 = 0;
		
		private void print(){
			System.out.print("a1:"+a1);
			System.out.print("a2:"+a2);
			System.out.print("a3:"+a3);
			System.out.print("a4:"+a4);

		}
	}
}
在这个中的结果是怎样？


从图片中可以看出，其权限级别是单方向的；静态嵌套类 A 对其包含类 E 完全透明；但 E 并不对 A 透明。

再来看看方法：


可以看出同样的情况；这个是为什么呢？为什么就是多一个 static 的修饰就这么完全不同？其是很好理解，两个独立的类；本来就无法直接使用，必须有引用才能调用其属性与方法。

我们或许可以这么调整一下就OK：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class E { 
  2.     int a1 = 0; 
  3.     private int a2 = 0; 
  4.     protected int a3 = 0; 
  5.     public int a4 = 0; 
  6.  
  7.     private void show() { 
  8.         A a = new A(); 
  9.         System.out.print("b1:" + a.b1); 
  10.         System.out.print("b2:" + a.b2); 
  11.         System.out.print("b3:" + a.b3); 
  12.         System.out.print("b4:" + a.b4); 
  13.  
  14.         a.b1(); 
  15.         a.b2(); 
  16.         a.b3(); 
  17.         a.b4(); 
  18.     } 
  19.  
  20.     void a1() { 
  21.  
  22.     } 
  23.  
  24.     private void a2() { 
  25.  
  26.     } 
  27.  
  28.     protected void a3() { 
  29.  
  30.     } 
  31.  
  32.     public void a4() { 
  33.  
  34.     } 
  35.  
  36.     private static class A { 
  37.         int b1 = 0; 
  38.         private int b2 = 0; 
  39.         protected int b3 = 0; 
  40.         public int b4 = 0; 
  41.  
  42.         void b1() { 
  43.  
  44.         } 
  45.  
  46.         private void b2() { 
  47.  
  48.         } 
  49.  
  50.         protected void b3() { 
  51.  
  52.         } 
  53.  
  54.         public void b4() { 
  55.  
  56.         } 
  57.  
  58.         private void print(E e) { 
  59.             System.out.print("a1:" + e.a1); 
  60.             System.out.print("a2:" + e.a2); 
  61.             System.out.print("a3:" + e.a3); 
  62.             System.out.print("a4:" + e.a4); 
  63.  
  64.             e.a1(); 
  65.             e.a2(); 
  66.             e.a3(); 
  67.             e.a4(); 
  68.         } 
  69.     } 
  70. }  
public class E {
	int a1 = 0;
	private int a2 = 0;
	protected int a3 = 0;
	public int a4 = 0;

	private void show() {
		A a = new A();
		System.out.print("b1:" + a.b1);
		System.out.print("b2:" + a.b2);
		System.out.print("b3:" + a.b3);
		System.out.print("b4:" + a.b4);

		a.b1();
		a.b2();
		a.b3();
		a.b4();
	}

	void a1() {

	}

	private void a2() {

	}

	protected void a3() {

	}

	public void a4() {

	}

	private static class A {
		int b1 = 0;
		private int b2 = 0;
		protected int b3 = 0;
		public int b4 = 0;

		void b1() {

		}

		private void b2() {

		}

		protected void b3() {

		}

		public void b4() {

		}

		private void print(E e) {
			System.out.print("a1:" + e.a1);
			System.out.print("a2:" + e.a2);
			System.out.print("a3:" + e.a3);
			System.out.print("a4:" + e.a4);

			e.a1();
			e.a2();
			e.a3();
			e.a4();
		}
	}
}
在其静态类中传递一个 E 的引用进去就能解决问题了：


可以看出其中现在并没有报错了；能正常运行。

两者之间的隐藏区别

但是最开始上面的内部类是怎么回事？难道是闹鬼了？上面的内部类没有传递引用的啊；为啥加上一个 static 就不行了？

在这里我们需要看看字节码，我们先建立一个简单的内部类：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class F { 
  2.      
  3.     class A{ 
  4.          
  5.     } 
  6. }  
public class F {
	
	class A{
		
	}
}
这个够简单吧？别说这个都难了；汗~

然后我们找到 class 文件，然后查看字节码：

在这里分别查看了 F 类的字节码和 F$A 类的字节码。

其中有这样的一句： final F this$0; 这句是很重要的一句，这句出现的地方在其内部类中，意思是当你 new 一个内部类的时候就同时传递了当前类进去；所以在内部类中能具有当前类的完全权限，能直接使用所有的东西；就是因为在隐藏情况下已经传递了当前类进去。

那么我们再看看一个简单的静态内部类：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class G { 
  2.     static class A { 
  3.  
  4.     } 
  5. }  
public class G {
	static class A {

	}
}
与上面的区别唯一就是在于添加了一个 static 。此时我们看看字节码：



可以看出其中无论是 G 类，还是 G$A 类的初始化中都没有其他多余的部分，也没有进行隐藏的传递进去当前类；所以这样的情况下并不具备访问权限，需要我们传递引用进去，可以通过接口也可以完全传递进去，具体取决于个人。所以加了static类的内部类除了在权限上比一般的类更加开放（与其包含类）外，与一般的类在使用上是一样的；所以准确的说应该叫做静态嵌套类。

初始化的区别

一个类中，同时包含了内部类与静态内部类，那么其初始化应该是怎么样的呢？

都是直接 new ？还是看看代码：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class H { 
  2.     int a = 1; 
  3.  
  4.     public class A { 
  5.         public void Show() { 
  6.             System.out.print("a:" + a); 
  7.         } 
  8.     } 
  9.  
  10.     public static class B { 
  11.         public void Show(H h) { 
  12.             System.out.print("a:" + h.a); 
  13.         } 
  14.     } 
  15.  
  16.     public static void main(String[] args) { 
  17.         H h = new H(); 
  18.         //A a = new A(); 
  19.         A a1 = h.new A(); 
  20.         B b = new B(); 
  21.         //B b1 = h.new B(); 
  22.         B b3 = new H.B(); 
  23.     } 
  24. }  
public class H {
	int a = 1;

	public class A {
		public void Show() {
			System.out.print("a:" + a);
		}
	}

	public static class B {
		public void Show(H h) {
			System.out.print("a:" + h.a);
		}
	}

	public static void main(String[] args) {
		H h = new H();
		//A a = new A();
		A a1 = h.new A();
		B b = new B();
		//B b1 = h.new B();
		B b3 = new H.B();
	}
}
其中注释了的两种方式是不允许的方式，也就是无法正常运行。

A 因为有一个隐藏的引用，所以必须是H 的实例才能进行初始化出A 类；而B 类则是因为是在H 类中以静态方式存在的类，所以需要 new H.B()；之所以能直接使用new B()，与该 main 方法在 H 类中有关，因为本来就在 H类中，所以直接使用 H类的静态属性或者方法可以不加上：“H.”  在前面。

内部类的继承

直接继承的情况：


可以看出报错了，为什么？因为需要传递一个 H 类进去，所以我们在继承的时候需要显示的指明：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class I extends H.A{ 
  2.     public I(H h){ 
  3.         h.super(); 
  4.     } 
  5. }  
public class I extends H.A{
	public I(H h){
		h.super();
	}
}
也就是在构造方法中，传递一个 H 的引用进去，并调用 H 实例的 super() 方法，才能进行实例化。
使用的话应该这样：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public static void main(String[] args) { 
  2.        H h = new H(); 
  3.        I i = new I(h); 
  4.    }  
	public static void main(String[] args) {
        H h = new H();
        I i = new I(h);
    }

而，如果是继承其静态嵌套类，则不需要这样：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class J extends H.B{ 
  2.  
  3. }  
public class J extends H.B{

}
就这样就OK。

哎，差不多了~~整个内部类的东西差不多就是这些了，写了我3个小时42分钟~汗！！！！

如果有没有写到的地方，还请补充~~

不对的地方还请指正~

noprvjau
关注
Java中内部类的使用总结
weixin_42098295的博客
01-21 842
局部内部类主要用于实现那些仅在某个方法或作用域内使用的类，以及在需要实现或继承特定接口或类且其使用非常局限的情况下。静态内部类在Java中的应用场景包括逻辑分组（将相关的类组织在一起），封装（隐藏内部类的细节，保持外部类的清洁接口），以及减少内存占用（静态内部类不持有对外部类实例的引用）。非静态内部类，也就是成员内部类，是定义在另一个类内部的非静态类。这种内部类与外部类之间有着密切的联系，它可以访问外部类的所有成员（包括私有成员），同时外部类也可以访问内部类的所有成员（包括私有成员）。
Java 内部类使用详解
deziko
01-25 205
这个系列是帮助复习 Java 的基础知识的，但是并不会按照一个特定的顺序。现在开始复习下内部类的相关知识。 0. 简介 内部类的定义很简单，它其实就是在一个类里面定义了另一个类，但是这个定义还是有很多细节需要掌握的。 1. 非静态内部类 1.1 定义 非静态内部类就是在一个类的内部里面定义了一个没有用 static 修饰的类。 1.2 访问控制符 内部类的访
java 内部类使用（内部匿名类）
12-12
java 成员内部类使用 内部匿名类 方法参数匿名类 方法匿名类
java中内部类的使用
qq_45760909的博客
06-10 209
package 内部类; /* 什么是内部类，在一个类中又定义了一个类 ： 内部类的规则： 1，内部类可以直接方法外部类的成员，包括私有。 2，外部类要访问内部类，必须建立内部类对象 在内部类中 内部类可以被私有 什么时候用： 当描述事物时，事物的内部还有事物，该事物用内部类来描述。 因为内部事物在 使用外部事物的内容 */ class A{ private int num = 4; cla
Java中内部类使用
nuist_NJUPT的博客
05-21 345
Java中内部类使用 Java语言允许在一个类的内部定义另一个类(接口，枚举或注解)， 这种类称为内部类或者嵌套类，允许内部类的目的是增强两个类之间的联系，并且可以使程序代码清晰简介 有多种类型的内部类，大致可以分为：成员内部类，局部内部类，匿名内部类和静态内部类 成员内部类是没有用static修饰且定义在外层类的类体中 成员内部类中不能定义static变量和static方法 成员内部类中可以使用abstract和final修饰 成员内部类还可以使用private,public,protected等访问
Java内部类、静态内部类、私有内部类、匿名内部类
微风吹过李子树的博客
11-29 676
内部类: 类中定义类 当一个类中的成员也是另外一个事物的时候,这个事物就可以使用内部类定义 分类: 成员内部类 静态内部类 局部内部类 私有内部类 匿名内部类 ** 成员内部类: 内部类处于外部类的成员位置 是外部的成员,就可以使用成员修饰符 是个类,有类的特性,继承,实现接口… 注意: 内部类中可以使用外部类中所有的内容,包括私有的 除了静态内部类以外的内部类中不可以定义静态的内容,除...
java-补充学习(1)
Mar.三月
09-02 479
一 。一些不熟悉的java基础，学习下 lambda表达式 https://www.zhihu.com/question/20125256lambda表达式理解上有问题，不过他是锦上添花，java8新特性，不太捉急，先放着，本来就是用来写简化优雅代码用的 内部类 内部类，也不是特别常用，即使不会，一时半会不影响，先放着 ...
Java学习专栏！全网最牛！
weixin_70730532的博客
08-12 2621
00254:《SpringCloud Alibaba微服务实战十四 - SpringCloud Gateway集成Oauth2.0》00242:《SpringCloud Alibaba微服务实战二十四 - SpringCloud Gateway的全局异常处理》00251:《SpringCloud Alibaba微服务实战十五 - SpringCloud 容器化部署》00248:《SpringCloud Alibaba微服务实战十八 - Oauth2.0 自定义授权模式》00184:《TCP网络那点破事！..
Android系统启动流程及其路径浅析
hejnhong的博客
12-27 2060
Android 系统启动流程相关的文章很多，但初次学习查阅的过程中，总是找不到相关文件的路径以及调用的过程。因此本文旨在梳理出 Android 系统启动过程中的主干节点，理清整个过程中的方法调用和相关文件路径。正文基本按照系统的启动过程来排布，在此分享一个Android 源码在线查看工具，本文的代码都来源于此。http://aospxref.com/ 1 BootLoader 1.1 加载 BootLoader 在关机状态下，Android 系统是存放在 ROM 中，而系统的运行是在 RAM中，因此有将 系
基于java的网上宠物销售商城设计(含源文件)
【完整】
03-04 4854
欢迎添加微信互相交流学习哦！ 项目源码：https://gitee.com/oklongmm/biye 毕业设计论文 基于JSP的网上宠物销售商城 摘 要 随着近年来中国经济的快速发展，人民水平的提高。人们的购物需求日益剧增，与传统购物销售不同的是，网上商城是当下最热门的方式。 为满足用户需求，实现一个基于JSP技术和MySQL数据库技术开发的购物销售系统。本系统基于B/S模式，采用SSH框架，使用MVC架构设计而成。在设计过程中，借鉴国内外优秀网站的设计，网站界面简洁、大方，便于用户操..
RecyclerView源码浅析之数据更改与动画
chengkun_123的博客
07-11 1527
概述上一篇我们针对RecyclerView的绘制流程做了简单的分析，重点放在了dispatchLayoutStep2()这个真正对子View操作的函数上，它完成了：子View的添加（LinearLayoutManager通过ChildHelper添加）、测量、布局。绘制流程虽然有了大概的了解，但却引出了很多问题：dispatchLayoutStep1()和dispatchLayoutStep3()有
java内部类的使用
ljf12138的博客
12-17 103
图片+桌面文档
java各内部类的使用
最新发布
m0_73668562的博客
02-10 214
java内部类使用
java内部类的用法
菜鸟一缕清风的博客
05-30 279
内部类共分４种：常规内部类、静态内部类、局部内部类、匿名内部类 １．常规内部类：常规内部类没有用static修饰且定义在在外部类类体中。 - 常规内部类中的方法可以直接使用外部类的实例变量和实例方法。 - 在常规内部类中可以直接用内部类创建对象 public class OuterClass { private int x = 100; ...
JAVA内部类简单使用
user2025的博客
10-08 171
文章目录成员内部类局部内部类匿名内部类实际就是内部类简化写法，只要存在一个类或接口就可以使用类中定义接口 内部类：一个类的内部定义的类 外部类：拥有内部类的类 成员内部类又分为静态成员内部内和非静态成员内部类 局部内部类可以位于方法内、块内、构造器内 成员内部类：分为成员内部类和局部内部类 成员内部类 （1） 成员内部类可以访问外部类的所有内容，包括静态和非静态的都可以访问 （2）静态成员内部类只能访问外部类的静态成员、静态方法，因为静态内部类是不依赖实例对象的，即便实例对象不存在也能运行，因此静态的只能访
Java中内部类的使用方法
m0_37134868的博客
09-01 1248
首先创建两个类，Animal、Demo类： Animal： public class Animal { private int num=9; public class Inner{ //内部类 public void show(){ //内部中show方法 System.out.println(num); } } public void method(){ //Animal类调用show()方法
Java---内部类的定义与用法
X_H学Java的博客
09-16 1186
目录 一. 内部类概述 二. 成员内部类 2.1 普通内部类 2.2 静态内部类 三. 局部内部类 四.匿名类 五.对象的打印 一. 内部类概述 内部类是定义在另一个类中的类，内部类也是封装的一种的体现。为什么要使用内部类，主要有两个原因： · 内部类可以对同一个包的其他类进行隐藏。 · 内部类方法可以访问定义这个类的作用域中的数据，包括原本私有的数据。 格式： public class OutClass { class InnerClass { ...
浅析Java深浅复制原理与实现
总结来说，Java中的深复制与浅复制主要体现在对对象和其引用对象的处理上。浅复制适用于简单对象，而深复制则适合于复杂对象，特别是当对象内部包含引用类型数据时。理解并掌握这两种复制方式对于正确处理数据复制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值