黑马程序员 Java基础<二>设计模式、继承等概念

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

(一)设计模式

设计模式：对普遍常见问题，通用的解决办法。
          23种。其实就是解决问题的思想。

单例设计模式：
    解决的问题：保证一个类在内存中的对象唯一性。


如何保证一个类的对象唯一性呢？

思路：
1，不让其他程序创建该类对象。
2，其他程序不能创建，只有在本程序中创建一个对象。
3，将自定义的对象提供给其他程序访问。


步骤：
1，私有化构造函数。
2，自己new一个本类对象。
3，对外提供一个方法可以获取到这个对象。
方式一:

//饿汉式class Single{//创建一个本类对象。private static Single s = new Single();//私有化构造函数。private Single(){}//对外提供方法，让其他程序获取该对象。//结果？Single//参数/ 无。public static Single getInstance(){return s;}}class SingleDemo {public static void main(String[] args) {Single s1 = Single.getInstance();Single s2 = Single.getInstance();System.out.println(s1==s2);}}

方式二:

//懒汉式，延迟加载方式。//存在一些小问题，这是涉及到多线程技术的。class Single{private static Single s = null;private Single(){}public static Single getInstance(){if(s==null)s = new Single();return s;}}class Single2{private static final Single2 s =  new Single2();private Single2(){}public static Single2 getInstance(){return s;}/**/}class SingleDemo2 {public static void main(String[] args) {//Single2 s1 = Single2.s;//Single2 s2 = Single2.s;//System.out.println(s1==s2);}}

(二)继承

当两个事物之间存在一定的所属关系，即就像孩子从父母那里得到遗传基因一样，当然，java要遗传的更完美，这两个类中，一个继承的类（为子类或者基础类）可以从被继承的类（为父类或者超类）中获得一些属性和方法，而不必再自己创建新方法（在不需要复写的情况等）。

一、特点：

1、提高代码复用性，定义在父类中的成员（变量和方法），可以被子类重复使用；

2、让类与类之间产生关系，这样就会有多态的特性。使得应用起来更方便。

需要注意的是：

A.不可以只是为了获取其他类的功能，简化代码就一味的使用继承；必须是类与类之间有所属关系，才可以用继承，这种关系称为“is-a”。

B.java语言中，只支持单继承，不支持多继承。究其原因，是因为多继承容易带来安全隐患：

a.当多个父类中定义了相同的功能，且功能内容不同时，子类对象并不确定要运行哪一个，这就造成了程序的混乱而导致异常出现。

b但是java保留了这种机制，并改良了多继承为多实现，而且接口就可以多继承。

二、使用继承体系中的功能

1、如果使用体系，要先对体系中父类的描述进行参阅，了解父类中的共性功能，即可以使用该体系了。这样既可以减少查阅时间，也能更系统的了解体系结构，以及父类的功能。

2、具体调用父类中的功能的时候，需要创建子类对象，通过子类对象对父类方法调用，实现继承。

为何要通过创建子类对象调用父类中的方法呢？原因如下：

a.父类很可能不可以创建对象，如父类是一个抽象类或者接口，这就需要子类创建对象，调用方法。

b.创建子类对象，可以使用更多的功能，如父类公有的，和子类中自定义的特有功能。

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

类成员：变量、函数、构造函数

1、变量：

子父类中出现非私有的同名成员变量是，子类访问本类的同名时，要用this关键字（如果省略了this，仍是代表本类的变量）；子类访问父类同名变量时，用super关键字。

补充：this和super两者都存在与方法区中。

    this：本类对象引用，那个对象调用this所在的函数，this就代表那个对象。

    super：父类对象引用，用于子类初始化父类构造函数时等。

2、.函数：（覆盖（重写））

当子类同父类出现相同函数时，子类对象调用该函数时，会运行子类内容，如同覆盖谷类函数一样。实际上并没有覆盖父类的函数，如果还需要调用父类的这个方法，需要用super.方法名即可。

