java中的封装，继承，多态

封装：

面向对象的三大特性：封装继承和多态。

封装的意义在于保护或者防止代码（数据）被我们无意中破坏。保护成员属性，不让类以外的程序直接访问和修改。

private私有，封装原则：隐藏对象属性和实现细节，仅对外公开访问方法，并且控制访问级别。封装对象的成员属性，提供一个可供操作的方法。当私有了一个属性以后，提供一个用于设置和获取的方法。

package com.zx;
//创建一个普通的类Person，普通的成员属性和成员方法
public class Person {
    String name;
    int age;
    void say() {
        System.out.println(name + age);
    }
}


package com.zx;

public class demo {
    public static void main(String[] args) {
        //创建Person对象
        Person p1 = new Person();
        //对象名.属性名直接可以赋值
        p1.age = 18;
        p1.name = "张三";
        p1.say();//张三18
    }
}


package com.zx;

//当给属性添加封装private关键字以后，外部不可以直接对象名.属性名赋值
public class Person {
    private String name;
    private int age;

    void say() {
        System.out.println(name + age);
    }
}

此时代码是报错状态

 

封装原则：隐藏对象属性和实现细节，仅对外公开访问方法，并且控制访问级别。封装对象的成员属性，提供一个可供操作的方法。当私有了一个属性以后，提供一个用于设置和获取的方法。get(获取)，set(设置)

package com.zx;

//当给属性添加封装private关键字以后，外部不可以直接对象名.属性名赋值
public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    void say() {
        System.out.println(name + age);
    }
}



package com.zx;

public class demo {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setAge(18);
        p1.setName("张三");
        p1.say();//张三18
    }
}

静态static：

通过静态修饰的属性存储到方法区中，被静态修饰的变量不需要依赖于对象进行访问，只要类被加载了，就可以通过类名访问。（非静态修饰的属性理解为对象的属性，根据图纸创建出来的一个个实例，而静态修饰的属性理解为类的属性，图纸自身已经定好的属性）。

无论一个类存在多少个对象，静态的属性和方法永远在内存中只有一份，类被加载时，静态的成员就被初始化了。

静态修饰的方法，不需要创建对象再去调用了，可以直接通过类去调用。静态的资源可被调用的时机早于非静态修饰的方法。

在访问时，静态的资源不能访问非静态，非静态可以访问静态。（非静态的资源可以使用了表示对象已经存在，对象已经存在表示类已经加载，类已经加载静态资源一定存在，所以可以去访问）。

继承：

继承允许我们编写类的时候给类进行等级层次的划分，可以把一些类变成父类，一些类变成子类。父类里边所拥有的行为和方法可以被子类所继承。

子类除了可以从父类继承以外，还可以有自己的部分。继承的有属性和方法。

使用extends关键字

package com.zx;

public class Student extends Person {
    private String number;

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public void showAll() {
        System.out.println(getName() + getAge() + number);
    }
}


package com.zx;

public class demo {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setAge(19);
        s1.setName("李四");
        s1.setNumber("1001");
        s1.say();//从父类继承的say方法李四19
        s1.showAll();//自己独有的showAll方法李四191001
    }
}

子类实例化内存分析：

java中只有单继承，多重继承，没有多继承。

多继承（贴切生活中的概念就是一个孩子有多个爹），多重继承（a和b这两个类c都想去继承，这就可以b继承a，c再继承b）。

当我们创建子类对象时，首先会先创建它的父类对象，把父类对象创建完毕之后才会创建自己，并且父类对象会作为自己这个对象里的super（指向父类）部分存在。（所谓的继承只是子类拥有父类的一个地址而已）。

权限修饰符，在子父里边能访问的只有public和protected，父的方法和属性只有这两种修饰的子类才可以操作。

抽象类：

要求：一个.Java文件只编写一个类，且这个类通过public修饰

之前编写的类，比如说描述一个人，这个人的一些细节，某些属性，某些行为，描述的很具体，这叫做实现类。

抽象的类指的是类所描述的行为和方法是模糊的。抽象类本身是不能进行实例化操作的，不能直接通过new关键字来完成。如果想对抽象的部分进行实例化创建对象，必须把抽象的部分明确，明确的方式是编写一个子类把父类中不能确定的部分明确了，这种操作称为实现实现父类的抽象方法。抽象类必须被子类所继承。

package com.zx;

//抽象类
public abstract class Person {
   //抽象方法
    public abstract void say();
    //非抽象方法
    public void show(){
    System.out.println("非抽象方法");
    }
}



package com.zx;

public class Student extends Person {

    //如果想对抽象的部分进行实例化创建对象，必须把抽象的部分明确，
    // 明确的方式是编写一个子类把父类中不能确定的部分明确了，
    // 这种操作称为实现实现父类的抽象方法。抽象类必须被子类所继承。
    @Override
    public void say() {
        System.out.println("我是Student类，实现Person类的say方法");
    }
}


