黑马程序员------Java基础学习------面向对象(下)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一．概述

　　面向对象除了封装、继承和多态三大特征之外，还有其他的特性，例如abstract抽象、interface接口等，抽象类主要作为多个类的模板，而接口则定义了多类应该遵守的规范，final关键字让java实现不可变类，让系统更加安全。　　

 

二、正文

1、构造器和初始化块

1.1 构造器

　　构造器是一种特殊方法，这个特殊方法用于创建实例时执行初始化，是创建对象的重要途径，如果程序员没有为JAVA类提供任何构造器，则系统会为这个类提供一个无参数的构造器，这个构造器的执行体为空，不做任何事情。无论如何，JAVA类至少包含一个构造器。

　　具体代码如下：

public class A{
       private String name;
       private int age;
       A(String  name){
       //this关键字代表本来引用
             this.name = name;
       }
       //自定义构造器，含两个参数，名称必须和类名相同
       A(String name,int age){
              this(name);
              this.age = age;
       }    
}
class Test{
      public static void main(String[] args){
              //根据构造器生产对象
              A a = new A("zhang",5);
              A a1 = new A();         
              System.out.print("name"+a.name+"age"+a.age);
              System.out.print("name"+a1.name+"age"+a1.age);    
       }
}

通过上面的程序我们可以看出，构造器是创建JAVA对象的重要途径，通过new 关键字创建构造器，一旦程序员提供了自定义的构造器，则系统不再提供默认的构造器,如果不自定义无参数构造器，将不能通过无参构造器创建对象，一个类可以有多个构造函数，名字必须相同，但参数不能相同。程序中this（name）用this关键字调用该类的无参构造函数，而且使用this必须放在第一条语句。

 

1.2 初始化快

      Java通过构造器对单个对象进行初始化，与之功能类似的是初始化块，它也可以对对象进行初始化。具体语法格式如下：

[修饰符]
{
             //初始化块的可执行代码......
}

 修饰符只能是static，使用static修饰的称为静态初始化块，初始化块里的代码包括定义局部变量，调用其他对象的方法，以及使用分支、循环语句等。如果不写修饰符的称为普通初始化块。下面是一段简单的代码：

class Test{
       //普通初始化块
       {
            //初始化块执行语句
       }
       //静态初始化块
       static
       {
              //静态初始化块执行语句
       }
       Test（）
       {
              //无参数构造函数执行语句
       }
}

上面程序如果执行Test test = new Test（）；时，那么它的执行顺序是先执行静态初始化块，然后普通初始化块，最后才是Test（）。

      注意：初始化块随着类的加载而执行，只执行一次，对所有对象进行初始化。

 

2、抽象类

      在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但是无法准确的知道这些子类如何实现这些方法，例如定义一个People类，这个类提供了一个eat（）方法，但不同的People子类的eat（）方法是不一样的，即People无法准确的描述eat（）方法。那么如何既能让People（）包含eat（）方法，又无须提供其他方法实现呢？这时使用抽象方法即可满足该要求。抽象方法和类的具体特征如下：

1、抽象类和方法必须使用abstract修饰，抽象方法不能有方法体。

2、抽象类不能被实例化。

3、抽象类和普通类没多大区别，可以包含成员变量、方法、构造器、初始化块和枚举类6种成分。抽象类的构造器不能创建实例，主要用于被其子类调用。

4、含有抽象方法的类，必须被定义成抽象类。

5、抽象类只能被子类继承，子类想要建立实例对象，必须复写所有抽象方法，如果只是复写了一部分，子类也必须是抽象类。

下面是一段简单的代码：

//定义抽象类
abstract class People{                   
    //普通成员变量
       private String name;
       //构造函数
    public People(String name){
        this.name = name;
    }
       //普通方法
    public void enjoy(){
        System.out.println("people");
    }
        //声明抽象方法
    public abstract void eat();      
}
//student继承People，并复写了eat（）抽象方法
//这样student才能被创建实例，不复写的话student也必须是abstract
class student extends People{
       public void eat(){
              System.out.println("student");
       }
}

　注意：抽象类也可以不包含抽象方法，只能被继承。它是从多个具有相同特征的类中抽取出来的，具备相同的特征，以这个抽象类作为其子类模板，从而避免了子类设计的随意性。

3、接口

      接口是一种特殊的抽象类，不能包含普通方法，接口中的所有方法都是抽象方法。具体语法如下：

