封装、继承、多态、重写、重载

封装

封装是JAVA基本概念之一，封装的好处是把数据隐藏起来，只能通过类名调用，数据更加安全；开发者只需要对类内部的代码进行修改，就可以实现所有与此类有关的程序的更新。

---

通过Set/Get方法对属性进行修改访问。
例：

public class Student {
    private String name; // 学生姓名
    private int age; // 学生年龄
    private int num; // 学生学号
        //查看学生姓名
    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 int getNum() {
        return num;
    }
        //修改学生学号
    public void setNum(int num) {
        this.num = num;
    }

}

---

抽象Class也是封装的一种。
例：

public abstract class Student1 {
    String name;
    int age;

    abstract void study();

}

这个类本身也是一种封装。

---

继承

继承是JAVA的一个特性，是通过extends关键字实现的，子类通过继承父类可以拥有父类的所有特性、功能，并拥有自己特殊的属性、功能，简化了程序员对程序的后期扩展的难度。

---

例：

public class Student1 {
    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;
    }

    public void study() {
        System.out.println(age+"岁的"+name+"在学习");
    }


}

public class Students extends Student1{
    private int num;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
    void play(){
        System.out.println("学号"+num+"的同学"+getName());
    }


}

public class Test1 {
    public static void main(String[] args) {
        Students s = new Students();
        s.setName("张三");
        s.setAge(10);
        s.setNum(1001);
        s.play();
        s.study();
    }

}

子类继承父类，拥有了父类的属性、方法，并且子类同时拥有自身特殊的属性、方法，可以在上面的代码中体现。

---

多态

一种事物多种形态，就是说有不同的表现形式在不同的环境下。
多态的三个必要条件：

• 继承
• 重写
• 父类引用指向子类对象

---

例：

public class Animal {
    String name;

    public void call() {

    }

}

public class Dog extends Animal {

    @Override
    public void call() {
        System.out.println(name + "汪汪叫");
    }

}

public class Cat extends Animal {

    @Override
    public void call() {
        System.out.println(name + "喵喵叫");
    }

}

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();
        dog.name = "旺财";
        cat.name = "花花";
        dog.call();
        cat.call();
    }

}

运行结果：
旺财汪汪叫
花花喵喵叫

---

重写和重载

• 重载：方法名相同参数列表不同（参数类型不同，参数数量不同，参数列表位置不同）
  例：

public class Demo {
    String name;
    int time;

    void show(String name) {
        System.out.println(name + "在学习Java");
    }

    void show(String name, int time) {
        System.out.println(name + "在学习Java，已经" + time + "天了");
    }

    void show(int time, String name) {
        System.out.println(name + "在学习Java，已经" + time + "天了");
    }

}

public class Test {
    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.show("张三");
        demo.show(10,"李四");
        demo.show("王五", 20);
    }

}

---

• 重写：就是子类继承父类的方法，但是做了一定的修改，具有了新的特性。
  例：

public class A {
    public String show(A num) {
        return "aaaaa";
    }

    static public class B extends A {
        @Override
        public String show(A num) {
            return "bbbbbb";
        }
    }

    public static void main(String[] args) {
        A a = new B();
    }

}

---

                                                           ——————SpringAndI