java的三大特征：封装，继承和多态

有点递进关系，继承增加了代码的复用性，多态必须基于继承才可以实现。

一、封装

　　使用原因：当我们没有为类进行封装的时候，类中定义的属性可以被外界随意访问，这样容易造成一些合法性的问题。封装可以非常好的解决这个问题。

　　步骤：1.先把我们希望外界不要直接访问属性设为private

　　　　   2.创建一个set方法来帮助外界为该变量赋值，创建get方法来帮助外界为该变量取值

　　　　   3.形成规范，每一次在类中编写不适合被外界直接访问的属性时，一律按照套路把属性设为私有，生成set和get方法

public class Goods {

    private String name;  //商品名字
    private int price;  //商品单价
    private int count;  //商品数量

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        if(count<0){
            this.count = 0;
        }else {
            this.count = count;
        }
    }
}

public class TestGoods {

    public static void main(String args[]){
        Goods goods = new Goods();
        goods.setCount(2);
        System.out.println("商品的数量是:"+goods.getCount());
    }
}

构造方法：如果一个对象有多个属性，那么，需要创建很多对象，为了解决重复的set值，所以就用到了构造方法；

　　1.每一个类都有一个隐形的默认的无参数的构造方法。比如上面的 Goods goods = new Goods();

　　2.构造函数的语法很鲜明，访问修饰符 类名(参数列表)；   构造方法必须与类名同名

　　3.构造方法可以有很多个，实例化的时候需要传入对应的参数。

public class Student {

    private String name;
    private int age;
    private char sex;

    public Student(String name, int age, char sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public Student(String name, char sex){
        this.name = name;
        this.sex = sex;
    }

    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 char getSex() {
        return sex;
    }

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

public class TestStudent {

    public static void main(String[] args){
        Student student1 = new Student("张三",25,'男');
        Student student2 = new Student("李四",'男');
        System.out.println("学生的名字是："+student1.getName()+", 年龄是："+student1.getAge()+", 性别是："+student1.getSex());
        System.out.println("学生的名字是："+student2.getName()+", 性别是："+student2.getSex());
    }
}

二、继承

　　意义：父类和子类，子类可以继承父类的某些属性和方法,但是私有的不可以被继承。

重写：当某些方法不适用与子类的时候，子类可以重写他的方法，方法名称参数不变，只是内容会改变。

super：就是基类中的，表示当前类的父类

（在子类中右键，点击generate）                      （然后点击override methods，就会出现重写的方法）            （会让你选择要重写那个方法）

     

public class Father {

    private String name;
    private int age;
    private String hobby;

    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 String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }

    public void teach(){
        System.out.println("教育孩子");
    }
}

public class Son extends Father{

    @Override
    public void teach() {
        super.teach();
    }
}

public class TestSon {

    public static void main(String[] args){
        Son son = new Son();
        son.teach();
        son.setAge(6);
        System.out.println(son.getAge());
    }
}

三、多态（父类的引用可以指向子类的实例，子类有很多不同的）father可以叫做对象，变量，引用，句柄，右半边的代码创建了一个son的实例

前提：必须要有继承关系

精准概述：父类的引用指向子类的实例

意义：提升灵活性，降低耦合度

特点：只有继承关系才可实现多态

可以将子类的对象实例赋值给其父类的变量

　　  主要基于方法的重写进行体现

　　　不可以调用子类中有的父类中没有的方法。

public class Son extends Father{

    @Override
    public void teach() {
        System.out.println("儿子要好好学习");
    }
}

public class Daughter extends Father{

    @Override
    public void teach() {
        System.out.println("女儿要好好学习");
    }
}

public class TestSon {

    public static void main(String[] args){

        Father father = new Son();
        father.teach();
        father = new Daughter();
        father.teach();
    }
}