Java 面向对象特性

Java 基础核心知识

面向对象特性

面向对象的三大特性？

封装

利用抽象将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立个体

封装的 4 大好处

良好的封装能够减少耦合
类内部的结构可以自由修改
可以对成员进行更加精确的控制
隐藏信息、实现细节

封装可以使得我们更容易的修改类的内部实现，而无需修改使用该类的代码

2.继承

继承就是子类继承父类的属性和方法，使得子类对象具有父类的属性和方法，或者子类从父类继承方法，使得子类具有父类相同的方法

继承不仅大大的减少了代码量，也使得代码结构更加清晰可见

Java 实现多继承的方法

内部类：继承一个和外部类无关的类，保证内部类的独立性
多层继承：子类继承父类，父类如果还继承其他的类，就是多层继承
实现接口：多继承最好的方法，一个类实现多个接口。类就是一个实体，有属性和方法，而接口更倾向于一组方法

实现继承的关键字

extends
implements

this 和 super 关键字

this：表示当前对象，是指向自己的引用
super：表示父类对象，是指向父类的引用

方法的重写和重载

重写：外壳不变，但是核心内容重写
重载：方法名相同，参数不一致

继承修饰符

访问权限修饰符，也就是 public、private、protected 等
非访问修饰符，也就是 static、final、abstract 等

多态

前提条件

子类继承父类
子类重写父类的方法
父类引用指向子类的对象

多态机制提供的一个重要的好处就是程序具有良好的扩展性

多态是同一个行为具有多个不同表现形式或形态的能力。即一个父类可能有若干子类，各子类实现父类方法有多种多样，调用父类方法时，父类引用变量指向不同子类实例而执行不同方法，这就是所谓父类方法是多态的。

封装

正常去实现一个类

arduino 复制代码

public class Husband {
    public String name ;
    public String sex ;
    public int age ;
    public Wife wife;
}

使用类中的参数时

ini 复制代码

Husband husband = new Husband();
husband.age = 30;
husband.name = "张三";
husband.sex = "男";    //貌似有点儿多余

一处进行了修改，牵一发而动全身，这样的话当后期进行维护和修改时，会十分麻烦

推荐使用封装的方法

arduino 复制代码

public class Husband {

    /*
     * 对属性的封装
     * 一个人的姓名、性别、年龄、妻子都是这个人的私有属性
     */
    private String name ;
    private String sex ;
    private int age ;    /* 改成 String类型的*/
    private Wife wife;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 120){
            System.out.println("ERROR：error age input....");    //提示錯誤信息
        }else{
            this.age = age;
        }

    }

    /** 省略其他属性的setter、getter **/

}

继承

所以这样从代码的层面上来看我们设计这个完整的 Animal 类是这样的：

csharp 复制代码

class Animal
{
    public int id;
    public String name;
    public int age;
    public int weight;

    public Animal(int id, String name, int age, int weight) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.weight = weight;
    }
    //这里省略get set方法
    public void sayHello()
    {
        System.out.println("hello");
    }
    public void eat()
    {
        System.out.println("I'm eating");
    }
    public void sing()
    {
        System.out.println("sing");
    }
}

而 Dog，Cat，Chicken 类可以这样设计：

scala 复制代码

class Dog extends Animal//继承animal
{
    public Dog(int id, String name, int age, int weight) {
        super(id, name, age, weight);//调用父类构造方法
    }
}
class Cat extends Animal{

    public Cat(int id, String name, int age, int weight) {
        super(id, name, age, weight);//调用父类构造方法
    }
}
class Chicken extends Animal{

    public Chicken(int id, String name, int age, int weight) {
        super(id, name, age, weight);//调用父类构造方法
    }
    //鸡下蛋
    public void layEggs()
    {
        System.out.println("我是老母鸡下蛋啦，咯哒咯！咯哒咯！");
    }
}

各自的类继承 Animal 后可以直接使用 Animal 类的属性和方法而不需要重复编写，各个类如果有自己的方法也可很容易地拓展。

单继承

单继承，一个子类只有一个父类，如我们上面讲过的 Animal 类和它的子类。单继承在类层次结构上比较清晰，但缺点是结构的丰富度有时不能满足使用需求。

多继承

多继承，一个子类有多个直接的父类。这样做的好处是子类拥有所有父类的特征，子类的丰富度很高，但是缺点就是容易造成混乱。下图为一个混乱的例子。

如何实现继承

1.extends 关键字

csharp 复制代码

class Animal {
    public void  sayHello()//父类的方法
    {
        System.out.println("hello,everybody");
    }
}
class Dog extends Animal//继承animal
{ }
public class test {
    public static void main(String[] args) {
       Dog dog=new Dog();
       dog.sayHello();
    }
}

2.implements 关键字

csharp 复制代码

interface doA{
     void sayHello();
}
interface doB{
     void eat();
    //以下会报错 接口中的方法不能具体定义只能声明
    //public void eat(){System.out.println("eating");}
}
class Cat2 implements  doA,doB{
    @Override//必须重写接口内的方法
    public void sayHello() {
        System.out.println("hello!");
    }
    @Override
    public void eat() {
        System.out.println("I'm eating");
    }
}
public class test2 {
    public static void main(String[] args) {
        Cat2 cat=new Cat2();
        cat.sayHello();
        cat.eat();
    }
}

多态

csharp 复制代码

//子类继承父类
public class Wangxiaoer extends Wanger {
    public void write() { // 子类重写父类方法
        System.out.println("记住仇恨，表明我们要奋发图强的心智");
    }

    public static void main(String[] args) {
        // 父类引用指向子类对象
        Wanger[] wangers = { new Wanger(), new Wangxiaoer() };

        for (Wanger wanger : wangers) {
            // 对象是王二的时候输出：勿忘国耻
            // 对象是王小二的时候输出：记住仇恨，表明我们要奋发图强的心智
            wanger.write();
        }
    }
}

class Wanger {
    public void write() {
        System.out.println("勿忘国耻");
    }
}

多态机制提供的一个重要的好处就是程序具有良好的扩展性

csharp 复制代码

//子类继承父类
public class Wangxiaoer extends Wanger {
    public void write() { // 子类覆盖父类方法
        System.out.println("记住仇恨，表明我们要奋发图强的心智");
    }

    public void eat() {
        System.out.println("我不喜欢读书，我就喜欢吃");
    }

    public static void main(String[] args) {
        // 父类引用指向子类对象
        Wanger[] wangers = { new Wanger(), new Wangxiaoer() };

        for (Wanger wanger : wangers) {
            // 对象是王二的时候输出：勿忘国耻
            // 对象是王小二的时候输出：记住仇恨，表明我们要奋发图强的心智
            wanger.write();
        }
    }
}

class Wanger {
    public void write() {
        System.out.println("勿忘国耻");
    }

    public void read() {
        System.out.println("每周读一本好书");
    }
}