黑马程序员_面向对象（三）

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

一、单例设计模式

1、什么是单例设计模式？
对于单例模式（Singleton Pattern）是一个比较简单的模式，他的定义如下：
Ensure a class has only one instance,and provide a global point of access to it.
意思是确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
好处：保证对象的唯一性
使用场景：比如多个程序都要使用一个配置文件中的数据，而且要实现数据共享和交换。必须要将多个数据封装到一个对象中。而且多个程序操作的是同一个对象。那也就是说必须保证这个配置文件对象的唯一性。

如何能保证对象的唯一性？
一个类只要提供了构造方法，就可以产生多个对象。完全无法保证唯一。既然数量不可 控，干脆不让其他程序建立对象。

不让其他程序创建，对象何在？
自己在本类中创建一个对象，好处，对象可控。

创建完成后，是不是要给其他程序提供访问的方式？
怎么实现这个步骤？
怎么就能不让其他程序创建对象呢？
直接私有化构造方法，不让其他程序创建的对象存在。
直接在本类中new一个本类对象
定义一个功能，其他程序可以通过这个功能获取到本类对象。


2、单例模式分成两种：懒汉式、饿汉式

3、下面就通过代码来看看这三种单例模式的区别
饿汉式：

//饿汉式
class Singleton_1{
    private static Singleton_1 s = new Singleton_1();
    private Singleton_1(){}
    public static Singleton_1 getInstance(){
        return s;
    }
    
}

懒汉式：（容易引发线程安全问题）

//懒汉式（单例模式的延迟加载方式），面试最多的是懒汉式
class Singleton_2{
    private static Singleton_2 s = null;
    private Singleton_2(){}
    public static Singleton_2 getInstance(){
        if(s == null){
            s = new Singleton_2();
        }
        return s;
    }
}

二、继承

1、假设有两个类，一个类是Student类，另外一类是Worker类，两个类中都有属性name和age，那么既然有共同的属性，我们能不能对他们进行抽取呢？
答案：可以，可以将两个类中的name属性和age属性都抽取取来，放到另外一个类，这个类就是Person，因为学生是人，工人也是人，所以就抽取出来再建立Person类。
继承的关键字：extends

代码体现：

package day08.itcast01;
public class ExtendsDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.name = "林青霞";
        s.age = 16;
        s.show();
        
        Worker w = new Worker();
        w.name = "小二";
        w.age = 28;
        w.show();
    }
}
class Student extends Person{//定义一个Student类，并提供一个成员方法
    public void study(){
        System.out.println("我在学习");
    }
}
class Worker extends Person{  //定义一个Worker类，并提供一个成员方法
    public void work(){
        System.out.println("我在工作");
    }
}
class Person{   //定义一个Person类，由Student类和Worker类抽取而来，是Worker类和Student类的父类（基类、超类）
    String name;
    int age;
    public void show(){
        System.out.println(name+"---"+age);
    }
}

继承的好处：提高了代码的复用性，为面向对象另一个特征多态提供了前提条件

什么时候定义继承？
必须保证类与类之间的所属（is a）关系，XX是XXX的一种
比如：狗是动物的一种，学生是人的一种

Java当中允许单继承，不允许多继承
单继承：一个子类只会有一个父类
多继承：一个子类会有多个父类

2、继承中子父类成员的特点：
1、成员变量
特殊情况：当子类和父类定义了同名的成员变量的时候，如何在子类中访问父类中的变量？
通过关键字super来完成
super的用法与this的用法类似，
this代表的是本类对象的引用。
super代表的是父类的内存空间
2、成员方法
当子类和父类定义了一模一样的的方法时，当子类调用该方法时，运行的是子类中的方法
这种情况在子父类中被称之为方法的重写。
何时需要重写方法？
当子类的方法有自己的特有的功能的时候就需要重写。
子类重写父类的方法必须保证权限要大于或者等于父类的权限
静态只能覆盖静态的
写法上需要注意的：必须一模一样，方法的返回值类型 方法名 参数列表都要一样。
代码体现：

package day09.itcast01;
public class ExtendsDemo1 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.age = 15;
        zi.des();
    }
}
class Fu{
    int age;
    public void des(){
        System.out.println("父类的des方法"+"---父类的成员变量---"+age);
    }
}
class Zi extends Fu{
    int age;
    public void des(){
        super.age = 10;
        super.des();
        System.out.println("子类的des方法"+"---子类的成员变量---"+age);
    }
    
}

