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

黑马程序员——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() { 



       // Exists only to defeat instantiation. 



    } 



   //对外提供public static方法提供自身实例



    public static Singleton getInstance() { 



       if (uniqueInstance == null) { 



           uniqueInstance = new Singleton(); 



       } 



       return uniqueInstance; 



    } 



    // Other methods... 



} 

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

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

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

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

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

//饿汉式单例类.在类初始化时，已经自行实例化  



public class Singleton1 { 



    //私有的默认构造子 



    private Singleton1() {} 



    //已经自行实例化  



    private static final Singleton1 single = new Singleton1(); 



    //对外提供自身实例 



    public static Singleton1 getInstance() { 



        return single; 



    } 



}  

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

 

4.2 final关键字

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

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

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

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

 

三、总结

    上面介绍了构造器和初始化块，它们是用来给对象初始化用的，接口和抽象类提高了函数的复用性，大大提高开发效率，单例是一种设计模式，java还有很多这样的设计模式，为开发带来了很大的方便。