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

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

一、封装

　　什么是封装？有什么用？

　　显示生活中，有很多封装的例子，例如：手机，电视机，笔记本电脑，照相机，这些都是外面有一个坚硬的壳儿。封装起来保护内部的部件。保证内部的部件是安全的。另外封装之后，对于我们使用者来说，我们看不见内部复杂的结构，我们也不需要关心内部有多么的复杂，只需要操作外部壳儿上的几个按钮就可以完成操作。

　　作用：1.保证内部结构的安全。2.屏蔽复杂，暴露简单。

　　在代码级别上，封装有什么用？

　　一个类体当中的数据，假设封装之后，对于代码的调用人员来说，不需要关系代码的复杂实现，只需要通过一个简单的入口就可以访问。另外，类体中安全级别较高的数据封装起来，外部人员不能随意访问，来保证数据的安全性。

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

　　　　不使用封装有什么问题？

如何封装？

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

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

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

 

public class Goods {
　　　//private表示私有的，被这个关键字修饰之后，该数据只能在本类中访问，出了这个类，所有被private修饰的属性就无法访问。
    private String name;  //商品名字
    private int price;  //商品单价
    private int count;  //商品数量

　　//对外提供简单的访问入口，外部程序只能通过调用一下的代码来完成访问
　　//set是设置，所以不需要返回类型用void，get需要得到，需要返回数据，所以需要用类型接受

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

　　//给set设置关卡，有的是不合理的就需要设置限制
    public void setCount(int count) {
        if(count<0){
            this.count = 0;
　　　　　　　System.out.println("不合理的数量,请重新赋值");
        }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();
    }
}