[修饰符] interface 接口名 [extends 父接口名列表]{
[public] [static] [final] 常量;
[public] [abstract] 方法;

修饰符：可选，用于指定接口的访问权限，可选值为public。如果省略则使用默认的访问权限。

接口名：必选参数，用于指定接口的名称，接口名必须是合法的Java标识符。一般情况下，要求首字母大写。

extends 父接口名列表：可选参数，用于指定要定义的接口继承于哪个父接口。当使用extends关键字时，父接口名为必选参数。

方法：接口中的方法只有定义而没有被实现。

　　那么接口在什么时候定义呢？比如，有两个及上的的类拥有相同的方法，但是实现功能不一样，就可以定义一个接口，将这个方法提炼出来，在需要使用该方法的类中去实现，就免除了多个类定义系统方法的麻烦。下面是一个简单的例子代码：

//定义接口A

interface A  { 

    void a(); 

} 

//定义接口B

interface B { 

    void b(); 

} 

/接口C继承了A又实现了B

interface C extends A  implements B  { 

      void c（）；

} 

//接口D实现了C，必须要复写了C中所有的抽象方法，即a（）和b（），不然

class D implements C{ 

    public void a()  { 

        System.out.println("a"); 

} 

    public void b()  { 

        System.out.println("b");

      public void c()  { 

        System.out.println("c"); 

    }   

    } 

} 

//

public class cam2  { 

    static public void main(String args[])  { 

           //生成的D的实例，并调用方法

        D a=new D(); 

        a.a(); 

        a.b();

           a.c(); 

    } 

}

上面代码有接口A和B，C继承了A实现了B，其实也可以同时实现AB，AB之间只需要逗号隔开就可以，后面D有实现了C，那么D就必须复写ABC中的所有抽象方法，不然就不能被实例化。

    注意：接口是对外暴露的规则，接口可以继承接口，可以被多实现，通常情况下把事物的共性功能去被子类继承，扩展功能放在接口里被实现。

 

4、单例和final关键字

4.1 单例

    单例是解决类在内存中只存在一个对象的最有效的方法，下面是一段代码：

//懒汉式
public class Singleton { 
    //私有化声明变量
      private static Singleton uniqueInstance = null; 
      //私有化构造函数，保证不被其他类实例化  
    private Singleton() {} 
   //对外提供public static方法提供自身实例
    public static Singleton getInstance() { 
       if (uniqueInstance == null) { 
           uniqueInstance = new Singleton(); 
       } 
       return uniqueInstance; 
    } 
    // 其它方法
}

从代码可以看出，想要保证对象的唯一性，那么步骤是：

1.为避免其他程序建立该对象实例，必须私有化构造函数

2.在本类中创建一个本类实例

3.为了方便其他程序访问，可以对外提供访问方式

    上面介绍的懒汉式单例方法，是延时加载，还有一种是饿汉式，具体代码如下：

//饿汉式单例类.在类初始化时，已经自行实例化  
public class Singleton1 { 
    //私有的默认构造子 
    private Singleton1() {} 
    //已经自行实例化  
    private static final Singleton1 single = new Singleton1(); 
    //对外提供自身实例 
    public static Singleton1 getInstance() { 
        return single; 
    } 
}

饿汉式，static修饰，随着类的加载而加载，会损耗性能，但是方法相对简单

懒汉式 第一次用的时候相对较慢，因为需要加载！线程，不安全！

注意：开发中一般用饿汉式，懒汉式面试时用的多，因为懒汉式有缺点，容易造成多次创建实例，不能保证实例的唯一性。

 

4.2 final关键字

   final可以修饰类、变量和方法，也可修饰局部变量和形参。那么他的特征是：

1.修饰变量时，说明该变量一旦被赋值就不可被改变，一般情况下格式是public static final int MAX，这个称为全局常量，注意常量名大写。

2.被final修饰的类不可被继承，防止被子类继承之后复写里面的方法。

3.被final修饰的方法不可被复写。

 

三、总结

    上面介绍了构造器和初始化块，它们是用来给对象初始化用的，接口和抽象类提高了函数的复用性，大大提高开发效率。

    接口只定义了类应当遵循的规范,却不关心这些类的内部数据和其方法内的实现细节.

    接口只规定了这些类里必须提供的方法;从而分离了规范和实现.增强了系统的可拓展性和维护性;

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------