java快速入门-----类的封装继承多态抽象接口

java面向对象

面向对象的本质：以类的方式组织代码，以对象的形式组织数据

三大特性：封装，继承，多态

一、类和对象

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。

 

Fruit.java

public class Fruit {
    private String privateVariable;   // 私有成员变量
    String defaultVariable;           // 默认访问修饰符成员变量
    protected String protectedVariable;   // 受保护的成员变量
​
    private void privateMethod() {
        System.out.println("私有方法");
    }
​
    void defaultMethod() {
        System.out.println("默认方法");
    }
​
    protected void protectedMethod() {
        System.out.println("受保护的方法");
    }
}
​

二、封装

（一）作用

1.提高程序安全性，保护数据

2、隐藏代码的实现细节

3、统一接口

4、增强系统可维护性

（二）属性私有以及get/set的使用

通常 类 中的属性我们将其 设置为 private 来防止外部类调用修改该类中该属性的值。 但 设置为 private 后，外部类创建对象无法 对该对象的属性进行赋值。此时可用 get /set 方法。

Fruit.java

public class Fruit {
    private String name;    // 私有成员变量
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
}
​

Main.java

public class Main {
    public static void main(String[] args) {
        Fruit apple = new Fruit();
        apple.setName("Apple");
​
        System.out.println(apple.getName());  // 输出：Apple
    }
}
​

三、继承

(一)使用

子类通过extends关键字能够继承父类的方法和成员变量

Fruit.java

public class Fruit {
    private String name;
​
    public Fruit(String name) {
        this.name = name;
    }
​
    public void eat() {
        System.out.println("吃" + name);
    }
}
​

Apple.java

public class Apple extends Fruit {
    private String color;
​
    public Apple(String name, String color) {
        super(name);  // 调用父类的构造方法
        this.color = color;
    }
​
    public String getColor() {
        return color;
    }
}
​

Main.java

public class Main {
    public static void main(String[] args) {
        Apple apple = new Apple("Apple", "Red");
        apple.eat();                   // 调用父类的 eat() 方法
        System.out.println(apple.getColor());  // 调用子类的 getColor() 方法
    }
}
​

1、子类能够继承 父类中的所有成员变量和方法，只是对于父类中的 private修饰的方法和成员变量由于访问权限的问题，不能直接在子类中访问。

2、所有的类都默认直接或者间接继承了Object 类

3、Java 中只有单继承没有多继承 （一个儿子只能有一个亲生父亲，一个父亲可以有多个儿子）

(二) super 关键字

Fruit.java

public class Fruit {
    protected String name;
​
    public Fruit(String name) {
        this.name = name;
    }
​
    public void eat() {
        System.out.println("吃" + name);
    }
}

Apple.java

​
public class Apple extends Fruit {
    private String color;
​
    public Apple(String name, String color) {
        super(name);  // 调用父类的构造方法
        this.color = color;
    }
​
    public void printInfo() {
        System.out.println("水果名称：" + super.name);  // 使用 super 访问父类的成员变量
        super.eat();  // 使用 super 调用父类的方法
    }

​
​

四、多态

（一）概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状 态。

总的来说：同一件事情，发生在不同对象身上，就会产生不同的结果。

（二）实现条件

1、 必须在继承关系下，发生向上转型

2、子类必须重写父类中方法

3、通过父类的引用调用重写方法

1、使用父类类型的引用指向子类的对象； 2、该引用只能调用父类中定义的方法和变量； 3、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（此过程称为 ：动态连接 或 动态调用） 4、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。

Fruit.java

abstract class Fruit {
    public abstract void eat();
}
​

Apple.java

class Apple extends Fruit {
    @Override
    public void eat() {
        System.out.println("吃苹果");
    }
}
​
​

Orange.java

class Orange extends Fruit {
    @Override
    public void eat() {
        System.out.println("吃橘子");
    }
}
​

Main.java

class Main {
    public static void main(String[] args) {
        Fruit apple = new Apple();
        Fruit orange = new Orange();
​
        apple.eat();   // 输出：吃苹果
        orange.eat();  // 输出：吃橘子
    }
}
​

(五)抽象类

（一）概念

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是 抽象类。

（二）实现

Fruit.java

public abstract class Fruit {
    public abstract void eat();
}
​
​

Apple.java

public class Apple extends Fruit {
    @Override
    public void eat() {
        System.out.println("吃苹果");
    }
}
​

Main.java

public class Main {
    public static void main(String[] args) {
        Fruit apple = new Apple();
        apple.eat();  // 输出：吃苹果
    }
}
​

（三）特点

1、 抽象类中可以写普通方法，但抽象方法必须在抽象类中

2、抽象类是无法进行实例化创建对象的，只能去实例化它的子类来创建对象。

abstract class Fruit {
    public abstract void eat();
​
    public void wash() {
        System.out.println("洗水果");
    }
}
​
class Apple extends Fruit {
    @Override
    public void eat() {
        System.out.println("吃苹果");
    }
}
​
class Main {
    public static void main(String[] args) {
        Fruit apple = new Apple();
        apple.eat();  // 输出：吃苹果
​
        apple.wash();  // 输出：洗水果
    }
}
​

(四)作用

（四）作用 抽象类这么抽象，那它的具体作用是什么呢？

其实利用抽象类，有利于提高代码的开发效率。

如： 创建一个游戏角色，其特性比较复杂，反复创建会比较麻烦，我们可以利用 抽象类 抽象其一些公有的特性，而后我们每创建一个角色，就可以去写一个子类 继承这个抽象类，再去重写一些其中方法，改掉一些不必要方法。可以提高开发效率，和可拓展性。

五、接口

（一）概念 接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

（二）语法规则 接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。

Fruit.java

public interface Fruit {
    void eat();
    String getName();
    String getColor();
}
​
​

Apple.java

public class Apple implements Fruit {
​
    public void eat() {
        System.out.println("吃苹果");
    }
​
​
    public String getName() {
        return "苹果";
    }
​
​
    public String getColor() {
        return "红色";
    }
}
​

Main.java

public class Main {
    public static void main(String[] args) {
        Apple apple = new Apple();
        apple.eat();  // 调用接口中的 eat 方法
​
        String name = apple.getName();  // 调用接口中的 getName 方法
        System.out.println("水果名称：" + name);
​
        String color = apple.getColor();  // 调用接口中的 getColor 方法
        System.out.println("水果颜色：" + color);
    }
}
​

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接 口

interface Fruit {
    void eat();
}
​
interface Animal {
    void run();
}
​
class Monkey implements Fruit, Animal {
    @Override
    public void eat() {
        System.out.println("猴子吃水果");
    }
​
    @Override
    public void run() {
        System.out.println("猴子跑步");
    }
}
​

一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

即Java中不支持多继承，但是一个类可以实现多个接口。

​