初级面向对象总结

一、类和对象

? 类：类事物的抽象的模板，在现实世界中，类就是任意一类事物，它在程序中就是一个描述这类事物的文件

? 对象：在这类事物中，具体的某一个个体就是对象，在程序中对象就是new出来的有内存空间的

1、类和对象的关系、以及类和类的关系

? 类和对象的关系：雷士抽象的而对象是具体的，对象是由类创建的实例（new出来的）

? 案例：

? 类的组成（人类）：

? 类名：给某一类事物取名字—People

? 静态的特征称为属性：名字、年龄、身高、体重（定义变量的语法）

? 动态的行为称为方法：吃饭、睡觉、打豆豆（方法大的定义依然满足方法的语法）

? 类的实现：

? 在一个类文件（People）中，定义属性和方法

? 对象的实现：

? 通过类名创建这个类的对象

? 注意：类名不能直接访问，它里面的属性和方法的，必须通过类的对象访问

public class People {
    //定义姓名属性  指定数据类型   属性名 ={初始值}
       //定义名称属性
        String name = "张三";
        //定义性别属性
        String sex = "男";
        //定义身高属性
        double height =175;
        //定义体重属性
        double weight =140;

    /**
     * 定义吃饭方法
     */
    public void eat(){
            System.out.println("正在吃饭");
        }
    /**
     * 定义睡觉方法
      */
    public void sleep(){
            System.out.println("正在睡觉");
    }
    /**
     * 定义打豆豆方法
     */
    public void playGame(){
            System.out.println("正在打游戏");
    }
    /**
     * 定义加法算术
     */
    public int add(int a,int b ){
        return a+b;
    }
}

调用：

public static void main(String[] args) {
        //不能通过People直接访问它，需要创建类的实例，也就是对象
        //创建对象的过称为类的实例化
        //语法    类名  对象名 =  new  类名（）；
        People people = new People();
        //这时候才可以通过对象名  访问这个对象具有的 属 性 和 方 法
        //对象名.属性名
        //对象名.方法名（【实参】）
        System.out.println("这个对象的属性name：——" + people.name);
        System.out.println("这个对象的属性sex：——" + people.sex);
        System.out.println("这个对象的属性wieght：——" + people.weight);
        System.out.println("这个对象的属性height：——" + people.height);
        //调用对象的方法
        people.eat();
        people.sleep();
        people.playGame();
        int result = people.add(2, 8);
        System.out.println("这个对象的计加法——" + result);
    }

在类中定义的属性，称为“成员属性”、在类中定义的方法，称为“成员方法”

?

二、面向对象的三大特征

1、封装

? 将类中的成员属性私有化，并提供共有的访问属性的方法，为了最大程度保护类中属性的隐蔽性（不被其他对象改变），对类中的成员方法公开

? 生活中的封装：例如 笔记本 的内部结构统一疯涨，一般人使用笔记本时 不需要了解笔记本的结构，而是直接开机使用

1.1、对类成员属性的封装

? 将属性私有化（private）， 提供对属性的访问给属性添加公用的getter和setter方法

? 1.2、对代码的封装

? 为了提高代码的复用性，尽量使用方法加参数传递对代码进行封装，并使该方法公用（public）

案例：

public class People {
    private String pname;
    private int age;
    private String sex;
    //提高getter(获取)  和 setter(设置)
    public String getPname(){
        return pname;
    }
    public void setpnme(String pname){
        this.pname = pname;
    }
    public int getAge(){
        return age;
    }
    public String getSex(){
        return sex;
    }
    public void setSex(String sex){
        this.sex = sex;
    }
    public void setAge(int age){
        // 对成员属性的隐蔽性 可以防止随意对属性更改
        if (age>100||age<0){
            System.out.println("设置的年龄不合法");
        }else {
        this.age = age;
        }
    }

    //通用为了方便给属性赋值，会提供有参构造器
    public People(String pname,int age,String sex){
        this.pname=pname;
        this.age=age;
        this.sex=sex;
    }
    public People(){

    }
    //对代码的放在 是将功能写在方法中 或者 代码块中
}

