黑马程序员---面向对象核心思想总结

---------------------- 黑马程序员 Android培训、期待与您交流！ ---------------------

1：final

    (1)是一个关键字，表示的是最终的意思。
    (2)它可以修饰类，修饰成员变量，修饰成员方法。
    (3)特点：
        它修饰的类不能被继承。
        它修饰的变量是常量。
        它修饰的成员方法不能被重写。
    (4)知识点：
        修饰局部变量。

        方法的形式参数：
            基本类型：基本类型的值不能发生改变。
            引用类型：引用类型的地址值不能发生改变，但是内容可以发生改变。

2：多态
    (1)同一个对象在不同时刻表现出现的多种状态。
        举例：
            水(水蒸气,冰,水)
        理解：
            编译时期状态和运行时期状态不一致的现象。

            判断下面哪个有问题：从右边往左边念。
            Fu f = new Fu();
            Zi z = new Zi();
            Fu f = new Zi(); //多态
            Zi z = new Fu(); //报错
    (2)多态的前提：
        A:要有继承或者实现关系。
        B:有方法重写。
            因为一般都是抽象类或者接口的多态。
        C:要有父类/父接口的引用指向子类对象。
    (3)多态访问的成员特点：
        Fu f = new Zi();

        A:成员变量
            编译看左边，运行看左边。
        B:成员方法
            编译看左边，运行看右边。
        C:静态方法
            编译看左边，运行看左边。
    (4)多态的好处和弊端：
        A:好处
            提高了程序的可维护性和可扩展性。
            维护性：继承保证
            扩展性：多态保证
        B:弊端
            父类/父接口不能访问子类特有功能。
    (5)多态中的类型转换：
        A:向上转型
            Fu f = new Zi();
        B:向下转型
            Zi z = (Zi)f;

        举例：毕老师装爹 ：

class 毕爹 {
        int age = 50;    

        public void teach() {
            System.out.println("工商管理");
        }
    }

    class 毕老师 extends毕爹 {
        int age = 28;

        public void teach() {
            System.out.println("Java");
        }

        public void paly() {
            System.out.println("看电影");
        }
    }

    //别人来找他爹去讲课。他爹出差了。
    
    老毕 B爹 = new 毕老师(); //传上爹的衣服，带上爹的眼睛，粘上小胡子 (向上转型)

    System.out.println(B爹.age); //50 看起来要像爹的年龄
    B爹.teach(); //工商管理
    //B爹.paly();  报错


    //下课了，回家
   老毕B = (毕老师)B爹; //脱下爹的衣服，去掉眼睛，拔掉胡子 (向下转型)
    System.out.println(B.age); //28
    B.teach(); //Java
    B.paly(); //看电影
   

    (6)多态的体现形式：
        A:具体类多态
            class Fu {}
            class Zi extends Fu {}
        
            Fu f = new Zi();
        B:抽象类多态
            abstract class Fu {}
            class Zi extends Fu {}

            Fu f =  new Zi();
        C:接口多态
            interface Inter {}
            //接口的实现类命名：接口名+Impl
            class InterImpl implements Inter{}

            Inter i = new InterImpl();

3：抽象类
    (1)把多个类中相同的方法声明给抽取出来。定义到一个类中。
       一个方法如果只有方法声明，没有方法体，那么该方法必须定义为抽象方法。
       而一个类中如果有抽象方法，那么，该类必须定义为抽象类。
    (2)抽象类的特点：
        A:抽象方法和抽象类都必须用abstract表示。
        B:一个类继承抽象类的时候；
            要么：本身是一个抽象类。
            要么：实现抽象类中的所有抽象方法。
        C:抽象类不能实例化。可以按照多态的使用方式使用。
        D:成员特点：
            a:成员变量
                可以是变量，也可以是常量。
            b:构造方法
                有
            c:成员方法
                可以是抽象，也可以非抽象。
    (3)抽象类的好处：
        A:抽象类中的非抽象方法提高了代码的复用性。
        B:抽象类中的抽象方法强制要求子类必须重写某些方法。

    (4)抽象类的案例 ：

 举例 员工案例 ：

abstract class Employee {
    private String name;
    private int pay;

    public Employee (){}

    public Employee (String name,int pay){
        this.name=name;
        this.pay=pay;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setPay(int pay){
        this.pay=pay;
    }
    public int getPay(){
        return pay;
    }
    //
    public abstract void work();
}
class Coder extends Employee{
    public Coder(){}

    public Coder(String name, int pay){
        super(name,pay);
    }
    public void work(){
        System.out.println("根据任务,完成代码");
    }
}
class Manager extends Employee{
    
    public Manager(){
        super("张三",31);
    }

    public Manager(String name,int pay){
        super(name,pay);
    }
   
    private int bonus;

    public void setBonus(int bonus){
        this.bonus=bonus;
    }
    public int getBonus(){
        return bonus;
    }

    public void work(){
        System.out.println("判断需求,指定任务");
    }
}

class EmployeeDemo {
    public static void main(String[] args) {
        Manager e = new Manager();
        e.setName("牟经理");
        e.setPay(12000);
        e.setBonus(10000);
        e.work();
            System.out.println(e.getName()+"--月工资--"+e.getPay()+"-奖金-"+e.getBonus());
    }
}

