面向对象语言的三大特征

封装

一次多意 平常讲的封装 ：五子棋 判断棋子坐标，判断输赢....封装（包装，提取，抽取）了判断坐标判断输赢德两个方法

面向对象讲的封装：指的是通过访问权限修饰符，使得类中的信息是否对外可见（隐藏类中的信息）

例子 对属性私有化

package com.ffyc.javaoop.day2;public class Person {    
    /*    封装使用案例使用private这个权限修饰符对成员变量进行修饰，在其他类中访问不到     */    
    private String name;    
    private int age;    
    //为封装起来的成员变量提供一个特定的公共权限的方法为其赋值   
    //方便我们自己加入控制语句
    //name属性赋值
    public  void setName(String name) {        
        if (name != null || name.length() < 10) {  
            this.name = name;        
        }    
    }    
    //获取name属性
    public String getName (){        
        return this.name;    
    }
}

package com.ffyc.javaoop.day2;public class TestPerson {
/*    
在其他地方可以对person中的name进行赋值不好控制赋值操作     
*/    
public static void main(String[] args) {
    Person a = new Person();
    a.setName("null"); 
    System.out.println(a.getName());
    }
}

/*把方法私有化 */
private static Person person =null;
private Person(){
​
}
public static Person center() {
    if (person == null) {
        person = new Person();
    }    
    return  person;
}

继承

子 继承 父

用来实现代码的重用 子继承父之后就可以实现父的功能不需要重复定义

代码扩展 在自己类中扩展自己特有的功能，不影响别的类

语法：基类--派生出-->新的类

人类(基类/父类 把人共有的属性和行为定义在基类中，让其他类去继承即可)

例：

学生 姓名，性别，年龄 吃东西（）{}

老师 姓名，性别，年龄 吃东西（）{}

工人 姓名，性别，年龄 吃东西（）{}

............

相如同一类事物，都可以使用继承来实现

符合什么是什么的关系 即is-a关系

是实现代码重用的根基

用extends关键字来继承

继承有传递性，但是一个类不能继承多个类

当一个类没有继承其他类时，默认继承Object
Object类是java中所有类的基类（父类）

继承中的·构造方法

子类构造方法执行时先调用父类构造方法
构造方法的作用是用来为对象中的属性进行赋值操作的
因为子类拥有父类中的成员，所以需要对父类中的成员也要进行初始化

调用了父类的构造方法并不会创建一个父类对象

在子类构造方法中，默认是有调用的，使用的是super（）进行调用父类的无参构造并且在子类构造方法的第一行

使用super访问父类，对父类中的成员（构造方法，成员变量，成员方法）进行访问

方法重写

重写/覆写/覆盖

应用：当父类中的方法实现（功能）不能满足子类需求实可以在子类中对父类的方法进行重写（覆盖）

如果出现这种情况我们就将父类中的方法,原封不动（方法结构）在子类中进行定义

称为在子类中重写或者覆盖父类中的方法

@Override注解标签，表示此方法是从父类中重写而来，在编译期间进行语法上的检验

重写要求：

方法的结构与父类保持一致

方法名一致

参数一致

返回值一致

访问权限等于大于父类权限

注意：构造方法，静态方法，成员变量 不能重写

抽象类

类是抽象的，是概念，不能直接用

抽象方法--->概念方法--->不能用的方法

在java中有一种方法，没有方法体（没有具体的实现）称为抽象方法，用来定义功能，定义规范

/*abstract修饰的类叫抽象类
一旦类中有不完整的，没有实现的抽象方法，那么这个类也是一个抽象类abstract修饰的方法叫抽象方法
抽象方法没有方法体，没有具体实现，主要是用来定义功能
*/
public  abstract void eat();

越顶级的类，一般都是抽象的

值定义功能，不具体实现

让子类继承来实现

抽象类除了不能创建对象外，类的其他功能都有，成员变量成员方法构造方法都有

多态

多态是一种状态

同一种事物，在不同时刻表现不同的状态

条件：1.要有继承（包括接口的实现）

2.要有重写（前提条件）

3.父类引用指向子类对象

package com.ffyc.javaoop.day5;
public class Test1 {
    public static void main(String[] args) {
        //        Dog d = new Dog();
        //        Cat c = new Cat();
        //父类引用指向子类对象，但是最终执行对象是等号右边子类自己的方法
        //多态状态下使用父类类型进行成员方法访问时特点：编译看左边，运行看右边
        Animal d = new Dog();
        d.eat();//输出子类内容
        Animal c = new Cat();
        c.eat();        
        Animal wc = new Dog();
        wc.eat();//非静态成员方法：编译看左边，运行看右边
        wc.showinfo();//对于静态成员方法编译和运行都看左边
        System.out.println(wc.num);//对于成员变量编译和运行都看左边
    }
}

非多态的程序设计，每扩展一个新的动物，代码就需要做出改动

使用多态语法，将子类类型都上升为父类类型，可以使用一个父类类型表示任意子类对象，使得程序扩展性更加良好

java中最大的类Object就是用来服务多态的

缺点：上升为父类类型后不能访问子类类型特有的方法

解决：将父类类型向下转为子类类型

instanceof判断运行的类型是否为指定类型