调用：

    public static void main(String[] args) {
        //创建对象
        People people = new People();
        //不能直接访问私有的成员，只能通过访问方法
        people.setpnme("张三");
        people.setSex("男");
        people.setAge(18);
        System.out.println(people.getAge());
    }

对于Boolean类型的属性，需要使用is返回属性的值

    boolean flag;
    //对于boolean类型的 方法提供 返回属性值的方法使用is开头
    public boolean isFlag(){
        return flag;
    }
    public void setFlag(boolean flag){
        this.flag = flag;
    }

? 1.3、封装的优点

? 1、良好的封装可以减少类的耦合性（类与类的关联）

? 2、对类中封装的代码可以自由修改，而不会影响其他类

? 3、最大程度提供类中属性的隐蔽性 和 对属性的控制

2、继承

? 用于定义类与类的关系的方法，一个类可以继承一个类，当多个类都存在相同属性和行为时，可以将这些共有的属性和行为定义到一个新的类中，让其他类附庸这个新类的属性和行为，这种关系就是继承关系

? 继承的语法：

? 先定义父类

public class 父类名{
    
}

? 在定义子类

public class 子类名 extends 父类名{
    
}

? 2.1、子类继承父类，子类拥有父类的哪些属性和方法？

? 可访问的：子类拥有父类的共有属性和方法，同包下面的属性和方法，不同包下受保护的也可以访问。

? 不可访问的：其中子类不能继承父类私有的属性和方法，不同包默认属性和方法，不能继承父类的构造器

? 2.2、子类继承父类，子类如何访问父类的属性和方法

? 属性：子类通过super关键字访问父类的属性，子类通过this关键字访问自己的属性

? 方法：子类通过super关键字访问父类的方法，子类通过this关键字访问自己的方法

? 注意：这里的this和super可以省略，省略后子类通过”就近原则“访问属性和方法（子类中存在就访问子类的，子类中不存在的，就访问父类的）

? super.属性

? super.方法（参数）

? 构造器：子类通过super（[参数]）调用父类的构造器，子类通过this（[参数]）调用自己的构造器，其中super([参数])必须写在子类构造器的第一行

通过子类构造器手动调用父类的有参构造器给父类的属性赋值

/**
 * @Author: Qijian
 * @Date: 2020/10/8 16:08
 * @Description: 员工类
 */
public class Employee {
    String ename = "小朱";  //员工姓名
    double sal = 5000; //员工工资

    public void work() {
        System.out.println(ename + "员工在好工作！！！");
    }

    //父类的有参构造器
    public Employee(String ename, double sal) {
        this.ename = ename;
        this.sal = sal;
    }

    //无参构造器被覆盖
/*    public Employee(){

    }
    */
}

/**
 * @Author: Qijian
 * @Date: 2020/10/8 16:12
 * @Description: 经理类
 */
public class Manager extends Employee {
    //奖金
    private double comm;
    double sal = 666;

    //自动调用父类的无参构造器
    //public Manager（）{
    //      super（）；
    // }

    public Manager(String ename, double sal, double comm) {
        //如何覆盖父类的无参构造器，手动调用父类的有参构造器
        super(ename, sal);
        this.comm = comm;
    }

    public double getComm() {
        return comm;
    }

    public void manmagerInfo() {
        //访问父类的属性  访问父类的方法
        System.out.println(super.ename + "的工资：" + super.sal);
        super.work();
        //也可以通过this访问自己的方法
        System.out.println("奖金：" + this.getComm());
    }

    public void manmagerInfo2() {
        //super  和 this 可以省略
        //先从子类自己查找是否存在该方法，如何在父类中查找
        work();
        System.out.println(ename + "的工资：" + super.sal + "自己的工资：" + this.sal + "——" + sal);
    }
}

注意：子类构造器中默认调用父类的无参构造器

? 2.3、java中只能单继承，一个类只有唯一父类，可以实现多层继承

? 子类—>父类—>父类的父类

? 例如：Pupll—>Student—>People

? 创建子类对象时，优先创建父类对象，在创建子类对象，执行顺序：最上层父类—>父类—>子类