    (5)抽象类中的几个小问题：
        A:抽象类不能实例化，构造方法有什么用呢?
            用于子类访问父类数据的初始化。
        B:如果一个类中没有抽象方法，而类却被定义为了抽象类，请问为什么?
            不让创建对象。
        C:abstract不能和哪些关键字共存：
            private: 冲突
            final: 冲突
            static: 无意义

4：接口
    (1)如果一个抽象类中的所有成员方法都是抽象的，java就提高了一种更抽象的表达方式：接口。
    (2)接口的特点：
        A:接口用interface定义。
          类实现接口用implements关键字。
        B:一个类要实现接口：
            要么：本身是抽象类。
            要么：实现接口中的所有抽象方法。
        C:接口不能实例化。可以按照多态的使用方式使用。
        D:成员特点：
            a:成员变量：只能是常量。
                      默认修饰符：public static final
            b:成员方法：只能是抽象方法。
                  默认修饰符：public abstract
    (3)类与接口的关系：
        A:类与类的关系
            继承，单继承。
        B:类与接口的关系
            实现，单实现，多实现。
            继承一个类的同时实现多个接口。
        C:接口与接口的关系
            继承，单继承，多继承。
    (4)案例：
        A:猫狗案例用接口实现基本版本。
    (5)抽象类和接口的区别:
        A:成员区别
            抽象类：
                a:成员变量
                    可以是变量，也可以是常量。
                b:构造方法
                    有
                c:成员方法
                    可以是抽象，也可以非抽象。
            接口：
                a:成员变量：只能是常量。
                        默认修饰符：public static final
                b:成员方法：只能是抽象方法。
                        默认修饰符：public abstract
        B:关系区别
            a:类与类的关系
                继承，单继承。
            b:类与接口的关系
                实现，单实现，多实现。
                继承一个类的同时实现多个接口。
            c:接口与接口的关系
                继承，单继承，多继承。
        C:设计理念不同
            抽象类被继承体现的是：is a的关系。抽象类中定义的是继承体系共性功能。
            接口被实现体现的是：like a的关系。接口中定义的是继承体系的扩展功能。

        示范案例：
            运动员和教练案例。

            分析：从具体到抽象。
            实现：从抽象到具体。

            使用：具体。

//说英语
interface SpeakEnglish {
    public abstract void speak();
}

//人抽象类
abstract class Person {
    private String name;
    private int age;

    public Person() {}

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }

    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 abstract void eat();
}

//运动员抽象类
abstract class Player extends Person {
    public Player() {}

    public Player(String name,int age) {
        super(name,age);
    }

    //学习的抽象方法
    public abstract void study();
}

//教练抽象类
abstract class Coach extends Person {
    public Coach() {}

    public Coach(String name,int age) {
        super(name,age);
    }

    //教的抽象方法
    public abstract void teach();
}

//具体的运动员类
//乒乓球运动员类
class PingPangPlayer extends Player implements SpeakEnglish {
    public PingPangPlayer() {}

    public PingPangPlayer(String name,int age) {
        super(name,age);
    }

    public void speak() {
        System.out.println("乒乓球运动员说英语");
    }

    public void eat() {
        System.out.println("乒乓球运动员吃鸡蛋和粥");
    }

    public void study() {
        System.out.println("乒乓球运动员学习如何发球和接球");
    }
}

//篮球运动员类
class BasketBallPlayer extends Player {
    public BasketBallPlayer() {}

    public BasketBallPlayer(String name,int age) {
        super(name,age);
    }

    public void eat() {
        System.out.println("篮球运动员吃牛肉喝红牛");
    }

    public void study() {
        System.out.println("篮球运动员学习如何带球和过人");
    }
}

//具体的教练类
class PingPangCoach extends Coach implements SpeakEnglish {
    public PingPangCoach() {}

    public PingPangCoach(String name, int age) {
        super(name,age);
    }

    public void speak() {
        System.out.println("乒乓球教练说英语");
    }

    public void eat() {
        System.out.println("乒乓球教练吃鸭蛋和鸭汤");
    }

    public void teach() {
        System.out.println("乒乓球教练教如何发球和接球");
    }
}

//篮球教练
class BasketBallCoach extends Coach {
    public BasketBallCoach() {}

    public BasketBallCoach(String name, int age) {
        super(name,age);
    }

    public void eat() {
        System.out.println("篮球教练吃驴肉火烧和白开水");
    }

    public void teach() {
        System.out.println("篮球教练教如何带球和过人");
    }
}
//测试类
class SportDemo {
    public static void main(String[] args) {
        //乒乓球运动员
        PingPangPlayer ppp = new PingPangPlayer();
        ppp.setName("王浩");
        ppp.setAge(35);
        System.out.println(ppp.getName()+"---"+ppp.getAge());
        ppp.speak();
        ppp.eat();
        ppp.study();
        System.out.println("------------------------------");

        //篮球运动员
        BasketBallPlayer bbp = new BasketBallPlayer();
        bbp.setName("易建联");
        bbp.setAge(30);
        System.out.println(bbp.getName()+"---"+bbp.getAge());
        bbp.eat();
        bbp.study();
    }
}

---------------------- 黑马程序员 Android培训、期待与您交流！ ---------------------