java面向对象（二）

这篇文章继续接着上一篇总结介绍Java面向对象特性中的一些基础语法，包括接口，抽象类，内部类以及
final关键字的用法等.

1.包装类

基本数据类型的数据也不具备“对象”的特性。
  所以Java提供了包装类的概念，为8种基本数据类型分别定义了相应的引用类型，并称之为基本数据类
  型的包装类。
把基本数据类型变量包装类实例是通过对应包装类的构造器来实现的，不仅如此，8个包装类中除了Character
之外，还可以通过传入一个字符串参数来构建包装类对象。
  如果希望获得包装类对象中包装的基本类型变量，则可以使用包装类提供的XxxValue()实例方法。

  JDk还提供了自动装箱和自动拆箱。自动装箱就是把一个基本类型的变量直接赋给对应的包装类变量，
  自动拆箱则与之相反。
  包装类还可以实现基本类型变量和字符串之间的转换，除了Character之外的所有包装类都提供了一
  个parseXxx(String s)静态方法。
  如果将基本类型转换为这符串，只需在后面加+ “”进行连接运算。

2.单例设计模式

单例设计模式：保证一个类在内存中只有一个对象。
模式：模式就是解决一类问题的固定步骤 。

单例设计模式的步骤：

饿汉单例设计模式
 1. 私有化构造函数。
 2. 声明本类的引用类型变量，并且使用该变量指向本类对象。
 3. 提供一个公共静态的方法获取本类的对象。 
 例如：

//饿汉单例设计模式 ----> 保证Single在在内存中只有一个对象。
class Single{
    //声明本类的引用类型变量，并且使用该变量指向本类对象。
    private static Single s = new Single();

    //私有化构造方法
    private Single(){}

    //提供一个公共静态的方法获取本类的对象
    public static Single getInstance(){
        return s;
    }
}

懒汉单例设计模式：
 1. 私有化构造函数。
 2. 声明本类的引用类型变量，但是不要创建对象，
 3. 提供公共静态 的方法获取本类 的对象，获取之前先判断是否已经创建了本类 对象，如果已经
 创建了，那么直接返回对象即可，如果还没有创建，那么先创建本类的对象，然后再返回。

例如：

//懒汉单例设计模式 ----> 保证Single在在内存中只有一个对象。
class Single2{
    //声明本类的引用类型变量，不创建本类的对象
    private static Single2 s;

    //私有化构造函数
    private single2(){}

    //提供一个公共方法获取或者返回该对象
    public static Single2 getInstance(){
        if(s==null){
            s = new Single2();
        }
        return s;
    }
}

3.final关键字

1.final变量

final修饰变量时，表示该变量一旦获得 初始值之后就不可被改变。
final既可修饰成员变量，也可以修饰局部变量。

2.final修饰成员变量

成员变量是随类的初始化或对象初始化而初始化的。final修饰的成员变量必须由程序员指定初始值。
对于类属性而言，要么在静态初始化块中初始化，要么在声明该属性时初始化。
对于实例属性，要么在普通初始化块中指定初始值。要么在定义时、或构造器中指定初始值。

3.final修饰局部变量

使用final修饰局部变量时既可以在定义时指定默认值，也可以不指定默认值。
给局部变量赋初始值，只能一次，不能重复。

4.final修饰基本类型和引用类型

当使用final修饰基本数据类型变时，不能对其重新赋值，不能被改变。
但对引用类型的变量而言，它仅仅保存的是一个引用，final只能保证他的地址不变，但不能保证对象，
所以引用类型完全可以改变他的对象。

5.可执行“宏替换”的final变量

对一个final变量来说，不管它是类变量、实例变量，还是局部变量，只要该变量满足以下3个条件，这
个final变量就不再是一个变量，而是相当于一个直接量。

  1.使用final修饰符修饰；
  2.在定义该final变量时指定了初始值；
  3.该初始值可以在编译时就被确定下来。

6.final方法

final 修饰的方法不可以被重写。
final 修饰的方法仅仅是不能重写，但它完全可以被重载。

7.final 类

final 修饰的类不可以被继承。

8.不可变类

不可变的类要满足以下几个条件：
1.使用private和final修饰符来修饰该类的属性
2.提供带参数的构造器，用于根据传入参数来初始化类里的属性
3.仅为该类的属性提供getter方法，不要为该类的属性提供setter方法，因为普通方法无法修改
final修饰的属性
4.如有必要，重写Object类中hashCode 和equals

缓存实例的不可变类：如果程序经常需要使用不可变类的实例，则可对实例进行缓存。

4.抽象类

1.抽象类的应用场景：

我们在描述一类事物的时候，发现该种事物确实存在着某种行为，
但是这种行为目前是不具体的，那么我们可以抽取这种行为 的声明，但是不去实现该种行为，这时
候这种行为我们称作为抽象的行为，我们就需要使用抽象类。

2.抽象方法和抽象类

抽象方法和类都必须使用abstract来修饰，有抽象方法的类只能定义成抽象类，抽象类里也可以没
有抽象方法。
抽象类不能被实例化，可以通过其子类给他赋值，普通类里有的抽象类里也有，定义抽象方法只需在
普通方法上增加abstract修饰符，并把普通方法的方法体（也就是方法后花括号括起来的部分）
全部去掉，并在方法后增加分号即可。 