扩展问题：当一个类中存在static元素时，它们的执行顺序是如何？

? 顺序：最上层父类的静态块—>父类的静态块—>子类的静态块—>最上层父类的 构造块和构造方法—>父类的构造块和构造方法—>子类的构造块和构造方法

public class People {
    static {
        System.out.println("这是People类的静态代码块！");
    }
    public People(){
        System.out.println("这是People类的无参构造器！");
    }
    {
        System.out.println("这是People类的构造器语句块！");
    }
}
public class Student extends People {
    static{
        System.out.println("这是Student类的静态代码块！");
    }
    public Student(){
        System.out.println("这是Student类的无参构造器！");
    }
    {
        System.out.println("这是Student类的构造器语句块！");
    }
}
public class Pupll extends Student {
    static {
        System.out.println("这是pupll类的静态代码块！");
    }
    public Pupll(){
        System.out.println("这是pupll类的无参构造器！");
    }
    {
        System.out.println("这是pupll类的构造器语句块！");
    }
}

调用测试：

public class TestPeople {
    public static void main(String[] args) {
        Pupll pupll=new Pupll();
    }
    //静态代码块最先执行
    //构造块和无参构造器平级   构造快>无参构造器
}
//执行结果
这是People类的静态代码块！
这是Student类的静态代码块！
这是pupll类的静态代码块！
这是People类的构造器语句块！
这是People类的无参构造器！
这是Student类的构造器语句块！
这是Student类的无参构造器！
这是pupll类的构造器语句块！
这是pupll类的无参构造器！

2.4、重写

2.2.1、重写的前提

? 子类可以继承父类的方法，但是当父类的方法不能满足子类的需要时，子类可以重写父类的方法

2.2.2、重写的必要条件

1. 两个方法名必须相同，且存在不同类中（父子关系的类）
2. 子类重写的父类的方法，其方法的参数和返回值必须完全一样，方法的具体实现可不一样
3. 访问修饰符必须大于或等于父类的修饰符

注意：子类的对象 调用父类方法时，如果子类重写父类的方法，则执行子类的方法，没有重写，则执行父类的方法

3、多态

? 在继承关系中，一个类的对象可能呈现不同的状态，为了适应需求和多种变化，使代码更加通用，同一行为，具有多个不同的表现形式

? 生活中的多态：同一行为，例如跑，人是两条腿，动物是四条腿或两条腿跑，飞的行为不同是事物飞的方式也不同，飞机飞，小鸟飞，无人机飞都不一样，同一种行为对于不同事物呈现的不同形态就是多态的表现

3.1、实现多态的前提

• 基于继承关系或者基于实现关系的
• 子类或实现类必须对方法进行重写（没有重写的方法不具有多态行为）
• 父类的引用是指向子类对象（接口的引用指向实现类的对象）

?

3.2、多态的对象转型

? 3.2.1、子类对象转父类对象时，称为上转型是默认转换，自动转型

public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}
public class Cat extends Animal {

