java面向对象--封装、继承、多态

java面向对象--封装、继承、多态

封装

封装的基本思想：决定属性与行为归属谁的问题，

例如定义一个人类，那就有名称，年龄，吃饭，睡觉等的属性和行为。

在例如门类，开门，关门，高，宽

那么封装是什么呢？就是用类设计对象处理某一个事物的数据时，应该把要处理的数据，以及处理这些数据的方法设计到一个对象中去

封装我认为有两个要点：

1. 我们程序设计要追求 " 高内聚，低耦合 " ，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用
2. 封装（数据隐藏）应禁止直接访问一个对象中数据的实际表示，而是应该通过操作接口来访问，这称为信息隐藏。通俗说就是属性私有，get/set 操作数据

public class Person {
    //实现人的封装
    private String name; //私有属性
    private int age;
    private String sex;
    //get/ set
    /*
    1、提高程序的安全性，保护数据
    2、隐藏代码的细节，对外就只有一个接口
    3；、统一接口
    4、系统可维护性增加
     */
​
    public Person() {  // 有有参构造器，就必须要有无参构造器
    }
​
    public Person(String name, int age, String sex) { //有参构造器，用于生成对象的时候使用
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    //获得name
    public String getName() {
        return name;
    }
   //设置name
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public String getSex() {
        return sex;
    }
​
    public void setSex(String sex) {
        this.sex = sex;
    }
}
​

继承

什么是继承？

Java中提供了一个关键字extends，用这个关键字，可以让一个类和另一个类建立起父子关系。

public class B extends A{
  // A 类称为父类（基类或者超类）
   // B类称为子类（派生类）
}

继承的特点： 子类能继承父类的非私有成员（成员变量、成员方法)。

继承后对象的创建：子类的对象是由子类、父类共同完成的。

继承的好处和使用场景

减少重复代码的编写

public class People {
    private String name;
    public String getName(){
        return name;                //父类
    }
    public void setName( String name) {
        this.name = name;
    }
}
//子类
public class Teacher extends People{ 
    private String skill;//技能
     public string getskill(){
         return skill;
     }   
    public void setskil1(String skill) {
        this.skill = skill;
    }
}
//子类
public class Consultant extends People{
    private int number;//解答问题的总人数
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
}

需要处理讲师、咨询师的数据；讲师的数据有:姓名、具备的技能;咨询的数据有:姓名、解答问题的总人数。

都有name 属性那么就可以，封装到父类，然后子类继承；其中如果其他的类有name 属性，也可以直接继承person类，然后提高代码的复用，和重复度

继承的注意事项

1. 权限修饰符

   就是是用来限制类中的成员（成员变量、成员方法、构造器、代码块...）能够被访问的范围。

1. 单继承

   java是单继承的，java中的类不支持多继承，但是支持多层继承

   为什么不支持多继承呢？

   因为如果有两个父亲的有个方法名字相同，那么子类在继承调用的时候，就不知道应该调用哪个父亲的方法了

   class A{} 
   class B{}
   ​
   //class C extends A,B{}// 不支持多继承
   class B extends A{}
   class C extends B{}  //支持多层继承
   ​

2. Object类

   object类是java所有类的祖宗类。我们写的任何一个类，其实都是object的子类或子孙类。

3. 子类访问其他成员的特点

   1. 在子类方法中访问其他成员（成员变量、成员方法)，是依照就近原则的。

      1. 先子类局部范围找。
      2. 然后子类成员范围找。
      3. 然后父类成员范围找，如果父类范围还没有找到则报错。

   2. 如果子父类中，出现了重名的成员，会优先使用子类的，如果此时一定要在子类中使用父类的怎么办?

      1. 可以通过super 关键字，指定访问父类的成员: super.父类成员变量/父类成员方法

4. 子类构造器的特点

   1. 子类构造器的特点:·子类的全部构造器 ，都会先调用父类的构造器，再执行自己。

   2. 子类构造器是如何实现调用父类构造器的:

      1. 默认情况下，子类全部构造器的第一行代码都是super()(写不写都有)，它会调用父类的无参数构造器。
      2. 如果父类没有无参数构造器 ，则我们必须在子类构造器的第一行手写super(...) ，指定去调用父类的有参数构造器。

多态

什么是多态

多态是在继承/实现情况下的一种现象，表现为:对象多态、行为多态。

可以理解为儿子可以是父亲，儿子，男朋友多个对象

行为有：一个人跑的慢、一个人跑的快等等

多态的具体代码体现：

// people 是父类，student为子类
People p1=new Student();
p1.run()
People p2=new Student();
p2.run()
 //编译看左边，运行看右边

相反，对于变量，编译看右边，运行看左边

多态的前提 ：有继承/实现关系; 存在父类引用子类对象;存在方法重写。

多态的一个注意事项 ：多态是对象、行为的多态，Java中的属性(成员变量)不谈多态。

使用多态的好处

1. 在多态形式下，右边对象是解耦合的，更便于扩展和维护。
2. 定义方法时，使用父类类型的形参，可以接收一切子类对象，扩展性更强、更便利。

多态下的类型转换

类型转换

自动类型转换:父类变量名=new子类();

People p = new Teacher();

强制类型转换:子类变量名=(子类)父类变量

Teacher t = (Teacher)p;

强制类型转换的一个注意事项

存在继承/实现关系就可以在编译阶段进行强制类型转换，编译阶段不会报错。

运行时，如果发现对象的真实类型与强转后的类型不同，就会报类型转换异常(ClassCastException)的错误出来。

People p = new Teacher();
Student s=(Student) p;   //报错 java.Lang.CLasscastException

强转前，Java建议:使用instanceof关键字，判断当前对象的真实类型，再进行强转。

p instanceof Student; //判断当前对象是否是真实类型