2.抽象类的作用

抽象类代表了一种未完成的类设计，它体现的是一种模板。

3.抽象类要注意的细节

1. 如果一个函数没有方法体，那么该函数必须要使用abstract修饰,把该函数修饰成抽象的函数。。
2. 如果一个类出现了抽象的函数，那么该类也必须 使用abstract修饰。
3. 如果一个非抽象类继承了抽象类，那么必须要把抽象类的所有抽象方法全部实现。
4. 抽象类可以存在非抽象方法，也可以存在抽象的方法.
5. 抽象类可以不存在抽象方法的。 
6. 抽象类是不能创建对象的。
7. 抽象类是存在构造函数的，其构造函数是提供给子类创建对象的时候初始化父类的属性的。

5.接口

1.接口的概念

接口定义的是多个类共同的行为规范，这些行为是与外部交流的通道，这就意味着接口里通常是定义
一组公用的方法。
接口体现了规范与实现分离的设计。

2.接口的定义

和类定义不同，定义接口不再用class关键字，而是使用interface关键字。
语法如下：
[修饰符] interface接口名 extends 父接口1,父接口2 ...
{
零个到多个常量定义...
零个到多个抽象方法定义...
零个到多个内部类、接口、枚举定义...
零个到多个默认方法或类方法定义...
}

3.接口里的成分

在定义接口时，接口里可以包含成员变量（只能是常量），方法(只能是抽象实例方法、类方法或默
认方法），内部类（包括内部接口、枚举类)
  常量都是：public static final修饰
  方法都是：public abstract 修饰
  内部的类：public static

4.接口的继承

接口的继承和类继承不一样，接口完全支持多继承。
子接口扩展某个父接口将会获得父接口的所有抽像方法，常量属性，内部类和枚举类定义。 

5.使用接口

1.接口可以用于声明引用类型的变量，但接口不能用于创建实例。
2.当使用接口来声明引用类型的变量时，这个引用类型的变量必须引用到其实现类的对象。
3.一个类可以实现一个或多个接口，继承使用extends关键字，实现接口则使用implements关键字。
4.一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也
就是重写这些抽象方法）；否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。 

6.接口和抽象类的相似性

1.接口和抽象类都不能被实例化，它们都位于继承树的顶端，用于被其他类实现和继承。
2.接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。   

7.接口与抽象类的区别

1.接口里只能包含抽象方法，不同包含已经提供实现的方法；抽象类则完全可以包含普通方法。
2.接口里不能定义静态方法；抽象类里可以定义静态方法。
3.接口里只能定义静态常量属性，不能定义普通属性；抽象类里则既可以定义普通属性，也可以定
义静态常量属性。
4.接口不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而让其
子类调用这些构造器来完成属于抽象类 的初始化操作。
5.接口里不能包含初始化块，但抽象类则完全可以包含初始化块。
6.一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个
接口可以弥补Java单继承的不足。

6.内部类

1.内部类

1.我们把一个类放在另一个类的内部定义，这个定义在其他类内部的类就被称为内部类，有的也叫
嵌套类，包含内部类的类也被称为外部类有的也叫宿住类。
2.内部类提供了更好的封装，内部类成员可以直接访问外部类的私有数据，因为内部类被当成其他外部类成员。
3.匿名内部类适合用于创建那些仅需要一次使用的类。

2.非静态内部类

1.定义内部类非常简单，只要把一个类放在另一个类内部定义即可。
2.当在非静态内部类的方法内访问某个变量时，系统优先在该方法内查找是否存在该名字的局部变
量，如果存在该名字的局部变量，就使用该变量，如果不存在，则到该方法所在的内部类中查找是
否存在该名字的属性，如果存在则使用该属性。
3.总之，第一步先找局部变量，第二步，内部类的属性，第三步。外部类的属性。

3.静态内部类

1.如果用static修饰一个内部类，称为静态内部类。
2.静态内部类可以包含静态成员，也可以包含非静态成员。所以静态内部类不能访问外部类的实例
成员，只能访问外部类的类成员。
3.静态内部类的对象寄存在外部类里，非静态内部类的对象寄存在外部类实例里。

4.使用内部类

1.在外部类内部使用内部类－不要在外部类的静态成员中使用非静态内部类，因为静态成员不能访问非静态成员。
2.在外部类以外使用非静态内部类。
    （1）private 修饰的内部类只能在外部类内部使用。
    （2）在外部类以外的地方使用内部类，内部类完整的类名应该OuterClass.InnerClass.
    （3）在外部类以外的地方使用非静态内部类创建对象的语法如下：OuterInstance.new InnerConstructor()
    （4）在外部类以外的地方使用静态内部类创建对象的语法如下：new OuterClass.InnerConstructer();

5.局部内部类

1.如果把一个内部类放在方法里定义，这就是局部内部类，仅仅在这个方法里有效。
2.局部内部类不能在外部类以外的地方使用，那么局部内部类也不能使用访部控制符和static修饰

6.匿名内部类

1.匿名内部类适合创建那种只需要一次使用的类，定义匿名内部类的语法格式如下：
new 父类构造器（实例列表) |实现接口）
{
  //匿名内部类的 类体部分
}

2.匿名内部类不能是抽象类，匿名内部类不能定义构造器。