Java三大特性（封装 继承 多态）

 

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
    }
}