封装

为什么要使用封装

我们程序设计要追求“低耦合，高内聚”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合是仅暴露少量的方法给外部使用，尽量方便外部调用。

编程中封装的优点

提高程序的安全性，保护数据；
隐藏代码的实现细节；
统一接口；
系统的可维护性增加了。

简介概述封装的实现：

在类中把定义的属性私有了，然后利用get获取这个数据，set给这个数据设置值完成外部的调用。

实例

public class Student {
    //属性私有
    //姓名 学号 性别
    private String name;
    private int id;
    private char sex;
    private int age;
    //提供一些可以操作这个属性的方法！
    //提供一些public的get set的方法
    //get获取这个数据
    public String getName(){
    return this.name;
    }
    //set给这个数据设置值
    public void setName(String name){
        this.name=name;
    }

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge(){
        return this.age;
    }
    public void setAge(int age) {
        if (age>=120||age<=0) {
            this.age=3;
        }else{
            this.age = age;
        }

    }
    //学习()   睡觉()
}

外部的调用

public static void main(String[] args) {
    Student s1 = new Student();
    s1.setName("王飞超");
    System.out.println(s1.getName());
    s1.setAge(999);
    System.out.println(s1.getAge());
}

继承

什么是继承

简单来说，继承就为子类继承父类。当子类继承了父类，就会拥有父类的全部方法。

注：私有的类无法被继承

super注意点:
    1.super调用父类的构造方法，必须在构造方法的第一个
    2.super必须只能出现在子类的方法或者构造方法中!
    3.super和this不能同时调用构造方法
VS this
    代表的对象不同
        this:本身调用这个对象
        super:代表父类
    前提:
        this:没继承也能使用
        super:只能在继承条件下才能使用
    构造方法:
        this();本类的构造
        super();父类的构造

public >default>protected>private

实例

父类

public class Person {
    public Person(){
        System.out.println("Preson无参构造执行了");
    }
protected String name="woawo";
//私有的东西无法被继承
public void print(){
    System.out.println("Person");
}

子类

public class Student extends Person {
private String name="woziji";
public Student(){
    //隐藏代码:调用了父类的无参构造
    super();//调用父类的构造器，必须要在子类构造器的第一行
    System.out.println("Student无参构造执行了");
}
public void print(){
    System.out.println("Student");
}
public void test1(){
    print();
    this.print();
    super.print();

    }
public void test (String name){
    System.out.println(name);
    System.out.println(this.name);
    System.out.println(super.name);
}
}

测试类

public static void main(String[] args){
    Student student=new Student();
    student.test("我自己");
    student.test1();
}

方法的重写

需要有继承关系，必须是子类重写父类的方法！

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大但是不能缩小
抛出的异常：范围可以缩小但是不能扩大 ClassNotFountException-->Exception(大)

重写是子类方法必须和父类方法保持一致，方法体不同。

为什么要重写？

父类的功能子类不一定需要，或者不一定满足。

实例

父类

public class B {
public  void test(){
    System.out.println("B=>test()");
}

子类

public class A extends B{
    @Override//方法的注解:有功能的注释
    public void test() {
        System.out.println("A=>test()");
    }
}

测试类

public static void main(String[] args) {
      //静态方法和非静态方法区别很大
      //静态方法://方法的调用只和左边，定义的数据类型有关
      A a=new A();
      a.test();//A
      //父类的引用指向了子类
      B b=new A();
      b.test();//B

多态

概念

同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性。

多态的注意事项

多态是方法的多态，属性没有多态
父类和子类，有联系！ClassCastException;
存在的三个条件：
- 继承关系
- 方法需要重写
- 父类引用对象指向子类
  
  Father a= new Son();

实例

父类

public class Person {
    public void run(){
        System.out.println("run");
    }
}

子类

public class Student extends Person{
public void run(){
    System.out.println("son");
}
public void eat(){
    System.out.println("eat");
}
}

测试类

public static void main(String[] args) {
    //一个对象的实际类型是确定的
    //new Student();
    //new Person();
    //可以指向的类型就不确定了:父类的引用指向了子类
    //Student能调用的方法都是自己的或者继承父类的
    Student s1 = new Student();
    //Person父类型，可以指向子类，但是不能调用子类的方法
    Person s2=new Student();
    Object s3=new Student();
    //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
    ((Student) s2).eat();//子类重写了父类的方法，就是执行子类的方法
    s1.run();
}

封装继承多态

封装