    public void eat(){
        System.out.println("猫吃??");
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

Cat cat= new Cat();
       //猫类 可以是一只动物 an4的本质还是 猫对象
       Animal an4=cat; //子类对象转成父类对象 是自动转换
        cat.eat();
        an4.eat();

? 3.2.2、父类的引用转成子类对象，称为向下转型，向下转型需要强转，为了避免转换错误，需要先判断数据类型是否匹配

        //创建一个动物类，将动物转成子类引用
        Animal an5=new Cat();
        //an5.catchMouse();  //动物类型对象不能访问 它子类特有的方法
        if (an5 instanceof Cat){
            Cat cat2=(Cat) an5;
            cat2.eat();
            cat.catchMouse();
        }

instanceof：判断给对象是否属于该类型

? 为什么需要做类型转换？

回答：有时候我们需要调用子类特有的方法时 必须用子类的引用。所有多态对象下父类应用需要强转。

?

? 为了避免ClassCastException的发生，java提供了instanceof 关键字，给引用变量做类型的效验，格式如下

变量名 instanceof 数据类型如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false

? 3.3、在多态环境下，方法和属性的调用规则

? 属性：当子类和父类中存在相同属性时，以对象左边引用的的类型为依据，所谓”看左边“

? 方法：以当前new出来的对象为依据，如果方法重写了就调用子类的，如果没有重写，就调用父类的

? 静态方法：无论方法是否有重写，都以对象左边的引用为依据，所谓”看左边“

public class People {
    int age = 18;
    String sex = "男";


    public void showAge() {
        System.out.println("年龄" + this.age);
    }

    public void sleep() {
        System.out.println("睡觉的方法——————");
    }

    public static void method1() {
        System.out.println("method1-------------");
    }

    public static void method2() {
        System.out.println("method2———————");
    }
}

public class Student extends People {
    int age=20;
    @Override
    public void showAge() {
        this.age++;
        System.out.println("年龄：" + this.age + "———" + super.age);
    }

    //重写的静态方法
    public static void method1() {
        System.out.println("method1——————重写后的方法");
    }

}

//测试
    public static void main(String[] args) {
        People p1 = new People();
        System.out.println(p1.age); //18
        p1.showAge(); //对象的本质People 调用people


        People p2= new Student();
        System.out.println(p2.age);  //18
        p2.showAge(); //本质student 且重写了  调用Student的方法
        p2.sleep();  //本质student  没重写  调用people

        Student p3 = (Student)p2;
        System.out.println(p3.age); //21
        p3.showAge();  //本质student 且重写调用Student

        People p4=p3;
        System.out.println(p4.age);//18  看左边
        p4.showAge(); //本质student 且重写了  调用student
    }


//结果
18
年龄18
18
年龄：21———18
睡觉的方法——————
21
年龄：22———18
18
年龄：23———18

//方法的测试
    public static void main(String[] args) {
        People p1 =new People();
        p1.method1();
        p1.method2();

        
        People p2=new Student();
        p2.method1();
        p2.method2();

        Student p3=(Student) p2;
        p3.method1();
        p3.method2();
    }


//结果
method1-------------
method2———————
method1-------------
method2———————
method1——————重写后的方法
method2———————

案例题：

public class Test01 {
    int i=1;
    public void test1(){
        i++;
        System.out.println(i);
    }
    public void test2(){
        System.out.println(i);
    }

    public static void main(String[] args) {
        Test01 t1=new Test02();
        t1.test1();  //1      //有i++  2
        t1.test2();  //2      //有i++  2
        System.out.println(t1.i);  //1      //有i++  2
        t1=(Test02)t1;
        System.out.println((t1.i));//1      //有i++  2
    }

}
class Test02 extends Test01{
    int i=2;

    @Override
    public void test2() {
        System.out.println(i);
    }
}

三、访问修饰符

? 用于修饰 类、属性、方法的关键字都称为访问修饰符

1、public ：公共的

? 可被同一个项目的所有类方法（项目可见性）

2、protected：受保护的

? 可以被自身的类访问

? 可以被同包下的其他类访问

? 对于不同包的，存在父子关系的子类可以访问

3、default：默认的

? 可以被自身访问

? 可以被同包下的其他类访问

4、private：私有的

? 只有被自身访问

public class Animal {
    //动物名
    public String name;
    //动物颜色
    protected String color;
    //动物体重
    double weight;
    //动物性别
    private String sex;

    //同一类下 都可以访问
    public void showInfo() {
        System.out.println("动物的名称：" + name + "动物的颜色：" + color + "动物的体重：" + weight + "动物的性别：" + sex);
    }
}

public class Dog02 extends Animal {
    //同包下子类
    public void dog02Info() {
        System.out.println("动物的名称" + name + "动物的颜色：" + color + "动物的体重" + weight);
        //private修饰符不能被访问
    }
}
//同包下非子类
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.name = "小朱";
        animal.color = "蓝色";
        animal.weight = 60;  //公斤
        //animal.sex;  //报错
        //private修饰符不能被访问
    }

public class Cat extends Animal {
    //不同包子类
    public void catInfo() {
        System.out.println("动物的名称：" + name + "动物的颜色：" + color);
        //默认的 和 private访问修饰符  不能再不同包子类访问
    }
}

