java内部类与单例模式

java中不允许外部类使用 private,protected 修饰

所谓的外部类:就是在源码中直接声明的类

所谓的内部类: 就是类中声明的类，内部类可以使用 public, private, protected 来修饰。

内部类

package goodStudy;
public class goodStudy{
	public static void main(String[] args) {

	}
	// 这个就是内部类，在类中声明的类
	class InnerClass{

	}
}

有的小伙伴可能就会问了，我如何使用内部类呢？

答：内部类就当成外部类的属性。从这一句我们也能够得到：

内部类可以使用 public, private, protected 来修饰。

在继续说如何使用？ 内部类就当成外部类的属性，因此，需要构建外部类对象才可以使用

这一种也是内部类

package goodStudy;

public class goodStudy{
	public static void main(String[] args) {

	}
	// 这个就是内部类，在类中声明的类
	class InnerClass{

	}
}
// 外部类
class OutClass{
	// 也是内部类
	 class InnerClass {

	}
}

内部类中也是可以使用static

有的小伙伴可能会说，之前我们有一个static，我们可以在内部类中使用static？

可以的，如果在内部类中使用static，我们叫做静态内部类

package goodStudy;

public class goodStudy{
	public static void main(String[] args) {

	}
	// 这个就是内部类，在类中声明的类
	class InnerClass{

	}
}
class OutClass{
	// 静态内部类
	static class InnerClass {
	}
}

内部类就当成外部类的属性，所以需要构建外部类对象才可以使用

public class study01 {
   public static void main(String[] args) {
   	System.out.println("main");
       // 内部类就当成外部类的属性，所以需要构建外部类对象才可以使用
       Person p = new Person();
       Person.PersonGrid PersonGrid =  p.new PersonGrid();
   }
}

// 外部类 Person
class Person {
 // 内部类 PersonGrid
   public class PersonGrid {

   }
}

私有构造，new的时候会报错

public class study01 {
	public static void main(String[] args) {
		System.out.println("main");
		// 因为下面的是私有的。所以new的时候会报错
		User p = new User(); // 报错
	}
}
class User{
  //	私有的，是有在当前类中才可以被访问
	private User (){

	}
}

protected 受保护的。在同类，同包(包路径相同)，子类中可以访问

package studyDemo9yue;
public class study01 {
	public static void main(String[] args) {
		System.out.println("main");
		// 受保护的。在同类，同包(包路径相同)，子类中可以访问
		User p = new User(); // 正常的
	}
}

class User{
  //	受保护的。在同类，同包(包路径相同)，子类中可以访问
	protected User (){

	}
}

JVM默认给类提供的构造方法，就是公共的public，无参的构造方法

类的创建过程复杂

类的对象消耗资源

成员对象，方法需要被new 才可以使用

静态方法不能直接访问成员属性，但是成员方法是可以访问静态属性。

类的对象消耗资源

package studyDemo9yue;
public class study01 {
	public static void main(String[] args) {
		System.out.println("main");
    // 创建多个实例对象， 现在这样创建的实例对象仍然是消耗内存的
		User u1 = User.getUser();
		User u2 = User.getUser();
	}
}

class User{
  //	成员方法
  private User ()  {

  };
  // 静态方法
  public static User getUser() {
	  return new User();
  }
}

单例模式

我们知道像上面那样去创建很多对象的时候；是非常消耗资源的。
现在我们希望去解决这个问题。
单例模式就出来了

package studyDemo9yue;
public class study01 {
	public static void main(String[] args) {
    // 创建多个实例对象， 现在这样创建的实例对象仍然是消耗内存的
		User u1 = User.getUser();
		User u2 = User.getUser();
    //		== 比较的是内存中的地址哈
		System.out.println(u1 == u2); // true
	}

}

class User{
  // 静态属性，为什么这里写静态属性？因为静态方法中不能获取成员属性
	private static User User = null;

  //成员方法
  private User ()  {

  };
  // 静态方法
  public static User getUser() {
	  if(User == null){
		  User=  new User();
	  }
	  return User;
  }
}