java随笔——面向对象（上）

//静态方法
package nyist.com;
class Per
{
	int n;
	public static void Say()//定义静态方法
	{
		System.out.println("默认输出");
	}
}
public class Demo
{
	public static void main(String[] atgs)
	{
		Per.Say();//调用静态方法
	}
}
/*
 * 静态方法可以在不创建对象的情况下就调用某个方法
 */

//单例模式
package nyist.com;
class Single
{
	private static Single p=new Single();//用static创建单例模式
	private Single() {};
	public static Single get()
	{
		return p;
	}
}
public class Demo
{
	public static void main(String[] args)
	{
		Single s1=Single.get();
		Single s2=Single.get();
		System.out.println(s1==s2);
	}
}
/*
 * s1==s2是ture，说明了两次调用的是同一个对象。
 */

//静态代码块
package nyist.com;
class Per
{
	static//静态代码块
	{
		System.out.println("静态代码被执行了");
	}
}
public class Demo
{
	public static void main(String[] args)
	{
		Per n=new Per();
		Per m=new Per();
	}
}
/*
 * 当类被加载时，静态代码块就会被执行。由于类只加载一次，
 * 静态代码块只执行一次。如上述中创建了两个类，但是只执行
 * 了一次静态代码块。
 */

//内部类
package nyist.com;
class Per
{
	int m=4;
	public void test()
	{
	 Inner n=new Inner();
	 n.show();
	}
	
	class Inner//内部类
	{
		public void show()
		{
			System.out.println("m="+m);
		}
	}
}
public class Demo
{
	public static void main(String[] args)
	{
		Per o=new Per();
		o.test();
		Per.Inner u=new Per().new Inner();//通过外部类创建内部类
		u.show();
//		u.test();//错误，因为u是内部类，不能调用外部类函数。
	}
}
/*
 * 内部类可以在外部类中使用，并且内部类可以访问外部类中的成员。
 * 如果想通过外部类去创建一个内部类，语法：外部类名.内部类名 变量名=new 外部类名().new 内部类名();
 */

//方法内部类
package nyist.com;
class Out
{
	private int mun=4;
	public void text()//定义在方法中的内部类
	{
		class Inner
		{
			public void text()
			{
				System.out.println("mun="+mun);
			}
		}
		Inner p=new Inner();
		p.text();
	}
}
public class Demo
{
	public static void main(String[] gras)
	{
		Out U=new Out();
		U.text();
	}
}
/*
 * 方法内部类是指成员方法中定义的类，它只能在当前方法中被使用。
 */