黑马程序员—Java面向对象(单例设计模式、面向对象的继承、final关键字)

------- android培训、java培训、期待与您交流！ ----------

 

设计模式：解决问题最行之有效的思想。是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

*java中有23种设计模式。

 * 单例设计模式，解决一个类在内存中只存在一个对象。

解决的问题：保证一个类在内存中的对象唯一性。

比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。

 

 * 想要保证对象的唯一性，该如何做呢？

 * 1.为了避免其他程序过多的建立该类对象，首先要禁止其他程序建立该类对象。

 * 2.为了让其他类能够访问到该类对象，只好在该类中创建一个对象。

 * 3.为了方便其他程序对这个对象的访问，可以对外提供一些访问方式。

 *

 * 这三部怎么用代码体现呢？

 * 1.将构造函数私有化。

 * 2.在类中创建一个本类对象。

 * 3.提供一个方法可以访问到本对象。

 *

 * 对于事物该怎么描述还是怎么描述，当需要将该事物的对象保证在内存中的唯一时，就将以上的三部加上即可。

代码体现：

//饿汉式

classSingle {

   

    private Single() {}

   

    private static Single s = new Single();  这个先在这里先建立对象。称为：饿汉式。

   

    public static Single getInstance() {

       return s;

    }

}

 

懒汉式：

//对象是在方法被调用时，才开始初始化，也叫做对象的延时加载。

//Single类进内存，对象还没有存在，只有调用getInstance方法时才建立对象。 //这个后在这里建立对象。这个叫懒汉式。

classSingle2 {

   

    private Single2() {}

   

    private static Single2 s = null;

   

    public static synchronized Single2getInstance() { //1.synchronized可以解决线程安全问题

                                                //2.但是使程序运行效率变低。因为cpu切换别的程序时要进行判断。

       if (s == null) {

          

           synchronized (Single2.class) {

             

              if (s == null)

                  s = new Single2();

           }

       }      

       return s;

    }

}

//定义单例时，开发的时候，建议使用饿汉式。

 

 

 

面向对象之继承：

继承的概述：

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可。

多个类可以称为子类，单独这个类称为父类或者超类。

子类可以直接访问父类中的非私有的属性和行为。

通过 extends 关键字让类与类之间产生继承关系。

•   class SubDemo extends Demo{}

好处：

1：提高了代码的复用性。

2：让类与类之间产生了关系，提供了另一个特征多态的前提。

父类的由来：其实是由多个类不断向上抽取共性内容而来的。

java中对于继承，java只支持单继承。java虽然不直接支持多继承，但是保留了这种多继承机制，进行改良。

单继承：一个类只能有一个父类。

多继承：一个类可以有多个父类。

Java语言中只支持单继承（有别于C语言）。

因为多继承容易带来安全隐患（父类多了，功能相同的话，就会出现调用不确定性，覆写一个方法，到底覆写的谁的？）。

但是java支持多重继承。A继承B  B继承C  C继承D。

多重继承的出现，就有了继承体系。体系中的顶层父类是通过不断向上抽取而来的。它里面定义的该体系最基本最共性内容的功能。

代码示例：

//Person类

classPerson {

    String name;

    int age;

}

//学生继承了Person类

classStudent extends Person {

   

    void study() {

       System.out.println("Goodstudy!");

    }

}

//工人也继承Person类

classWorker extends Person {

 

    void work() {

       System.out.println("Goodwork!");

    }

}

子父类出现后，类成员的特点：

1. 变量：

* 如果子类中出现非私有的与父类同名成员。子类要访问本类中的变量用this，子类要访问父类中的同名变量，要用super。

this和super的用法几乎一致。

* this代表的是本类对象的引用，super代表的是父类对象的引用。

2.函数:

当子类出现和父类一模一样的函数（方法）的时候。

 * 创建子类对象调用该函数，会运行子类的函数（方法）

 * 父类的函数（方法）就会被覆盖。

 *

 * 这种情况是函数的另一个特性：重写（覆盖）

 *

 * 当子类继承了父类，也继承了父类的功能，到子类中，但是子类虽具备该功能，却和父类的功能不一致，这时没有必要定义新的

 * 功能，而是使用覆盖特性，保留父类的功能定义，并重写功能的具体内容。

 *

 * 覆盖:子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

 *     静态只能覆盖静态。

 *    

 * 记住大家：

 * 重载：函数名一模一样，只看同名函数的参数列表。

 * 重写：函数名和参数列表和返回值都一模一样，并且，子类重写函数的权限要大于或等于父类被重写的函数。

代码示例：

//父类