package com.zx;

public class demo {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.say();//我是Student类，实现Person类的say方法
        s1.show();//非抽象方法
    }
}

抽象类常见问题：

抽象类是不能直接创建对象的。

抽象类中抽象和非抽象的方法都可以有。

抽象类不能使用final声明，final修饰的类是最终的类，不能拥有子类，不可以被继承，一个抽象类不能被继承就无法实现。

抽象类是否有构造方法？

能有构造方法，只是jvm限制开发者不能通过new来创建抽象类对象，但是java内部是可以自己创建的，当我们创建子类对象时，首先会先创建它的父类对象，把父类对象创建完毕之后才会创建自己，会把你已经实现的部分创建出来，因为抽象的部分子类已经实现了。

抽象类和普通类的区别：抽象类必须用public或protected修饰，如果把一个类私有了，私有的类子类无法继承。

在子类创建对象时，抽象父类也会被jvm实例化。

如果一个子类继承一个抽象类必须实现所有的抽象方法，如果有未实现的抽象方法，那么子类必须定义成abstract类。

abstract不能和以下两个关键字同用。

native修饰的方法代表该方法已经被实现。

private修饰的私有方法不能被继承的

接口：

接口的概念和抽象类很像，如果一个类里边有部分不能确定的地方，可以把类设计成抽象类，把能确定的部分先写好，不能确定的部分设计为抽象方法。

接口里边全是抽象部分，接口里边只能有抽象方法和全局常量。

因为接口里边都是抽象的部分，需要依赖于实现类。

接口的意义：1、弥补不能多继承的不足。2、提供统一的标准和规则，作为模板，所有的实现类都按照这个模板去写。

面向接口编程思想：

之前写代码都是把具体的细节部分先编写好，之前的面向对象，把细节部分都封装到对象里，之后来回调用这些对象来实现某个操作。

面向接口编程思想指的是我们一直关注的都是抽象部分，一个项目没有写的时候就通过抽象的方式把规范约束先定义出来（程序大概有哪些功能）,从宏观的角度先把程序设计好，但是程序流程中没有任何可实现的代码。

接口可以多实现，一个类可以实现多个接口，接口与接口之间可以继承，并且也允许多继承。

如果一个接口要想使用必须依靠子类，如果一个接口没有子类是没有意义的。

接口和抽象类之间的区别：

抽象类必须被子类继承，接口被子类实现。

接口只能声明抽象方法，而抽象类抽象非抽象都可以。

接口里定义的变量是全局常量，抽象类可以是普通变量。

抽象类使用继承，没有办法多继承，接口使用实现，可以多实现。

抽象类中可以包含static方法，而接口不行（静态方法不能被子类重写，而接口必须被子类继承实现）。

接口不能有构造方法，抽象类有。

package com.zx;

//接口
public interface  Person {
    public abstract void say();
    public void show();
}


package com.zx;

//接口必须使用implements关键字，而抽象类使用extends
public class Student implements Person {

    @Override
    public void say() {
        System.out.println("我实现Person接口里的say方法");
    }

    @Override
    public void show() {
        System.out.println("我实现Person接口里的show方法");
    }
}


package com.zx;

public class demo {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.say();//我实现Person接口里的say方法
        s1.show();//我实现Person接口里的show方法
    }
}

多态：

面向对象的三大特征：封装，继承，多态。

多态：对象的多种形态。设计的Person类（抽象类），后边有子类，一个是student。就可以称之为学生是人的一种形态。

多态可以总结一句话：父类引用指向子类对象，父类引用指的就是父类的对象名称等于（指向）子类对象。

public class demo {
    public static void main(String[] args) {
        Person p = null;
        //Person是父类，Student是子类，Student属于Person
        Student s = new Student();
        p = s;//右边s这个对象是左边类型的一种形态
        //相当于说一个学生是人，虽然说p是Person类型但是具体指向的内容是这种类型的另一种子形态
        p.say();//我是学生
    }
}

 

public class demo {
    public static void main(String[] args) {
        Student a = new Student();//创建一个学生a
        Person p1 = a;//学生a是人类p1的一种形态
        p1.say();//调用say方法，我是学生
        Student a1 = (Student) p1;//p1已经是一个人的学生形态，再转换成学生
        a1.say();//我是学生
    }
}

instanceof:

如何判断传入的对象是此类型的哪一种形态（哪个子类的对象）。

public class demo {
    public static void main(String[] args) {
    Student s=new Student();
    say(s);
    }
    public static void say(Person p) {
        //如果能进入if则意味着p就是Student的形态
        if (p instanceof Student){
            Student s = (Student) p;
            s.say();
        }else{
            System.out.println("必须传入学生形态");
        }
    }
}