Java 面向对象的概念

封装的概念，顾名思义就是将一些东西进行一个封装，下面我们来看一个例子

就我们所见的电视而言，电视中有很多复杂的线路，由很多很多的像素组成了我们看到的画面，我们不能也不会对那些电路进行操作，而我们只需要操作手中的遥控器，就可以对这台复杂的机器进行操作，这就是封装(将一堆复杂的东西封装起来，暴漏出一个接口供外部使用)

这就大大的提高了我们程序的安全性

java提供了一个修饰符(private)，被这个修饰符修饰的属性或方法，都会变成私密的，仅供同类中访问，外部访问不到

public class Pet {

    // 封装可以避免被直接操作类中的属性，保证了属性的安全性
    // 暴漏在外的set方法可以对操作做一个安全检查
    // 通常应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这成为信息隐藏

    public Pet() { // 无参构造器
        System.out.println("创建了一个Pet对象");
    }

    public Pet(String name,short age,short height){ // 有参构造器
        this.name = name;
        this.age = age;
        this.height = height;
    }

    private String name; // 私有属性 姓名
    private short age; // 年龄
    private short height; // 身高

    public String getName() {
        return name;
    }

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

    public short getAge() {
        return age;
    }

    public void setAge(short age) {
        if(age<0 || age>100){ // 我们可以在set里面做一些校验
            this.age = 0;
        }else{
            this.age = age;
        }
    }

    public short getHeight() {
        return height;
    }

    public void setHeight(short height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "Pet{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
}

我们给这些私有的属性专门写了get(获取)和set(设置)方法，我们可以在set某一个属性时进行一些操作，比如要求大于0或者要求必须时汉字，这些都可以做到

下面我们来看一下继承的概念:

我们每个人都有一个父亲，而我们会在我们的父亲哪里继承他的所有东西(前提是这些东西他没有私有化，愿意给我们继承)

我们创建的类也是如此，都有一个父类，我们用extends关键字来继承父类，我们所有的类都默认继承了一个类，这个类就是Object类，也就是说，Object类是所有类的父类

那么我们继承一个父类，能干什么呢？

我们继承一个父类，就相当于用于了父类的属性和方法(非私有的，可被继承的)，我们可以用子类扩展父类

下面我们用两个类来演示一下

父类:

public class polyTestOne {

    public void polyTest(){
        System.out.println("我是父类方法的Test");
    }

}

子类:

public class polyTestTwo extends polyTestOne{

    public void polyTestTwo(){ // 子类独有的方法
        System.out.println("我是子类独有的方法");
    }

}

我们来实例化一下:

public class Main {

    public static void main(String[] args) {
        polyTestOne one = new polyTestOne(); // 实例化一个父类对象
        one.polyTest();

        polyTestTwo two = new polyTestTwo(); // 实例化一个子类对象
        two.polyTest();
        two.polyTestTwo();
    }

}

下面我们来看一下多态的概念:

我们大家都是人类中的一员，我们把人类看成一个类，我们都是人类，那我们都是程序员，我们可以把程序员也分为一个类，那我们把程序员的父类就是人类，那我们声明一下自己

程序员  李彦庆  =  new 程序员();

这样我就实例化了一个我自己，那么我的类型是程序员，我也可以用程序员的父类声明自己

人类  李彦庆  = new 程序员();

父类的引用指向子类的实例，这就是多态

下面我们来演示一下:

先创建一个父类

public class instanceofTestOne {

    public String name; // 姓名
    public short age; // 年龄
    public short height; // 身高
    public boolean gender; // 性别

    private boolean running; // 跑步

    public void setRunning(boolean running) {
        this.running = running;
    }

    public boolean isRunning() {
        return running;
    }

    public void perseverance(){
        System.out.println("我有不屈不挠的精神");
    }

    @Override
    public String toString() {
        return "instanceofTestOne{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                ", gender=" + gender +
                ", running=" + running +
                '}';
    }
}

然后创建一个子类:

public class instanceofTestTwo extends instanceofTestOne{