classFu1 {

    //show方法

    void show() {

       System.out.println("Fu1 show");

    }

    //speak方法

    public void speak() {

       System.out.println("Fu1 vb");

    }

}

//子类

classZi1 extends Fu1 {

    //重写父类的show方法

    void show() {

       System.out.println("Zi1 show");

    }

    //重写父类speak方法

    public void speak() {

       System.out.println("Zi1 java");

    }

}

//测试类

publicclass ExtendsDemo3 {

 

    public static void main(String[] args) {

       //创建子类的实例对象

       Zi1 z = new Zi1();

       //这时运行的将是子类重写后的show方法

       z.show();

       //运行的是子类重写后的speak方法

       z.speak();

    }

}

3.构造函数:

/**

 * 子父类中的构造函数。

 *

 * 在对子类对象进行初始化时，父类的构造函数也会运行。那是因为子类的构造函数的第一句有一条隐式的语句，super();

 * super();这个语句会访问父类中的那个空参数的构造函数，而且子类中所有的构造函数默认第一行都是Super();

 *

 * 为什么子类一定要访问父类中的构造函数呢？

 * 答；因为父类中的初始化数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的

 *    所以子类在对对象初始化时，要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动修改

 *   super语句的方式来指定。

 *   

 * 注意：super语句一定要在子类构造函数的第一行。  

 *

 * 子类的实例化过程。

 * 结论：

 * 子类的所有构造函数，默认都会访问父类中的空参数的构造函数。

 * 因为子类的每一个构造函数里面的第一行都有隐式的super();

 *

 * 当父类中没有空参数的构造函数时，子类必须手动通过super();语句来指定父类中的有参数构造函数。

 *

 * 当然，子类的构造函数的第一行也可以手动的用this语句来指定本类中的构造函数。

 * 子类中至少会有一个构造函数会访问父类的构造函数。

 */

//父类

classFu2 {

    public Fu2() {

       System.out.println("Fu2构造函数");

    }

}

//子类继承父类

classZi2 extends Fu2 {

    //子类空参数构造函数

    public Zi2() {

       System.out.println("Zi2构造函数");

    }

    //子类带参数构造函数

    public Zi2(int x) {

       System.out.println("Zi2带参数构造函数");

    }

}

//测试类

publicclass ExtendsDemo4 {

 

    public static void main(String[] args) {

       //创建子类实例对象，会访问父类空参数构造函数

       Zi2 z = new Zi2();

       //用子类带参构造函数创建子类实例对象，会访问父类空参数构造函数

       Zi2 z2 = new Zi2(5);

    }

}

super()和this()是否可以同时出现的构造函数中。

两个语句只能有一个定义在第一行，所以只能出现其中一个。

super()或者this():为什么一定要定义在第一行？

因为super()或者this()都是调用构造函数，构造函数用于初始化，所以初始化的动作要先完成。

 

注意：千万不要为了获取其他类的功能，简化代码而继承，必须是类与类之间有所属关系才可以继承。

 *     所属关系就是，is a。

所以判断所属关系，可以简单看，如果继承后，被继承的类中的功能，都可以被该子类所具备，那么继承成立。如果不是，不可以继承。

 

细节二：

在方法覆盖时，注意两点：

1：子类覆盖父类时，必须要保证，子类方法的权限必须大于等于父类方法权限可以实现继承。否则，编译失败。

2：覆盖时，要么都静态，要么都不静态。 (静态只能覆盖静态，或者被静态覆盖)

 

继承的一个弊端：打破了封装性。对于一些类，或者类中功能，是需要被继承，或者复写的。

这时如何解决问题呢？介绍一个关键字，final:最终。

 

final关键字：

/**

 * final关键字：最终的。作为一个修饰符。

 * 1.可以修饰类，函数，变量。

 * 2.被final修饰的类不能被继承。为了避免被继承，被子类重写。

 * 3.被final修饰的方法不可以被重写。

 * 4.被final修饰的变量是一个常量，只能赋值一次，但在定义常量的时候或者在构造函数里面要马上给常量赋值。

 *   既可以修饰成员变量，又可以修饰局部变量。

 *   当在描述事物时，一些数据的出现值是固定的。这时为了增强阅读性，都会给这个值起个名字，方便于阅读。

 *   这个值不需要改变，所以加上final修饰。

 *   常量的书写规范：所有的字母都大写，如果由多个单词组成，单词间通过  _   下划线连接。

 * 5.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

 */

 

//演示类

classDemo {

    //final修饰的常量

    final int X = 3;

    //PAI也是一个常量

    public static final double PAI = 3.14;

    //被final修饰的方法不可以被重写。

    final void show1() {

      

    }

}

------- android培训、java培训、期待与您交流！ ----------