3、子父类中构造方法的的特点

package day09.itcast02;
public class ExtendsDemo2 {
    public static void main(String[] args) {
        Son son = new Son();
    }
}
class Father{
    Father(){
        System.out.println("Father is running");
    }
}
class Son extends Father{
    Son(){
        System.out.println("Son is running");
    }
}

分析运行结果：
因为在子类的所有构造方法中的第一行都默认有一个super();它会调用父类的构造方法
为什么会有super();呢？
因为在子类进行初始化的时候，先要对父类进行初始化，只有对父类进行初始化完成后，才能使用父类的一些方法

当父类没有空参的构造方法时，需要使用super关键字去调用相应的构造方法

如果在子类的第一行使用了this调用本类的其他构造方法，还会有super();吗？
没有，因为this()或者super()只能定义在构造方法的第一行

父类的构造方法中是否有super();
有，因为所有类的构造方法的第一行都有一个super();此时父类调用的是所有类的父类Object类。

如果默认的隐式super语句没有对应的构造函数，必须在构造函数中通过this或者super的形式明确调用的构造函数。

三、final关键字

继承的缺点：打破封装性，如何能保证继有继承又不会打破封装性呢？
就不让其他类继承该类，就不会重写方法。这时就需要用到final关键字
final的意思是最终，它用于修饰类，方法或者变量（成员变量、局部变量、静态变量）

final的特点：
1、final修饰的类是一个最终类，不能再派生子类
如果一个类中的方法部分需要重写，部分不需要，就对不需要被重写的方法使用final修饰
2、final修饰的方法是最终方法，该方法不能被重写
3、final修饰的变量是一个常量，只能被赋值一次

什么时候需要在程序中定义final常量呢？
当程序中一个数据使用时是固定不变的，这时为了增加阅读性，可以给该数据起个名字。
这就是变量，为了保证这个变量的值不被修改，加上final修饰，这就是一个阅读性很强的常量。
书写规范：被final修饰的常量名所有的字母都是大写，如果该变量名是由多个单词组成的，每个字母都大写，并且单词之间使用"_"连接。



四、抽象类

对与狗和狼这两种动物他们都有一个吼叫的行为，而且他们还属于动物，对他们的共性进行向上抽取，可以使用继承，但是狗和狼吼叫的行为又不同。这时使用继承就显得不合适了，这时就需要使用另外一个关键字abstract（抽象的）对父类进行修饰。

抽象类的特点：抽象类和抽象方法都需要使用abstract修饰，抽象方法一定要定义抽象类中，抽象类中的方法不一定都是抽象方法。

只有覆盖了抽象类中的所有抽象方法后，其子类才可以实例化。否则该子类还是一个抽象类。

抽象类要实例化的话需要通过子类对父类进行实例化。（多态）

细节：
抽象类一定是一个父类
是的，因为抽象类就是子类的功能不断抽取出来的

抽象类中是否有构造方法？
有，不能给自己的对象实例化，可以给子类的对象进行初始化。

抽象类和普通类的异同点？
相同：它们都是用来描述事物的，它们之间都可以定义属性和行为

不同：一般类可以具体的描述事物，抽象类描述的事物信息不具体
抽象类可以多定义一个成员：抽象方法。
一般类可以创建对象，而抽象类不能创建对象。

抽象类中是否可以定义普通方法？
可以，如果抽象类中定义了普通方法，那么其抽象类的作用就是不能对该类进行实例化。

抽象关键字abstract不能与哪些关键字共存？
final
private
static

代码体现：

package day09;
public class AbstractDemo {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.show();
        d.speak();
        
    }
}
abstract class Animal{
    public void show(){
        System.out.println("Animal");
    }
    public abstract void speak();
}
class Dog extends Animal{
    public void speak(){
        System.out.println("小狗叫");
    }
}

案例：
需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
分析：程序员和项目经历都属于公司里的员工，而且他们都有共性：姓名、工号、薪水以及工作内容

