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(); } }