/*继承：提高了代码的复用性。  让类与类之间产生了关系，给多态这个特征提供了前提。特点：1，java中不直接在类上体现多继承。只支持单继承。多继承：一个子类可以继承多个父类。class Fu1{void show(){}}class Fu2{void show(){}}class Zi extends Fu1,Fu2{}new Zi().show();//出现了调用的不确定性。在方法体上不确定。单继承：一个子类只能继承一个父类。多层继承：就会出现继承体系，学习一个体系的时候，先看最顶层的类。使用最底层的类创建对象调用方法。什么时候写继承？事物之间存在着所属(is a)关系时，才继承。xxx是yyy中的一种。xxx继承yyy。比如：狗继承犬科，狼继承犬科。*/class Person{private String name;int age;public String getName(){return this.name;}}class Student extends/*继承*/Person{void study(){System.out.println(getName()+":"+age+" good good study...");}}class Worker extends Person{void work(){System.out.println(name+":"+age+"....work");}}class ExtendsDemo {public static void main(String[] args) {Student s = new Student();//s.name="李四";s.age=12;s.study();}}

/*继承中，子类里，成员的特点。成员变量。成员函数。构造函数。*///成员变量。/*super关键字：super关键字的用法和this相似。this代表的是当前对象。super代表的是父类中内存空间。子父类中不会出现同名属性的情况。*/class Fu{int num = 4;}class Zi extends Fu{int num = 5;void show(){int num = 6;System.out.println("num="+super.num);System.out.println(this);//System.out.println(super);//不可以。}}class ExtendsDemo2 {public static void main(String[] args) {new Zi().show();}}

/*继承中，成员函数的特点。特殊情况：子父类中出现了一模一样的方法，创建子类对象调用该方法时，运行的是子类中的方法。这种情况称之为函数的另一个特性----覆盖(override)重写 复写。继承的覆盖使用注意事项：1，子类覆盖父类权限必须大于等于父类的权限。2，覆盖中，静态只能覆盖静态，或者被静态覆盖。*/class Fu{public void show(){System.out.println("fu show");}}class Zi extends Fu{public void show(){System.out.println("zi show");}}class ExtendsDemo3 {public static void main(String[] args) {Zi z = new Zi();z.show();//Phone p = new Phone();//NewPhone p = new NewPhone();//p.show();}}/*覆盖的应用。新电话的功能来电显示 除了号码，还显示姓名，大头贴。*/class Phone{public void call(){}//来电显示。public void show(){System.out.println("number");}}//新电话描述。/*覆盖的应用:沿袭父类的功能声明，定义子类该功能的特有内容。*/class NewPhone extends Phone{public void show(){//System.out.println("number");super.show();System.out.println("name");System.out.println("pic");}}

/*子父类中的构造函数的特点。创建子类对象，父类中的构造函数也运行了。为什么呢？其实在子类的所有构造函数中的第一行，都有一句默认的super();在调用父类中的空参数构造函数。为什么子类实例化都必须去父类中的初始化呢？因为子类继承了父类，只有了父类中的内容，所以子类在实例化使用父类中的内容之前，必须要先明确父类是如何对自己的内容进行初始化的，所以子类的构造函数都会默认访问父类中空参数的构造函数。通过super();如果父类中没有空参数的构造函数时，子类的构造函数必须通过super执行要访问的父类中的构造函数。this()和super();都必须出现在构造函数的第一行。为什么都必须出现的第一行呢？因为初始化的动作要先执行。*/class Fu extends Object{Fu(){//super();//显示初始化。//构造代码块初始化。System.out.println("fu run...");}/**/Fu(int x){System.out.println("fu ..."+x);}}class Zi extends Fu{Zi(){//super();System.out.println("Zi run...");}Zi(int x){this();System.out.println("Zi ..."+x);}}class ExtendsDemo4 {public static void main(String[] args) {new Zi(4);}}