package day09.itcast02;
public class AbstractDemo {
    public static void main(String[] args) {
        Programer p = new Programer("张三","448",5000);
        Manager m = new Manager("李四","500",5000,2500);
        p.content();
        p.show();
        m.content();
        m.show();
        
    }
}
abstract class Employee{
    String name;
    String number;
    int salary;
    public Employee(String name,String number,int salary){
        this.name = name;
        this.number = number;
        this.salary = salary;
    }
    public abstract void content();
    public abstract void show();
    
}
class Programer extends Employee{
    public Programer(String name,String number,int salary){
        super(name,number,salary);
    }
    public void content(){
        System.out.println("敲代码");
    }
    public void show(){
        System.out.println(name+"---"+number+"---"+salary);
    }
}
class Manager extends Employee{
    int pay;//奖金
    public Manager(String name,String number,int salary,int pay){
        super(name,number,salary);
        this.pay = pay;
    }
    public void content(){
        System.out.println("写规划");
    }
    public void show(){
        System.out.println(name+"---"+number+"---"+salary+"---"+pay);
    }
    
}

五、接口

当一个抽象类中的方法都是抽象方法的时候，这个抽象类就有另外一个表现方式，叫做接口（interface）
定义接口使用关键字interface，格式：interface 接口名{}

接口中的成员已经被限定为固定的几种。
接口中的定义格式（两种）
1、定义变量，但是变量必须有固定的修饰，public static final，所以接口中的变量也被称之为常量。
2、定义方法，方法也有固定的修饰符，public abstract
接口中的成员都是公共的。

特点：
接口不可以创建对象
子类必须覆盖掉接口中的所有抽象方法后，子类才可以被实例化。否则子类是一个抽象类。

定义接口的子类，类与类之间的关系是继承，而子类与接口之间的关系是实现(implements)。
格式：
interface Animal{ // 定义一个动物接口
}
class Dog implements Animal{ //定义犬类实现了动物的接口
}

接口解决了多继承中调用不明确的弊端，讲多继承机制在java中通过多实现完成了

接口的出现避免了单继承的局限性
父类中定义事物的基本功能。
接口中定义事物的扩张功能。

类与类之间是继承(is a)关系，类与接口之间是实现（like a）关系.

接口与接口之间是继承关系，而且可以多继承。

抽象类和接口的区别:
接口中定义的方法都是抽象方法，不允许定义普通方法。
抽象类中可以允许有普通方法，但是抽象方法一定定义在抽象类中。

接口的思想：
1、对功能实现了扩展。
2、定义了规则。
3、降低了耦合性。

三、多态

什么是多态？
举例子：学生和工人，但是他们都是人中的某一类，这就是多态。多态就是一种事物的不同体现。
多态的体现：
父类的引用或者接口的引用指向了自己的子类对象。
好处：提高了程序的扩展性。
弊端：通过父类的引用操作子类对象时，只能使用父类中已有的方法，不能操作子类特有的方法
多态的前提：继承或者实现。
多态通常都有重写操作。
代码体现：

package day10.itcast01;
public class DuotaiDemo1 {
    public static void main(String[] args) {
        Person p = new Student();
        p.eat(p);
        Person p1 = new Worker();
        p1.eat(p1);
        
    }
}
abstract class Person{
    public void eat(Person p){
        if(p instanceof Student ){
            System.out.println("吃饭");
            p.method();
        }else if( p instanceof Worker){
            System.out.println("吃饭");
            p.method();
        }
    }
    public abstract void method();
}
class Student extends Person{
    public void method(){
        System.out.println("学习");
    }
}
class Worker extends Person{
    public void method(){
        System.out.println("工作");
    }
}

2、多态调用子类的特有方法

Person p = new Studnet();
或者Person p = new Worker();
父类引用指向了子类的对象，这是让子类对象进行类型的提升（向上转型）
好处：提高了扩展性，隐藏了子类，弊端：不能使用子类的特有方法。

如果想要使用子类的特有方法，只有子类的对象才能使用，这时就需要使用向下转型。
向下转型属于强制类型转换，向上转型是自动类型转换。

package day10.itcast01;
public class DuotaiDemo1 {
    public static void main(String[] args) {
        Person p = new Student();
        p.eat(p);
//        p.write();  报错
        ((Student)p).writer();
        Person p1 = new Worker();
        p1.eat(p1);
        ((Worker)p1).work();
        
    }
}
abstract class Person{
    public void eat(Person p){
        if(p instanceof Student ){
            System.out.println("吃饭");
            p.method();
        }else if( p instanceof Worker){
            System.out.println("吃饭");
            p.method();
        }
    }
    public abstract void method();
}
class Student extends Person{
    public void method(){
        System.out.println("学习");
    }
    public void writer(){
        System.out.println("学生的特有方法：写作业");
    }
}
class Worker extends Person{
    public void method(){
        System.out.println("工作");
    }
    public void work(){
        System.out.println("工人的特有方法：干活");
    }
}

