java面向对象易忘点（1）

一、面向对象三大特征：

1. 封装：对外部不可见。
2. 继承：扩展类的功能。
3. 多态：方法重载，对象多态。

二、数据类型：

（1）普通数据类型：

（2）引用数据类型：数组，对象。

类属于引用数据类型。因此有栈内存和堆内存的引用关系。

Person p = null;//开辟栈内存
p = new Person("张三",20);//开辟堆内存

对象保存在栈内，属性保存在堆内，方法保存在全局代码区中，此区内容的所有对象共享。

三、java中有四种内存区域：

1.栈内存：保存对象。

2.堆内存：保存属性。

3.全局数据区：保存static类型属性。

4.全局代码区：保存全部方法定义。

四、代码块：用｛｝括起来的代码

1.普通代码块：直接定义在方法中的代码块。

2.构造块：将代码块直接定义在类中。

构造块优先于构造方法先执行，而且构造块执行多次，只要一个实例化，就执行一次。

3.静态代码块：用static关键字声明的代码块。优先于主方法执行，而且只执行一次。

功能：为静态属性初始化。

4.同步代码块：synchronized括起来的代码块。

以下程序揭示了这些代码块的执行顺序以及特性：

class Demo{
	{
		System.out.println("2、构造块"); 
	}
	static{
		System.out.println("1、静态代码块"); 
	}
	public Demo(){
		System.out.println("3、构造方法"); 
	}
}
public class CodeDemo01{
	static{
		System.out.println("0、主方法的静态代码块"); 
	}
	public static void main(String args[]){
		Demo d1 = new Demo();
		Demo d2 = new Demo();
	}
}

五、构造方法私有化：

特性：

（1）类不能在外部实例化，但是能够在类的内部实例化。

（2）可以通过在内部产生对象实例，然后能够传到外部。

class Singleton{
	private static Singleton s = new Singleton();
	private Singleton(){
		
	}
	public  void print(){
		System.out.println("hello world"); 
	}
	public static Singleton getSingleton(){
		return s;
	}
}
class SingletonDemo01{
	public static void main(String args[]){
		Singleton s1 = Singleton.getSingleton();
		Singleton s2 = Singleton.getSingleton();
		Singleton s3 = Singleton.getSingleton();
		s1.print();
		s2.print();
		s3.print();

	}
}

以上程序的意义：

如果产生了本类的三个对象，但是都只有一个实例化对象，所以能够限制实例化的对象。

设计模式中，称为单态设计模式（单例设计模式Singleton）。

如果不希望一个类产生过多的对象，则使用单态设计模式，而且使用单态设计模式的java类库也会遇到。比如InetAddress。

所谓单态就是在入口处限制了对象的实例化。

比如windows中的回收站，也是使用了单态的设计，在桌面上有一个回收站对象，在每个硬盘也存在一个回收站的对象，但是实际上这些对象只有一个回收站实例。

单态设计模式：将类的构造方法私有化，之后在类的内部产生实例化的对象，并通过类的静态方法返回实例化对象的引用。

六、内部类：

1.能够访问外部类的私有属性。

2.但是以上内部类是无法由外部直接调用。

3.如果一个内部类使用static关键字声明，则此内部类称为静态内部类，类似于外部类。这样才能够在外部直接访问。

• 外部类.内部类 内部类对象 = new 外部类.内部类();
  

class Outer{
	private static String info = "hello";
	static class Inner{									//静态内部类对外部可见
		public void print(){
			System.out.println(info);					//访问外部类的私有属性
		}
	}
	public void fun(){
		new Inner().print();
	}
}
public class InnerDemo03{
	public static void main(String args[]){
		new Outer.Inner().print();						//直接外部访问内部类
	}
}

4.如果要在外部直接访问内部类，则需要以下语法：

• 外部类.内部类 内部类对象 = 外部类对象.new 内部类（）；

class Outer{
	private String info = "hello";
	class Inner{
		public void print(){
			System.out.println(info); 	//访问外部类的私有属性
		}
	}
	public void fun(){
		new Inner().print();
	}
}
public class InnerDemo02{
	public static void main(String args[]){
		Outer o = new Outer();
		o.fun();
		Outer.Inner i = o.new Inner();	//外部类.内部类 内部类对象 = 外部类对象.new 内部类();
		i.print();
	}
}

5.在方法中定义内部类：该方法的参数一定要final关键字。

class Outer{
	private String info = "hello";
	
	public void fun(){
		class Inner{
			public void fun(final int temp){//在方法中的声明的内部类，此内部类中的方法的参数一定要是final的
				System.out.println(temp);
				System.out.println(info);
				
			}
	}
		new Inner().print();
	}
}
public class InnerDemo02{
	public static void main(String args[]){
		Outer o = new Outer();
		o.fun();
		Outer.Inner i = o.new Inner();	//外部类.内部类 内部类对象 = 外部类对象.new 内部类();
		i.print();
	}
}