    //不同包
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.name = "小朱";
        //其他的访问修饰符不能被访问
    }

四、static关键字

? static表示“静态”，它可以修饰属性、方法、代码块，在一类中除了可以定义成员属性，成员方法和构造器以外，还可以定义静态部分（静态属性，静态方法，静态代码块）

? static修饰属性：称为：静态属性 或 类的属性

? static修饰方法：称为：静态方法 或 类的方法

? static修饰的语句块：称为：静态属代码块

? static修饰的组件不需要对象访问，而是直接通过类名访问（也可以被对象访问），在类一加载时会给static修饰的属性和方法分配内存区这个内存分布在静态内存区中，后续对象操作的是同一个内存区

案例一：类的组件执行顺序

public class Student {
    //成员属性
    String name;
    //静态属性      通常static写在public的后面
    static int age = 20;

    //静态代码块
    static {
        System.out.println("这就是静态代码块，再类一加载时，就会被执行，且执行一次");
    }

    public Student() {
        System.out.println("这是个无参构造器");
    }

    {
        System.out.println("这是个构造器代码块");
    }

    //成员方法  ，既可以访问成员属性  也可以访问静态属性
    public void getInfo() {
        System.out.println("姓名：" + name + "年龄：" + age);
    }

    //静态方法 只能访问静态属性 不能访问成员属性（非静态属性）
    // 这是为什么？  由于成员属性的存在需要依赖对象
    //  静态属性和静态方法再创建之前就必须初始化并分配内存
    public static void getStaticInfo() {
        //    System.out.println("姓名："+name);  //成员属性不会被访问
        System.out.println("年龄：" + age);
    }

    public static void main(String[] args) {
        System.out.println("访问静态属性年龄：" + Student.age);
        //方法静态方法
        Student.getStaticInfo();
    }
//测试
public class TestStudent {
    public static void main(String[] args) {
        /**
         * 类的组件执行顺序
         * 类编译成.class文件被JVM的类加载器加载
         * 从上向下初始化static的组件
         * （静态属性，静态代码块，静态方法，其中静态方法调用才执行，静态属性和静态代码块自动直接执行）
         * 先执行构造代码块、再执行构造器   初始化成员属性，成员方法
         */
        Student stu1 = new Student();
        stu1.name = "张三";
        // 静态属性可以通过类名访问，也可以通过对象名访问
        stu1.age = 21;
        System.out.println(stu1);

        Student stu2 = new Student();
        stu2.name = "李四";
        stu2.age = 22;
        System.out.println(stu2);

        System.out.println(stu1.name);
        System.out.println(stu1.age); //   22

        System.out.println(stu2.name);
        System.out.println(stu2.age); // 22

        System.out.println(Student.age);//  22

    }
}    

案例二：静态变量 在同一个内存中

public class People {

    double height;

    static int score;

    static {
        score++; // 1
    }

    public void setScore() {
        score++; //81  86
    }

    public static void setScore2() {
        score++;
    }

    public static void main(String[] args) {
        People p1 = new People();
        p1.score = 80;//静态属性
        p1.setScore();
        People.score = 85;
        p1.height = 1.75;
        People p2 = new People();
        p2.setScore(); //86
        p2.height = 1.80;

        System.out.println(p1.score); // 86
        System.out.println(p1.height); // 1.75

        System.out.println(p2.score);//86
        System.out.println(p2.height);// 1.80

    }
}

案例三：构造代码块和静态代码块的执行顺序

public class UserInfo {
    //  关于静态的组件 从上往下执行
    static {
        System.out.println("这是静态代码块2，只执行一次");
    }

    // 静态属性  需要先初始化 ，需要new一个对象
    static UserInfo u = new UserInfo(); // 先执行构造代码块 在执行构造器

    static {
        System.out.println("这是静态代码块1，只执行一次");
    }

    public UserInfo() {
        System.out.println("这是无参构造器");
    }

    {
        System.out.println("构造代码块");
    }