    private boolean fitness; // 健身

    public boolean isFitness() {
        return fitness;
    }

    public void setFitness(boolean fitness) {
        this.fitness = fitness;
    }

    @Override
    public void perseverance() {
        System.out.println("我不会服输的");
        super.perseverance();
    }

    public void test(){
        System.out.println("子类独有的方法");
    }

    @Override
    public String toString() {
        return "instanceofTestTwo{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                ", gender=" + gender +
                ", fitness=" + fitness +
                "} " + super.toString();
    }
}

我们实例化一个父类:

        instanceofTestOne one = new instanceofTestOne();
        one.name = "李彦庆";
        one.age = 18;
        one.gender = true;
        one.height = 175;
        one.setRunning(true);
        System.out.println(one.toString());

我们实例化一个子类:

        instanceofTestTwo two = new instanceofTestTwo();
        two.name = "李彦庆";
        two.age = 18;
        two.gender = true;
        two.height = 175;
        two.perseverance();
        two.setRunning(true);

我们用多态来实例化一个对象 

        instanceofTestOne three = new instanceofTestTwo(); // 多态
        three.perseverance(); // 父类引用指向了子类实例 子类重写了父类的方法
        System.out.println(three.toString());

我们可以使用 instanceof 来查看一个实例是否属于一个类(或者这个类的父类)

        System.out.println(three instanceof instanceofTestOne); // 查看此多态的实例是否属于 instanceofTestOne 类
        System.out.println(two instanceof instanceofTestOne); // 查看 instanceofTestTwo 的实例是否属于 instanceofTestOne 类
        System.out.println(one instanceof instanceofTestOne); // 查看 instanceofTestOne 的实例是否属于 instanceofTestOne 类

一个实例可以调用的方法，取决于实例的类型，也就是说，多态化创建的实例可使用的方法和属性取决于父类有什么方法和属性，如果父类的方法无法满足需求，我们可以在子类中重写这个方法，这样在调用某一个方法时，调用的就会是子类重写的方法

重写:

父类:

public class polyTestOne { // 多态类 测试

    public void polyTest(){
        System.out.println("我是父类方法的Test");
    }

}

子类:

public class polyTestTwo extends polyTestOne{ // 我是多态子类 测试

    @Override
    public void polyTest() { // 重写了父类的方法
        System.out.println("我是子类方法的Test");
    }

    public void polyTestTwo(){ // 子类独有的方法
        System.out.println("我是子类独有的方法");
    }
}

使用@Override注解来声明要重写的方法，当然这里先不需要太了解注解，重写的方法除了方法体，其他都要与父类的方法方法相同，上面我们就是重写了父类的 polyTest 方法

        polyTestOne three = new polyTestTwo(); // 多态 也就是父类的引用指向了子类的实例
        three.polyTest(); // 如果子类重写了父类的方法 那么调用的是子类的方法

最后总结一下概念:

        // 现在有一个类 是人类 我属于人类中的一类 男人类
        // 我是男人类中的一个实例 李彦庆

        // 我封装了我自己的内脏 我只能使用我内脏暴露出来的功能 比如肺用来呼吸 胃用来消化 无法随意自如的操控这些 这就是封装的意义
        // 我继承了我爸所有暴漏在外的东西 包括 财产 想法 经验 这就是继承的意义
        // 我是人类中的一员 我的类型可以是人类 我的实例是我自己 但由于我的类型是人类 所以我只能使用所有人类都会的方法 因我我不能确定我会的东西所有人都会
        // 所以人类的引用可以指向我的实例 但是只能使用人类都会的方法 这就是多态
        // 而我现在的类型是人类 实例是李彦庆 我也可以强制将我转换为李彦庆类 使用我本就有的方法 这就是强制类型转换
        // 比如正常人类五公里跑三十分钟 那我跑了二十五分钟 我将这个方法重新定义了 这就是重写