目录

一、封装性

1、封装与隐藏

2、体现

3、四种权限修饰符

4、代码举例

二、继承性

1、概念

2、为什么要有继承

3、使用规则

4、重写

4、代码举例

三、多态性

 1、什么是多态性

2、虚拟方法

3、前提

4、多态是“晚绑定”，是运行时行为

5、使用

 6、代码例子

一、封装性

1、封装与隐藏

属性和功能封装起来，不允许外部干扰，当要使用那些功能或属性时，提供相应的接口

2、体现

（1）将类的属性私有化（private)，提供get和set方法来调用，完成相应设置和获取的操作

（2）私有方法

（3）单例设计模式，将构造器私有化

（4）缺省的类，无法被包外使用。

3、四种权限修饰符

4、代码举例

package com.p4;


public class Person {
    private String name;//名字
    private int age;//年龄
    private  boolean gender;//性别,ture为男性，false为女性
    //无参构造器
    public Person(){

    }
    //有参构造器，与上面无参的形成重载。
    public Person(String name,int age,boolean gender){
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

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

    public boolean isGender() {
        return gender;
    }

    public void setGender(boolean gender) {
        this.gender = gender;
    }
}

使用private对其属性、方法进行封装，私有化，外部要使用时，需要通过get、set方法，或者调用其他public方法，而这些方法中，要使用到私有属性或私有方法，才能达到效果。

二、继承性

1、概念

通过extends关键字，把两个类关联起来，如类A extends 类B，那么称类A是子类，类B是父类，子类中拥有着父类的属性、方法，如果父类的属性、方法，子类不能直接调用，但它们依然存在于子类中，子类可以拥有直接的属性和方法。

2、为什么要有继承

  （1）减少代码冗余

程序中，有些内容的属性和方法被重复出现，则使得代码冗余，为此，提供继承，把这些重复的属性、方法包装成父类，又子类去继承，从而省去了重新书写的麻烦，减少了代码的冗余。

（2）增加扩展性

当想要对程序进行扩展时，只需要对父类进行操作即可，子类也会跟着继承，增加了程序的扩展性，利于功能的扩展。

（3）联系了类与类，为多态性做前提

3、使用规则

        （1）格式calss A extends calss B

        （2）一个类可以被多个类继承，但，一个类只能拥有一个直接父类，父类的父类称之为间接父类，也就是多层继承，不过父类的父类也只能有一个。

        （3）当没有显式继承时，类默认继承类：java.lang.Object类，该类是根父类，所有的类的直接或间接的父类。

4、重写

        （1）当子父类当中，拥有同名同参数列的方法时，子类的对象会默认调用子类中的这个同名方法，这被称之为重写方法

        （2）一般规则

           

4、代码举例

        父类：Person

package com.p4;


public class Person {
    private String name;//名字
    private int age;//年龄
    private  boolean gender;//性别,ture为男性，false为女性
    //无参构造器
    public Person(){

    }
    //有参构造器，与上面无参的形成重载。
    public Person(String name,int age,boolean gender){
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

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

    public boolean isGender() {
        return gender;
    }

    public void setGender(boolean gender) {
        this.gender = gender;
    }
}

      子类Student

        

package com.p4;


public class Student extends Person{
    private double score;//成绩

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public void study(){
        System.out.println("学习！");
        
    }
}

      Test测试类

package com.p4;


public class Test {
    public static void main(String[] args) {
        //实例化Student
        Student student = new Student();
        student.setName("稀晨");
        student.setAge(99);
        student.setGender(false);
        student.setScore(900);
        System.out.println("名字："+student.getName()+"  "+"年龄："+student.getAge()+"  "
                +"性别："+student.isGender()+"  "+"成绩："+student.getScore());

    }
}

   运行结果

 子类中并没有声明name、age、gender,却可以调用，声明该类继承了Person类。

三、多态性

 1、什么是多态性

一件事物具有多种形态，例如动物这个类别，它拥有猫、狗等的形态，这些猫、狗，是动物类的子类，它们都可以说是动物，但却是动物中不同的形态，动物可以是猫，也可以是狗。

即是父类的引用，指向子类的对象。

提高了代码的通用性。

2、虚拟方法

在多态情况下，子类与父类的同名同参数方法，即重写方法。

父类此时的该方为虚拟方法，实际调用的情况，要看是父类

被赋值的是哪一个子类，实际调用的就是子类的重写方法。

3、前提

需要有重写方法，有继承关系。

4、多态是“晚绑定”，是运行时行为

编译时调用的方法是左边的父类引用，当实际运行时，却调用的是子类重写的方法，即与父类同名同参数的方法。

5、使用

子父类的属性没有多态性，即使子父类的属性同名同数据类型，子类的属性也无法覆盖父类的属性。

格式：父类类型  变量名 = new  子类（）；

子类向父类转型，自动转型：多态。

父类向子类转型，需要强制类型转换，使用instanceof进行判断，才能转型成功。

a instanceof A ，判断，a 是A类的实例。若是，两者才能转型。

子类类型  变量名 = （子类）父类变量名；  

 传型成功。

 

转型失败

 6、代码例子

Person类

package com.p4;


public class Person {
    private String name;//名字
    private int age;//年龄
    private  boolean gender;//性别,ture为男性，false为女性
    //无参构造器
    public Person(){

    }
    //有参构造器，与上面无参的形成重载。
    public Person(String name,int age,boolean gender){
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

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

    public boolean isGender() {
        return gender;
    }

    public void setGender(boolean gender) {
        this.gender = gender;
    }
    //吃饭
    public void eat(){
        System.out.println("人吃饭");
    }
}

Teacher类

package com.p4;


public class Teacher extends Person {
    private double salary;//工资
    public Teacher(String name,int age,boolean gender,double salary){
        super(name,age,gender);
        this.salary = salary;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
    public void eat(){
        System.out.println("老师吃饭");
    }
}

Student 类

package com.p4;


public class Student extends Person{
    private double score;//成绩

    public Student(String name,int age,boolean gender,double score){
        super(name,age,gender);
        this.score = score;
    }
    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public void study(){
        System.out.println("学习！");

    }
    public void eat(){
        System.out.println("学生吃饭");
    }
}

Test测试类

package com.p4;


public class Test {
    public static void main(String[] args) {

        Person person = new Person("张三",99,true);
      //父类的引用指向子类
        Person person1 = new Student("稀晨",99,true,999);
        Person person2 = new Teacher("老六",100,false,29999);

        //调用eat方法。
        person.eat();
        person1.eat();
        person2.eat();



    }
}

运行结果

 老师类和学生类都重写了eat（）这个方法，当Person的引用指向子类的对象时，运行时，调用的子类的重写方法。