关于static class和public static class的测试记录

已于 2022-01-30 12:57:18 修改
阅读量1.1k 收藏
点赞数
分类专栏： java 源码解读 文章标签： spring java spring boot
于 2022-01-30 12:06:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hnzmdpan/article/details/122751576
版权

事情的起因，在看spring源码的时候，经常能看到一个内部类，而且，内部类用static关键字修饰。如


@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication
@Conditional(SpringBootAdminClientEnabledCondition.class)
@AutoConfigureAfter({ WebEndpointAutoConfiguration.class, RestTemplateAutoConfiguration.class,
		WebClientAutoConfiguration.class })
@EnableConfigurationProperties({ ClientProperties.class, InstanceProperties.class, ServerProperties.class,
		ManagementServerProperties.class })
public class SpringBootAdminClientAutoConfiguration {



	@Bean
	@ConditionalOnMissingBean
	public StartupDateMetadataContributor startupDateMetadataContributor() {
		return new StartupDateMetadataContributor();
	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnWebApplication(type = Type.SERVLET)
	@AutoConfigureAfter(DispatcherServletAutoConfiguration.class)
	public static class ServletConfiguration {

		@Bean
		@Lazy(false)
		@ConditionalOnMissingBean
		public ApplicationFactory applicationFactory(InstanceProperties instance, ManagementServerProperties management,
				ServerProperties server, ServletContext servletContext, PathMappedEndpoints pathMappedEndpoints,
				WebEndpointProperties webEndpoint, ObjectProvider<List<MetadataContributor>> metadataContributors,
				DispatcherServletPath dispatcherServletPath) {
			return new ServletApplicationFactory(instance, management, server, servletContext, pathMappedEndpoints,
					webEndpoint,
					new CompositeMetadataContributor(metadataContributors.getIfAvailable(Collections::emptyList)),
					dispatcherServletPath);
		}

	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnWebApplication(type = Type.REACTIVE)
	public static class ReactiveConfiguration {

		@Bean
		@Lazy(false)
		@ConditionalOnMissingBean
		public ApplicationFactory applicationFactory(InstanceProperties instance, ManagementServerProperties management,
				ServerProperties server, PathMappedEndpoints pathMappedEndpoints, WebEndpointProperties webEndpoint,
				ObjectProvider<List<MetadataContributor>> metadataContributors) {
			return new DefaultApplicationFactory(instance, management, server, pathMappedEndpoints, webEndpoint,
					new CompositeMetadataContributor(metadataContributors.getIfAvailable(Collections::emptyList)));
		}

	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnBean(RestTemplateBuilder.class)
	public static class BlockingRegistrationClientConfig {

		@Bean
		@ConditionalOnMissingBean
		public BlockingRegistrationClient registrationClient(ClientProperties client) {
			RestTemplateBuilder builder = new RestTemplateBuilder().setConnectTimeout(client.getConnectTimeout())
					.setReadTimeout(client.getReadTimeout());
			if (client.getUsername() != null && client.getPassword() != null) {
				builder = builder.basicAuthentication(client.getUsername(), client.getPassword());
			}
			return new BlockingRegistrationClient(builder.build());
		}

	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnBean(WebClient.Builder.class)
	@ConditionalOnMissingBean(RestTemplateBuilder.class)
	public static class ReactiveRegistrationClientConfig {

		@Bean
		@ConditionalOnMissingBean
		public ReactiveRegistrationClient registrationClient(ClientProperties client, WebClient.Builder webClient) {
			if (client.getUsername() != null && client.getPassword() != null) {
				webClient = webClient.filter(basicAuthentication(client.getUsername(), client.getPassword()));
			}
			return new ReactiveRegistrationClient(webClient.build(), client.getReadTimeout());
		}

	}

}

为什么要这么写？？？带着疑问，做了下测试。

package org.test.dog;

public class Dog {
	class A {
		private String p;

		public String getP() {
			return p;
		}

		public void setP(String p) {
			this.p = p;
		}
	}

	static class B {
		private String p;

		public String getP() {
			return p;
		}

		public void setP(String p) {
			this.p = p;
		}

	}

	public class C {
		private String p;

		public String getP() {
			return p;
		}

		public void setP(String p) {
			this.p = p;
		}
	}

	public static class D {
		private String p;

		public String getP() {
			return p;
		}

		public void setP(String p) {
			this.p = p;
		}
	}

	A a = new A();
	B b = new B();
	C c = new C();
	D d = new D();

}

测试的重点，分为两种，一是和 Dog同处一个包里的 InnerPackageTest，目的是为了测试Dog.A, Dog.B，因为它们没有使用public关键字。二是和Dog没有处在同一个包的里的 OutPackageTest。

内部测试类

package org.test.dog;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * 演示了内部测试（InnerPackageTest和Dog所处同一个包）。
 * 
 * @author cpp
 *
 */
public class InnerPackageTest {

	private static Integer newLine = 2;
	
	public static void main(String[] args) throws Exception, IllegalAccessException, IllegalArgumentException, InvocationTargetException, SecurityException {

		Dog a = new Dog();

		System.out.println("----------------- A测试开始");

		// new Dog.A(); //报错，编译不通过
		Dog.A a1 = a.new A();
		message("打印实例:", a1);
		message("构造器个数:", Dog.A.class.getConstructors().length);
		newLIne(newLine);

		System.out.println("----------------- B测试开始");
		//
		Dog.B b = new Dog.B();
		b.setP("");
		message("构造器个数:", Dog.B.class.getConstructors().length);
		message("打印实例:", b);

		newLIne(newLine);

		System.out.println("----------------- C测试开始");
		//
		Dog.C c = a.new C();
		message("打印实例:", c);
		// new Dog.C();// 报错
		message("构造器个数:", Dog.C.class.getConstructors().length);
		Constructor[] cs = Dog.C.class.getConstructors();
		for (int i = 0; i < cs.length; i++) {
			message("构造器的样子:", cs[i].toGenericString());
		}
		Object c2 = Dog.C.class.getConstructors()[0].newInstance(a);
		message("反射出来的对象", c2.toString());

		newLIne(newLine);

		System.out.println("----------------- D测试开始");
		Dog.D d = new Dog.D();
		message("打印实例:", d);
		message("构造器个数:", Dog.D.class.getConstructors().length);
		cs = Dog.D.class.getConstructors();
		for (int i = 0; i < cs.length; i++) {
			message("构造器的样子:", cs[i].toGenericString());
		}
		Object d2 = Dog.D.class.getConstructors()[0].newInstance();
		message("反射出来的对象", d2.toString());
	}

	public static void message(Object... args) {
		for (int i = 0; i < args.length; i++) {
			System.out.print(args[i] + "\t");
		}
		System.out.println();
	}

	public static void newLIne(int newLIne) {
		for (int i = 1; i <= newLIne; i++) {
			System.out.println();
		}
	}
}

输出的结果为

----------------- A测试开始
打印实例:	org.test.dog.Dog$A@61f8bee4	
构造器个数:	0	


----------------- B测试开始
构造器个数:	0	
打印实例:	org.test.dog.Dog$B@7b49cea0	


----------------- C测试开始
打印实例:	org.test.dog.Dog$C@887af79	
构造器个数:	1	
构造器的样子:	public org.test.dog.Dog$C(org.test.dog.Dog)	
反射出来的对象	org.test.dog.Dog$C@7fac631b	


----------------- D测试开始
打印实例:	org.test.dog.Dog$D@5b87ed94	
构造器个数:	1	
构造器的样子:	public org.test.dog.Dog$D()	
反射出来的对象	org.test.dog.Dog$D@6e0e048a

 外部测试类

package org.test.cat;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

import org.test.dog.Dog;

/**
 * 演示了外部测试（OutPackageTest和Dog，没有在同一个包内）。
 * 
 * @author cpp
 *
 */
public class OutPackageTest {

	private static Integer newLine = 2;
	
	public static void main(String[] args) throws Exception, IllegalAccessException, IllegalArgumentException, InvocationTargetException, SecurityException {

		Dog a = new Dog();

		System.out.println("----------------- A测试开始");

		// new Dog.A(); //报错，编译不通过
//		Dog.A a1 = a.new A();// 报错，编译不通过
//		message("打印实例:", a1);
//		message("构造器个数:", Dog.A.class.getConstructors().length);
		newLIne(newLine);

		System.out.println("----------------- B测试开始");
		//
//		Dog.B b = new Dog.B(); //报错，编译不通过
//		b.setP("");
//		message("构造器个数:", Dog.B.class.getConstructors().length);
//		message("打印实例:", b);

		newLIne(newLine);

		System.out.println("----------------- C测试开始");
		//
		Dog.C c = a.new C();
		message("打印实例:", c);
		// new Dog.C();// 报错
		message("构造器个数:", Dog.C.class.getConstructors().length);
		Constructor[] cs = Dog.C.class.getConstructors();
		for (int i = 0; i < cs.length; i++) {
			message("构造器的样子:", cs[i].toGenericString());
		}
		Object c2 = Dog.C.class.getConstructors()[0].newInstance(a);
		message("反射出来的对象", c2.toString());

		newLIne(newLine);

		System.out.println("----------------- D测试开始");
		Dog.D d = new Dog.D();
		message("打印实例:", d);
		message("构造器个数:", Dog.D.class.getConstructors().length);
		cs = Dog.D.class.getConstructors();
		for (int i = 0; i < cs.length; i++) {
			message("构造器的样子:", cs[i].toGenericString());
		}
		Object d2 = Dog.D.class.getConstructors()[0].newInstance();
		message("反射出来的对象", d2.toString());
	}

	public static void message(Object... args) {
		for (int i = 0; i < args.length; i++) {
			System.out.print(args[i] + "\t");
		}
		System.out.println();
	}

	public static void newLIne(int newLIne) {
		for (int i = 1; i <= newLIne; i++) {
			System.out.println();
		}
	}
}

输出的结果为

----------------- A测试开始


----------------- B测试开始


----------------- C测试开始
打印实例:	org.test.dog.Dog$C@61f8bee4	
构造器个数:	1	
构造器的样子:	public org.test.dog.Dog$C(org.test.dog.Dog)	
反射出来的对象	org.test.dog.Dog$C@7b49cea0	


----------------- D测试开始
打印实例:	org.test.dog.Dog$D@887af79	
构造器个数:	1	
构造器的样子:	public org.test.dog.Dog$D()	
反射出来的对象	org.test.dog.Dog$D@7fac631b

总结一下，学习到的内容。

1、内部类A，B，由于没有使用修饰符，则默认的范围为包级别，这一点不变。

2、内部类A，B，在同一个包里被引用的时候，不能直接new，而是要通过Dog的实例对象来new。通过获取到的构造器个数来看，数量为0，也证实了这一点。

3、内部类C，如果只加了public，而不是public static时，根据获取的造造器来看，是有一个Dog参数的，所以，内部类C，虽然有public关键字，也是不能直接new。

4、内部类D，是通过public static 关键字来修饰的，进一步观察构造器，和普通的类（一个文件一个类，且是public级的）没有任何区别，所以，能够在包外直接new。

5、不能用static修饰顶级类Dog，只有内部类可以为static。

伤脑脑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的Static class详解及实例代码
08-31
public static class NestedStaticClass { public void printMessage() { System.out.println("Message from nested static class: " + msg); } } // 非静态内部类 public class InnerClass { public void...
JS中的public和private对象,即static修饰符
10-28
先看下面的例子,它将告诉我们在JS世界中也有C#里的public , private ,及static等
静态内部类(public static class)和普通内部类(public class)的区别
我是guyue，guyue就是我O(∩_∩)O
03-26 1万+
public static class和public class的区别 新学的java知识，静态类，使用static关键字修饰的类（public static class） 今天在看别人源码的时候看到了一个新知识。使用static关键字修饰的类。 java中普通的顶级类是不能使用static关键字修饰的。 只有内部类可以使用static修饰，或者不使用s...
public static class和public class的区别 和builder模式
usstmiracle的博客
01-18 1万+
链接：https://www.jianshu.com/p/749fbd9879cf https://blog.csdn.net/gengqiquan/article/details/52764455    （builder模式） 新学的java知识，静态类，使用static关键字修饰的类（public static class） 今天在看别人源码的时候看到了一个新知识。使用static关键字...
Java中的static和public关键字使用
weixin_43716412的博客
04-23 3185
在Java中，static关键字可以用来修饰类的成员变量、方法和代码块，它的作用是将这些成员标记为静态的，即与类相关而不是与类的实例相关。使用static关键字可以在不创建类的实例的情况下访问类的成员变量和方法。以下是static关键字的用法：静态变量也称为类变量，它们属于类而不是属于任何特定的实例。使用static关键字声明的变量只有一个副本，无论创建多少个类的实例，它们都共享这个变量。静态变量可以通过类名直接访问，例如： 可以通过来访问变量。静态方法属于类而不属于任何特定的实例。使用static关键字声
什么时候会用到public static class
enthan809882的博客
12-28 1470
这个主要用在内部类中，例如A类中有个内部类C，代码： public class A { public static class C{ public static void c_method(){ } } } public static 既可见，又静态。代码： new A.C(); // 不加static就需要 new A().new C()...
java中staticclass静态类详解
08-28
Java 中的静态类（Static Class）详解 Java 中的静态类是一种特殊的内部类，它可以被定义在外部类中，并且可以使用 static 关键字来修饰。静态内部类的使用可以带来很多便利，但是也存在一些限制。 静态内部类的...
深入浅析Java中Static Class及静态内部类和非静态内部类的不同
09-03
public static class NestedStaticClass { public void printMessage() { System.out.println("Message from nested static class: " + msg); } } // 非静态内部类 public class InnerClass { public void ...
java中public class与class区别
01-20
在编写类的时候可以使用两种方式定义类： 　public class定义类： 　class定义类： ... public static void main(String args[]){ //主方法 System.out.println(HelloWorld!!!); //系统输出，在屏幕上打印
Java内部类以及内部类与静态内部类的区别
weixin_58724261的博客
06-01 168
在Java编程中，内部类是将一个类定义在另一个类的内部，形成类的嵌套结构。内部类可以访问其所在外部类的成员，包括私有成员，并且可以对外部类对象拥有控制权，从而提供更加灵活和封装的设计方式。
public static
05-23 3104
static：静态。   可以设置：静态类、静态变量、静态方法。   没有使用static修饰的成员为实例成员。 静态成员的使用：通过类名。   1。不加static修饰的成员是对象成员，归每个对象所有。 2。加static修饰的成员是类成员，可以由一个类直接调用，为所有对象共有。 用static关键字标识的程序元素是静态的,不用static标识的程序元素是非静态. 两
Java中static class使用方式
热门推荐
淡淡的博客
09-03 3万+
java允许在一个类里面定义静态类。如内部类（nested class）。 在java中，不能用static修饰顶级类（top level class）。只有内部类可以为static。 静态内部类和非静态内部类之间区别: 1. 内部静态类不需要有指向外部类的引用。但非静态内部类需要。 2. 静态类只能访问外部类的静态成员，非静态内部类能够访问外部类的静态和非静态成员。 3. 非...
静态类与非静态类
似水流年
04-25 2837
静态类     静态类与非静态类的重要区别在于静态类不能实例化，也就是说，不能使用 new 关键字创建静态类类型的变量。在声明一个类时使用static关键字，具有两个方面的意义：首先，它防止程序员写代码来实例化该静态类；其次，它防止在类的内部声明任何实例字段或方法。     静态类是自C# 2.0才引入的，C# 1.0不支持静态类声明。程序员必须声明一个私有构造器。私有构造器禁止开发者
C#Static用法大汇总
mituan1234567的专栏
08-06 479
C#Static用法大汇总   2010-05-06 12:11:20|  分类： c# |字号 订阅   静态变量        当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。        有时候，我们希望无论是否产生了对象或无
Java 中 Static class 与non static class的区别
Fuge的博客
10-27 3628
外部类只能使用public、final、abstract修饰，不能使用private、protected、static修饰，但是内部类可以。非静态内部类不能拥有静态成员。 内部类的作用：①不允许同包的其他类访问该类；②内部类成员可以直接访问外部类私有数据；③匿名内部类适合用于创建那些仅需要使用一次的类。 非静态内部类可以访问外部类的private成员，但非静态内部类的成员不能被外部类直接使用，
java 计算数组平均值 用public class 和public static
最新发布
06-02
使用 `public class` 和 `public static` 可以将代码封装成一个静态方法，方便在其他地方调用。 以下是使用 `public class` 和 `public static` 计算数组平均值的代码： ```java public class CalcAverage { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值