    public static void main(String[] args) {
        // 结果
        UserInfo u = new UserInfo();
    }
}
//结果
这是静态代码块2，只执行一次
构造代码块
这是无参构造器
这是静态代码块1，只执行一次
构造代码块
这是无参构造器

五、抽象类

? 在已有类的基础上，由于特殊情况将该类设置为抽象的，这个类就是抽象类

? 1、抽象类语法

public abstract class 类名{
    //类的元素
}

什么情况下需要抽象类？

1、当这个类不需要创建具体实例化时，可将类定义为抽象的

2、当这个类中存在没有实现的方法时（没有方法体的方法），可以将这个类定义抽象的

? 2、抽象类的特点

? 2.1、抽象类 不能实例化（不能new），通常抽象类被当作父类使用

? 2.2、抽象类中可以有抽象方法（没有方法体的方法）也可以有普通方法

? 2.3、抽象类被当作父类时，它的子类必须重写父类的抽象方法

//父类
public abstract class Fruit {
         private String color;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    //水果的甜度
    //由于不知道是什么水果，所有说过的甜度未知
    //可以定义为抽象方法
    public abstract void getSweat();
}
//子类
public  class Apple extends Fruit{

    //子类重写（实现）父类的抽象方法
    @Override
    public void getSweat() {
        System.out.println("这个水果有点甜");
    }
}
//子类
public class Lemon extends Fruit {
    @Override
    public void getSweat() {
        System.out.println("这个水果有点酸，想想都觉得酸！");
    }
}
//测试
public class TestFruit {
    //抽象类不能实例化
    //Fruit fruit=new Fruit();
    public static void main(String[] args) {

        //创建子类
        Apple apple = new Apple();
        apple.setColor("红色");
        System.out.println(apple.getColor());
        apple.getSweat();

        Lemon lemon = new Lemon();
        lemon.setColor("黄色");
        System.out.println(lemon.getColor());
        lemon.getSweat();
    }
}
//结果
/**
*红色
*这个水果有点甜
*黄色
*这个水果有点酸，想想都觉得酸！
*/

六、构造器

? 在创建对象时被自动调用的特殊方法，也称为构造方法，在一个类中除了包含属性和方法以外，还包含构造器（构造方法）

? 每一个类都自带一个无参构造器，也可以在这个类中定义多个构造器，多个构造器之间称为”构造器重载”

? 1、构造器语法

访问修饰符  类名（[参数]）{
    
}

例如：

public class  Student{
    //无参构造器
    public Student(){
        System.out.println("这是个无参构造器")
    }
}

? 2、构造器的作用

1、用于创建对象自动调用，并可以给对象的属性赋初始值

public class  Student{
    String name;   //对象的属性
    //有参构造器
    public Student (String name){
        name = name1
    }
    //注意一个类中如果存在有参构造器，那么它的无参构造器被覆盖
}
//
创建对象：
	Student stu = new Student("张三")；
	//这里会自动调用有参构造器，并将“张三”的值赋值给name1，由于自动执行以上构造器，将name1的值赋值给name，这个name就是对象的属性
	System.out.println(stu.name)  //张三	

七、接口

? 接口用于对某件事物的功能的声明，而没有实现具体功能，接口提供对软件开发的标准规范。

? 利用接口的“多实现”完成Java的单一继承

1、接口语法

public interface 接口名{
    抽象方法定义
}

一个类实现接口，必须实现接口的所有方法

public class 实现类名 implements 接口名{
    实现接口的所有方法
}

?

? 2、接口的好处

? 1、为了规范实现类的行为，让所有的方法都通过接口定义

? 2、为了提高代码的可扩展性

? 3、接口中的成员组成部分特点

? 1、接口中定义的变量默认全部都是public static final修饰。

? 2、接口中的静态方法可以直接调用。

? 3、接口中不能写构造器（因为接口不能实例化，不需要要构造器）

? 4、接口中的方法全部都是抽象的方法，在JDK8以后可以定义default的非抽象方法

案例1：一个类既可以继承一个类 也可以实现多个接口

//定义一个门类 ，定义一个防盗门，它具有防盗的功能，如何防盗 （防盗功能中可以 拍照， 密码锁） 
// 门本 身有 开门，关门 功能
public abstract class Door {
    //定义开门 关门的方法
    public void openDoor(){
        System.out.println("门开了！");
    }
    public void closeDoor(){
        System.out.println("门是关的！");
    }
}
//防盗功能
public interface Burglars {
    //定义初始密码
    public static final String pwd="888888";