注意：无论是向上转型还是向下转型，最终都是子类对象做着类型的变化。
【向下转型的注意事项】：
Person p = new Studnet();
Worker w = (Worker)p;
以上代码是不允许出现的，会导致ClassCastException异常
为了避免出现类转换异常，在进行类转换时常使用instanceof关键字对对象进行类型判断
格式：对象名 instanceof 类名

3、子父类成员的调用问题
1、成员变量：当子父类中出现了同名的成员变量时
编译时期：参考的是引用型变量所属的类是否有被调用的成员变量，没有，编译失败。
运行时期：参考的是引用型变量所属类中的成员变量。
口诀：编译运行看左边。
2、成员方法：当子父类中出现了同名的成员方法时
编译时期：参考左边，如果没有，编译失败
运行时期：参考右边
口诀：编译看左边，运行看右边。
对于成员方法是动态绑定到对象上。
3、静态方法
编译和运行都参考左边
静态方法是静态绑定到类上。

4、题目
看一下代码分析打印结果（通过画图分析）

package day10.itcast02;
public class DuoTaiTest3
{
    public static void main(String[] args)
    {
        Fu f = new Zi();
        System.out.println("main :" +f.getNum());
    }
}
class Fu
{
    int x = 4;
    Fu()
    {
        System.out.println("A fu() : "+getNum());
    }
    int getNum()
    {
        System.out.println("B fu getnum run...."+x);
        return 100;
    }
}
class Zi extends Fu
{
    int x = 5;
    Zi()
    {    //super();默认存在并调用父类的无参构造
        System.out.println("C zi() : "+getNum());
    }
    int getNum()
    {
        System.out.println("D zi getnum run...."+x);
        return 200;
    }
}

结果分析：
分析这道题首先从main方法开始，Fu f = new Zi(); 程序首先会调用子类的构造方法，进入到子类的构造方法时，因为在子类的构造方法中第一行都会有默认的super();调用父类的构造方法，所以程序进入到 父类的构造方法之中，在父类的构造方法中，有一条输出语句，输出语句中调用了getNum()方法，那么这时候调用的是哪个呢？因为在main方法中，使 用了多态，使父类的对象引用指向了子类，所以调用的是子类的getNum方法，在getNum方法中输出了一个x，因为从程序开始一直到现在都还未对x进 行显示的初始化，所以x的值为0，所以最想打印的是D zi getnum run....0，接着getNum方法返回了200到父类的构造方法中，所以接着打印了A fu() : 200，当打印了两条语句之后，又回到了子类的构造方法中，这时子类的构造方法中同样有一条输出语句，在语句中调用了getNum()方法，这个 getNum方法同样是子类中的方法，因为此时对子类中的x已经完成了显式初始化，所以打印了D zi getnum run....5，打印完成后又回到了子类的构造方法中执行了输出语句，此时打印了C zi() : 200，至此Fu f = new Zi()完成了所有的操作，最后mian方法中的输出语句中同样调用的是子类中的getNum()方法，所以打印的是main :200
综合以上的分析，可以得出最后的结果为：
D zi getnum run....0
A fu() : 200
D zi getnum run....5
C zi() : 200
main :200

六、object类

object是所有的类的父类或者间接父类
在object类中有两个常用的方法
equlas和toString方法
equals：通常用来比较两象是个对否相等。
toString：返回对象的字符串表现形式，Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：
getClass().getName() + '@' + Integer.toHexString(hashCode())

一般来说equals和toString方法都需要被重写
案例：

package cn.test;
public class EqualsDemo {
    public static void main(String[] args) {
        Student s1 = new Student("谢群",18);
        Student s2 = new Student("谢群",22);
        boolean  result = s1.equals(s2);
        System.out.println("result:"+result);
        System.out.println(s2.toString());
        s2.setAge(18);
        result = s1.equals(s2);
        System.out.println("result:"+result);
        System.out.println(s2.toString());
        
    }
}
class Student{
    private String name;
    private int age;
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
    public Student(){}
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public boolean equals(Object s){
        if(s == null){
            return false;
        }
        if(!(s instanceof Student)){
            return false;
        }
        if(s == this){
            return true;
        }
        Student s1 = (Student)s;
        return this.name.equals(s1.name) && this.age == s1.age;
    }
    public String toString(){
        return this.name +"----"+this.age;
    }
    
    
}