class Singleton{
private Singleton(){ // 将构造方法进行了封装，私有化
}
public void print(){
System.out.println("Hello World!!!") ;
}
};class Singleton{
private Singleton(){ // 将构造方法进行了封装，私有化
}
public void print(){
System.out.println("Hello World!!!") ;
}
};
public class SingletonDemo02{
public static void main(String args[]){
Singleton s1 = null ; // 声明对象
s1 = new Singleton() ; // 错误，无法实例化对象
}
};class Singleton{
Singleton instance = new Singleton() ; // 在内部产生本类的实例化对象
private Singleton(){ // 将构造方法进行了封装。私有化
}
public void print(){
System.out.println("Hello World!!!") ;
}
};
public class SingletonDemo03{
public static void main(String args[]){
Singleton s1 = null ; // 声明对象
}
};例如以下所看到的：
class Singleton{
static Singleton instance = new Singleton() ; // 在内部产生本类的实例化对象
private Singleton(){ // 将构造方法进行了封装。私有化
}
public void print(){
System.out.println("Hello World!!!") ;
}
};
public class SingletonDemo04{
public static void main(String args[]){
Singleton s1 = null ; // 声明对象
s1 = Singleton.instance ; // 取得实例化对象
s1.print() ; // 调用方法
}
};正常情况下，这些属性应该封装起来。所以以上代码最好改动为下面形式：class Singleton{
private static Singleton instance = new Singleton() ; // 在内部产生本类的实例化对象
public static Singleton getInstance(){ // 通过静态方法取得instance对象
return instance ;
}
private Singleton(){ // 将构造方法进行了封装，私有化
}
public void print(){
System.out.println("Hello World!!!") ;
}
};
public class SingletonDemo05{
public static void main(String args[]){
Singleton s1 = null ; // 声明对象
s1 = Singleton.getInstance() ; // 取得实例化对象
s1.print() ; // 调用方法
}
};构造方法私有化之后，就能够通过以上的形式取得实例化对象。class Person{
private String name ; // 姓名属性
public Person(String name){ // 通过构造方法设置内容
this.name = name ; // 为姓名赋值
}
public String getName(){
return this.name ; // 取得姓名
}
};
public class ObjectArrayDemo01{
public static void main(String args[]){
// 类名称 数组名称[] = new 类名称[长度]
Person per[] = new Person[3] ; // 开辟了三个空间大小的数组
System.out.println("============== 数组声明 =================") ;
// 对象数组初始化之前，每个元素都是默认值
for(int x=0;x<per.length;x++){ // 循环输出
System.out.print(per[x] + "、") ; // 由于仅仅是开辟好了空间，所以都是默认值
}
// 分别为数组中的每个元素初始化。每个都是对象，都须要单独实例化
per[0] = new Person("张三") ; // 实例化第一个元素
per[1] = new Person("李四") ; // 实例化第二个元素
per[2] = new Person("王五") ; // 实例化第三个元素
System.out.println("\n============== 对象实例化 =================") ;
for(int x=0;x<per.length;x++){ // 循环输出
System.out.print(per[x].getName() + "、") ; // 此时，已经实例化完毕了，所以会直接打印出姓名
}
}
};
例如以下所看到的：
class Person{
private String name ; // 姓名属性
public Person(String name){ // 通过构造方法设置内容
this.name = name ; // 为姓名赋值
}
public String getName(){
return this.name ; // 取得姓名
}
};
public class ObjectArrayDemo02{
public static void main(String args[]){
// 声明一个对象数组。里面有三个对象，使用静态初始化方式完毕
Person per[] = {new Person("张三"),new Person("李四"),new Person("王五")} ;
System.out.println("\n============== 数组输出 =================") ;
for(int x=0;x<per.length;x++){ // 循环输出
System.out.print(per[x].getName() + "、") ; // 此时，已经实例化完毕了，所以会直接打印出姓名
}
}
};
假设在类Outer的内部再定义一个类Inner。此时Inner就称为内部类。而类Outer则称为外部类。
当内部类声明成public或private时。对其訪问的限制与成员变量和成员方法全然同样。
内部类的定义格式例如以下：
class Outer{ // 定义外部类
private String info = "hello world" ; // 定义外部类的私有属性
class Inner{ // 定义内部类
public void print(){ // 定义内部类的方法
System.out.println(info) ; // 直接訪问外部类的私有属性
}
};
public void fun(){ // 定义外部类的方法
new Inner().print() ; // 通过内部类的实例化对象调用方法
}
};
public class InnerClassDemo01{
public static void main(String args[]){
new Outer().fun() ; // 调用外部类的fun()方法
}
};class Outer{ // 定义外部类
private String info = "hello world" ; // 定义外部类的私有属性
public void fun(){ // 定义外部类的方法
new Inner(this).print() ; // 通过内部类的实例化对象调用方法
}
public String getInfo(){ // 添加了一个getter方法取得info内容
return this.info ;
}
};
class Inner{ // 定义内部类
private Outer out = null ; // 声明Outer对象
public Inner(Outer out){
this.out = out ;
}
public void print(){ // 定义内部类的方法
System.out.println(this.out.getInfo()) ; // 直接訪问外部类的私有属性
}
};
public class InnerClassDemo02{
public static void main(String args[]){
new Outer().fun() ; // 调用外部类的fun()方法
}
};假设将内部类拿到外部之后，会发现代码添加了，并且复杂度添加了。使用内部类的最大长处。能够方便的訪问外部类中的私有属性。可是，以上的内部类。是无法在外部直接调用的。是无法依照外部类的形式使用的。class Outer{ // 定义外部类
private static String info = "hello world" ; // 定义外部类的私有属性
static class Inner{ // 使用static定义内部类为外部类
public void print(){ // 定义内部类的方法
System.out.println(info) ; // 直接訪问外部类的私有属性
}
};
public void fun(){ // 定义外部类的方法
new Inner().print() ; // 通过内部类的实例化对象调用方法
}
};
public class InnerClassDemo03{
public static void main(String args[]){
new Outer.Inner().print() ; // 调用外部类的fun()方法
}
};class Outer{ // 定义外部类
private String info = "hello world" ; // 定义外部类的私有属性
class Inner{ // 定义内部类
public void print(){ // 定义内部类的方法
System.out.println(info) ; // 直接訪问外部类的私有属性
}
};
public void fun(){ // 定义外部类的方法
new Inner().print() ; // 通过内部类的实例化对象调用方法
}
};
public class InnerClassDemo04{
public static void main(String args[]){
Outer out = new Outer() ; // 外部类实例化对象
Outer.Inner in = out.new Inner() ; // 实例化内部类对象
in.print() ; // 调用内部类的方法
}
};
可是内部类所在方法的參数必须定义成final类型。
class Outer{ // 定义外部类
private String info = "hello world" ; // 定义外部类的私有属性
public void fun(final int temp){ // 定义外部类的方法
class Inner{ // 在方法中定义的内部类
public void print(){ // 定义内部类的方法
System.out.println("类中的属性：" + info) ; // 直接訪问外部类的私有属性
System.out.println("方法中的參数：" + temp) ;
}
};
new Inner().print() ; // 通过内部类的实例化对象调用方法
}
};
public class InnerClassDemo05{
public static void main(String args[]){
new Outer().fun(30) ; // 调用外部类的方法
}
};
原文：http://www.cnblogs.com/yangykaifa/p/7137919.html