黑马程序员_Java三大特性（封装 继承 多态）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1 封装

1.1 封装性的概念　

    1、封装性是面向对象思想的三大特性之一
    2、是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式 
    3、封装有：
　　　　　　属性的封装
　　　　　　方法的封装（方法本来就是一种封装体）
　　　　　　类的封装（属性和方法的集体封装）
　　　　　　组件的封装
　　　　　　模块化封装
　　　　　　系统级封装
    4、封装原则：
             　      将不需要对外提供的内容都隐藏起来             
                       把属性都隐藏，提供公共方法对其访问
    5、函数也是封装的一种体现，函数是java中最小的封装 体

1.2 封装的好处

    1、模块化，便于使用
    2、信息隐藏，将变化隔离
    3、代码重用
    4、插件化易于调试
    5、提高安全性

1.3 属性的封装

    1、把属性定义为私有的（只能在本类中直接访问）
    2、为属性提供get/set方法（通过这两个方法间接访问类中的属性）
    将属性使用private封装后，类以外即使建立了对象也不能直接访问了 。但是人应该有年龄，就需要在person类中提供对应访问age的方式（set()和get()） 
    就可以在访问方式中加入逻辑判断等语句 对访问的数据进行操作，提高代码的健壮性

public class Object_Encapsulation {    public static void main(String[] args) {        Person p=new Person();        p.setAge(20);        //p.speak();    }}class Person{    private int age;    //对外提供访问方式    public void setAge(int age){        if (age>0 && age<130){           this.age=age;           speak();        }        else            System.out.println("age feifa");    }    public int getAge(){        return age;    }//一个成员变量的访问方式一般会对应两种方式一个是set （没有返回值）一个时get（返回值时int）    void speak(){        System.out.println("age="+age);    }}

public class SixtyEight_SixtyNine_Seventy {    public static void main(String[] args) {        Person p = new Person();        p.name = "baobao";        p.age = 20;        p.say();                        //----------------------------------                Personn p1 = new Personn();        p1.setName("包包");        p1.setAge(22);        p1.say();            }}class Person{    String name;//如果没有将类的属性进行封装，外部类可以随意修改类的属性    int age;    void say(){        System.out.println("我是:"+name+",今年"+age+"岁");    }}class Personn{    private String name;//将类的属性进行封装，外部类不可以随意修改类的属性    private int age;    void say(){        System.out.println("我是:"+getName()+",今年"+getAge()+"岁");    }        //将类的属性进行封装后，需要提供一个设置属性值和获取属性值得方法（对外提供接口）   对应的是set 和 get    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;    }}

2 继承

2.1 继承的基本概念：

    1、继承是面向对象的三大特性之一
     2、被继承的类称为父类（超类），继承父类的类称为子类（派生类）
     3、继承是指一个对象直接使用另一个对象的属性和方法（继承之后才能使用）
     4、通过继承可以实现代码重用

2.2 使用继承的要求

    1、将每个类的共性提取出来单独放在一个类中来描述
     2、然后让这个类与其他每个类之间有点关系这样就可以了
     3、注意：千万不要为了获取其他类的功能，简化代码而继承
     4、必须是类与类之间有所属关系才可以继承
     5、例如：将学生和工人的共性(共同属性，共同方法)描述提取出来。单独进行描述。只要让学生和工人与单独描述的这个类有关系，就可以了。

2.3 继承的好处

    1、提高了代码的复用性
    2、让类与类之间产生了关系，有了这个关系，才有了多态的特性

2.4 继承的语法

public class extendsDemo {    public static void main(String[] args) {        HomeChicken c1 = new HomeChicken();        c1.desc();    }}//父类class Chicken{    String name;    public Chicken(){}        public Chicken(String name) {        super();        this.name = name;    }        public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public void desc(){        System.out.println("我是一只战斗鸡");    }}//子类class HomeChicken extends Chicken{    }//子类class Pheasant extends Chicken{    }

2.5 代码实例

public class ExtendsDemo1 {    public static void main(String[] args) {    }}class Person{    String name;    int age;}class Student extends Person{    void study(){        System.out.println("good study");    }}class Worker extends Person{    void work(){        System.out.println("good work");    }}

2.6 继承中使用时需要注意的

