Java中面向对象的特征

最新推荐文章于 2022-11-21 12:46:33 发布

noscallion

最新推荐文章于 2022-11-21 12:46:33 发布

阅读量114

点赞数

本文链接：https://blog.csdn.net/noscallion/article/details/105199407

版权

（1）面向对象特征之一：封装和隐藏

使用者对类内部定义的属性（对象的成员变量）的直接操作会导致数据的错误、混乱或安全性问题。
例如下面的代码，将年龄设置成负数。显然这样不符合实际情况。

public class Person {
    public int age;
    public void printAge() {
        System.out.println("年龄是：" + age);
    }

    public static void main(String[] args) {
        Person p = new Person();
        p.age = -100;
        p.printAge();
    }
}

可以用封装的技术修改这个错误，如下面的代码。

public class Person {
    private int age;
    public void printAge() {
        System.out.println("年龄是：" + age);
    }
    public void setAge(int a) {
        if (a > 150 || a < 0) {
            System.out.println("Input number " + a + " is not between 0 and 150");
        }
        else
            age = a;
    }

    public static void main(String[] agrs) {
        Person p = new Person();
        p.setAge(155);
        p.printAge();
    }
}

这样一来，如果设置的年龄不在0-150之间，程序就会进行提示。

信息的封装和隐藏
Java中通过将数据声明为私有的（private），再提供公共的（public）方法：getXxx()和setXxx()实现对该属性的操作。这样做可以：

隐藏一个类中不需要对外提供的实现细节。
使用者只能通过事先定制好的方法来访问数据，可以方便地加入逻辑控制，限制对属性的不合理操作。
便于修改，增强代码的可维护性。

（2）面向对象特征之二：继承

把共性的东西抽取出来形成父类，实际需求的子类在继承父类的基础上写自己的特有代码即可。
在子类中，可以使用父类中定义的方法和属性，也可以创建新的。
子类不能访问父类私有的东西。

注意：

继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。
不要仅为了获取其他类中的某个功能而去继承。

Java是单继承的，不允许多重继承。

一个子类只能有一个父类。
一个父类可以派生出多个子类。

方法的重写（override）
在子类中可以根据需要对从父类中继承来的方法进行重写。在程序执行时，子类的方法将覆盖父类的方法。

要求：

重写方法必须和被重写方法具有相同的方法名称，参数列表和返回值类型。
重写方法不能使用比被重写方法更严格的访问权限。
重写和被重写的方法必须同时为static的，或同时为非static的。
子类方法抛出的异常不能大于父类被重写的方法的异常。

super关键字

super可用于访问父类中定义的属性。
super可用于调用父类中定义的成员方法。
super可用于在子类构造器中调用父类的构造器。
super的追溯不仅限于直接父类，而是可以一直向上追溯。

调用父类的构造器

子类中所有的构造器默认都会访问父类中空参数的构造器。
当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或super(参数列表)语句指定调用本类或者父类中相应的构造器，而且必须放在构造器的第一行。
如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的的构造器，则编译出错。

（3）面向对象特征之三：多态性

1.多态性在Java中的体现

方法的重载（Overload）和重写（Overwrite）。
对象的多态性。——可以直接应用在抽象类和接口上。

重载（Overload）：
本类中的同名方法。体现相同名称的方法实现不同的逻辑。

重写（Overwrite）：
子类对父类方法的覆盖。子类可以使用和父类相同的方法名，覆盖掉父类的逻辑。
例如，想修改父类中方法的逻辑，但有别的代码在调用父类的方法；则可以考虑用子类继承父类，重写父类的方法。

2.Java引用变量类型

Java引用变量有两个类型，编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。
若编译时类型和运行时类型不一致，则出现多态（Polymorphism）。 ——对象的多态。

3.对象的多态

设有两个类Person和Student，且Student时Person的子类。那么：

Person p = new Student();

是合法的。称为向上转型。
具体来说就是，父类类型的变量可以引用子类类型的对象。这里可以把子类看成是特殊的父类。

注意：一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量不能访问子类中添加的属性。

public class Person {
    String name;
    int age;
    boolean sex;
}

class Student extends Person {
    int number;
}

public class Test {
    public static void main(String[] args) {
        Person p = new Student();
        p.number; //错误，无法引用子类中的属性。
    }
}

因为属性是在编译时确定的，而编译时p为Person类型，没有number成员变量。所以产生编译错误。

对于方法来说：

public class Person {
    public void show() {
        System.out.println("Person Method");
    }
}

class Student extends Person {
    public void show() {
        System.out.println("Student Method");
    }
}

public class Test {
    public static void main(String[] args) {
        Person p = new Student();
        p.show();  //打印Student Method。
    }
}

方法是在运行时调用，即所谓动态绑定。
Java的方法运行在栈内存中，在运行方法时会动态地进栈和出栈。

另外，方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法。

public class Person {
}

class Student extends Person {
}

public class Test {
    public void method(Person p) {}

    public static void main(String[] args) {
        Test t = new Test();
        Student stu = new Student();
        t.method(stu);
    }
}