    public void takePhoto();

    public boolean enterPassword(String password);
}
//防盗门
public class BurglarsDoor extends com.j2008.interfaces.Door implements com.j2008.interfaces.Burglars {
    @Override
    public void takePhoto() {
        System.out.println("防盗门正在拍照。。。");
    }

    @Override
    public boolean enterPassword(String password) {
        //equals比较两个字符串的值是否相等
        if (password.equals(com.j2008.interfaces.Burglars.pwd)){
            return true;
        }
        return false;
    }
}
//测试
public class TestDoor {
    public static void main(String[] args) {
        //创建门对象
        //1、第一门只能开关
        com.j2008.interfaces.Door door = new com.j2008.interfaces.BurglarsDoor();
        door.openDoor();
        door.closeDoor();
        //2、防盗功能
        com.j2008.interfaces.Burglars door2= new com.j2008.interfaces.BurglarsDoor();
        door2.takePhoto();
        if (door2.enterPassword("8888888")){
            System.out.println("锁打开了，但是门没有开！");
        }
        //3、使用防盗门类创建自己的对象
        com.j2008.interfaces.BurglarsDoor door3 = new com.j2008.interfaces.BurglarsDoor();
        door3.closeDoor();
        door3.takePhoto();
        System.out.println("输入密码验证：");
        if (door3.enterPassword("888888")){
            door3.openDoor();
        }
    }
}
//结果
门开了！
门是关的！
防盗门正在拍照。。。
门是关的！
防盗门正在拍照。。。
输入密码验证：
门开了！

案例2：一个类可以实现多个接口，中间用逗号分隔开（那么这个类实现接口的所有方法）

public interface Cooker {
    /**
     * 做饭的功能
     */
    public void makeFood();
}
public interface Driver {
    //开车的功能
    public void driverCar();
}
public interface Programer {
    /**
     * 赚钱的功能
     */
    public void takeMoney();
}
//实现
public class People implements Programer,Cooker,Driver {
    @Override
    public void makeFood() {
        System.out.println("做好吃的");
    }

    @Override
    public void driverCar() {
        System.out.println("开车的功能");
    }

    @Override
    public void takeMoney() {
        System.out.println("挣钱的功能");
    }

    String name;

    public People(String name) {
        this.name = name;
    }
}
//测试
public class TestPeople {
    public static void main(String[] args) {
        People people=new People("小朱");
        people.makeFood();
        people.driverCar();
        people.takeMoney();
    }
}
//结果
小朱做好吃的
小朱开车的功能
小朱挣钱的功能

案例3：一个接口可以继承接口，或者多个接口（接口可以多继承）

public interface Boos {
    //老板可以赚更多的钱
    public void takeMoreMoney();
}
public interface Employee {
    //是否有女朋友
    public boolean isGirlFriend();
}
public interface Programer extends Employee,Boos {
    //写代码
    public void writeCoding();
}
public class Student implements Programer {
    private  String name
;

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

    @Override
    public void writeCoding() {
        System.out.println(this.name+"可以写代码了");

    }

    @Override
    public void takeMoreMoney() {
        System.out.println(this.name+"以后可以赚更多的钱，有更多的女朋友！");
    }

    @Override
    public boolean isGirlFriend() {
        System.out.println(this.name+"有女朋友了");
        return true;
    }
}
//测试
public class TestPeople {
    public static void main(String[] args) {
        Student student=new Student("小朱");
        student.isGirlFriend();
        student.writeCoding();
        student.takeMoreMoney();
    }
}
//结果
小朱有女朋友了
小朱可以写代码了
小朱以后可以赚更多的钱，有更多的女朋友！

Java面向对象初级总结（基础中的基础很重要！！）

原文：https://www.cnblogs.com/qzwx63/p/13802931.html