     1、java不支持多继承：java语言中只支持单继承不支持多继承（一个类继承了另一个类就不能在继承其他类了）
                 因为多继承容易带来安全隐患 当多个父类中定义了相同功能，但功能内容不同时，子类对象不确定要运行哪一个。
                 但是java保留了这种机制，并用另一种体现形式来完成表现叫做多实现
     2、java支持多层继承：java语言中支持多层继承 ,就是一个继承体系
     3、继承只能继承非私有的属性和方法
     4、如何使用一个继承体系中的功能：想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中的共性功能通过了解共性功能，就可以知道该体系的基本功能
 　5、那么具体调用时，要创建最子类的对象，  为什么呢？
        （1）是因为有可能父类不能创建对象(抽象类)
         （2）是创建子类对象可以使用更多的功能，包括基本的也包括特有的
        简单一句话就是：查阅父类功能，创建子类对象使用功能
     6、构造方法不能被继承
     7、那么在继承中不能继承父类的私有成员，怎么办呢
        （1）访问修饰符：public(公有) private(私有) default（默认（本包中的所有类都可以访问）） protected（保护型（专门继承用的，子类的对象都能狗使用被该修饰符修饰的属性或者方法））
        （2）非私有：public(公有) default（默认） protected（保护型）

public class oneHundredAndNineteenFive {    public static void main(String[] args) {        HomeDog d1 = new HomeDog("小白");        d1.name = "小黑";        d1.desc();                /*下面这个类不是Dog的子类，所以创建了对象也不能够使用Dog里的共性属性和方法        fuck f = new fuck();        f.name = "西安";        f.desc();        */    }}//父类class Dog{    protected String name;//对于父类的共性属性可以使用该修饰符，这样子类是可以继承到的    public Dog(){}        public Dog(String name) {        super();        this.name = name;    }    protected void desc(){        System.out.println("我是一只战斗鸡"+name);    }}//子类class HomeDog extends Dog{    public HomeDog(String name) {        this.name = name;    }}//子类class PheasantDog extends Dog{    }class fuck{    }

3 多态

3.1 多态性的概念

     1、多态性是面向对象的三大特性之一
     2、可以理解为事物存在多种体现形态。比如动物：猫，狗

3.2 多态性的两种情况

     1、方法的重载和重写
     2、对象的多态性

3.3 对象的多态性

     1、多态的体现
 　　　　父类的引用指向了自己的子类对象
 　　　　父类的引用也可以接收自己的子类对象
     2、多态的前提
 　　　　必须是类与类之间有关系，要么继承，要么实现。
 　　　　通常还有一个前提就是存在覆盖

3.4 多态的好处和弊端

     多态的好处：
 　　　　多态的出现大大地提高了扩展性,前期的代码可以使用后期的代码
     多态的弊端：
   　 　　提高了扩展性，但是只能使用父类的引用访问zi类中的共性成员（不能访问子类的特有的成员）

abstract class Animal{    public abstract void eat();}class Cat extends Animal{    public void eat(){        System.out.println("吃鱼");    }    public void CatchMouse(){        System.out.println("抓老鼠");    }}class Dog extends Animal{    public void eat(){        System.out.println("吃骨头");    }    public void kanjia(){        System.out.println("看家");    }}class Pig extends Animal{    public void eat(){        System.out.println("饲料");    }    public void gongDi(){        System.out.println("拱地");    }}class DuoTaiDemo {    public static void main(String[] args) {        Animal a = new Cat();//类型提升，向上转型        //function(new Cat());        //如果想要调用猫的特有方法时，如何操作        //强制将父类的引用，转成子类类型，向下转型        //Cat c = new Cat();//错误 又new了一只新猫        //Cat c = (Cat)a;//强制将父类的引用转成子类类型，强制类型转换，将动物类型转换成猫        //c.catchMouse();        /*        Animal a = new Animal();        Cat c = (Cat)a;        不能将父类对象转换成子类 类型，自始自终都是类型在变化        能转换的是父类的引用指向了子类对象是，        */    }    public static void function(Animal c){//相当于Animal c = new Cat();父类的引用也可以接收自己的子类对象        c.eat();        //instanceof用于判断对象的具体类型        if (c instanceof Cat){            Cat a = (Cat)c;            a.catchMouse();        }        else if (c instanceof Dog){            Dog a = (Dog)c;            c.kanjia();        }        //通常情况下我们不会这么判断，因为扩展性很差。如果加个子类就要再判断一次.有两种情况是用这种方法来判断的：子类是有限的，比如人要么男人要么女人    }}

3.5 在多态中成员变量的特点：

     在编译时期，参阅引用型变量所属的类中是否有调用的成员变量，如果有编译通过，如果没有编译失败
     在运行时期，参阅引用型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量
     简单总结就是：无论编译和运行，都参考左边

class Fu{    int num = 3;//如果父类没有该num，会编译失败。}class Zi extends Fu{    int num = 4;}class DuoTaiDemo4 {    public static void main(String[] args) {        Fu f = new Zi();        System.out.println(f.num);//结果是3    }}

3.6 在多态中成员函数（非静态）的特点：

     在编译时期，参阅引用型变量所属的类中是否有调用的方法，如果有编译通过，如果没有编译失败
     在运行时期，参阅对像所属的类中是否有调用的方法
     简单总结就是：成员函数在多态调用时，编译看左边，运行看右边

class Fu{    void show(){        System.out.pritnln("Fu show");    }}class Zi extends Fu{    void show(){        System.out.pritnln("Zi show");    }}class DuoTaiDemo4 {    public static void main(String[] args) {        Fu f = new Zi();        f.show();//结果是Zi show    }}

3.7 在多态中，静态成员函数的特点：

     在编译时期，参阅引用型变量所属的类中是否有调用的静态方法，如果有编译通过，如果没有编译失败
     在运行时期，参阅引用型变量所属的类中是否有调用的静态方法
     简单总结就是：无论编译和运行都参考左边

class Fu{    static void show(){        System.out.pritnln("Fu show");    }}class Zi extends Fu{    static void show(){        System.out.pritnln("Zi show");    }}class DuoTaiDemo4 {    public static void main(String[] args) {        Fu f = new Zi();        f.show();//结果是Fu show    }}