JAVA面向对象【三大特性】_java面向对象的三大特征

目录

一、封装性

面向对象的特征一：封装与隐藏

一、问题的引入

二、封装性的体现：

三、封装性的体现需要权限修饰符来配合

体会四种不同的权限修饰 

练习 

二、继承性

一、继承性的好处：

二、继承性的格式：class A extends B{}

三、Java中关于继承性的规定

四、object类说明

方法的重写override/overwrite 

例子 

Super关键字的使用

 举例：

测试 

 子类实例化父类对象的过程

三、多态性

举例：

 为什么要有多态性

虚拟方法的调用

关键字instanceof操作符的调用

---

一、封装性

高内聚：类的内保部数据操作细节自己完成，不允许外部干涉

低耦合：仅对外暴露少量的方法用于使用

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调节，从而提高系统的可扩展性。可维护性。通俗地说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

就如我们下面在代码中所写的，我们将动物整一个类的特性内聚在一起。 

class Animals{
    String name;
    int age;
    int legs;
}
class AnimalTest{
    public static void main(String[] args){
        Animals a=new Animals();
        a.name="大黄";
        a.age=1;
        a.legs=4;
    }
}

面向对象的特征一：封装与隐藏

一、问题的引入

当我们创建一个类的对象以后，我们可以通过“对象.数据”的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他的制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能再属性声明时体现，我们只能通过方法进行限制条件的添加（比如：set ）同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的（private）

-->此时，针对于属性就体现了封装性。

二、封装性的体现：

我们将类的属性（私有化），同时，提供公共的（public）方法来获取（getxxx）和设置（setxxx）此属性的值

三、封装性的体现需要权限修饰符来配合

1.Java规定的四种权限：（从小到大排列）：private、缺省、protected、public

Java权限修饰符public、protected、private置于类的成员定义前，用来限定对象对该类成员的访问权限。

2.四种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类

3.具体的：四种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类

修饰类的话，只能使用，缺省、public

体会四种不同的权限修饰 

下面是我们文件的目录

 首先我们在power包下的order类中定义了如下四个不同权限的方法和属性。

package power;
 
public class Order {
    private  int orderPrivate;
    int orderDefault;
    protected  int orderProtected;
    public int orderPublic;
 
    private void methodPrivate(){
        orderPrivate=1;
        orderDefault=2;
        orderProtected=3;
        orderPublic=4;
    }
    void methodDefault(){
    }
    protected void methodProtected(){
    }
    public void methodPublic(){
    }
 
}

 在同一个包下的其他类中（下面是在Ordertest类中的代码），只能够调用权限为缺省，protected和public的方法和属性

package power;
 
public class Ordertest {
    public static void main(String[] args){
        Order order=new Order();
 
        order.orderDefault=1;
        order.orderProtected=2;
        order.orderPublic=3;
 
        order.methodDefault();
        order.methodProtected();
        order.methodPublic();
 
        //同一个包中的其他类，不可以调用Order类中的私有属性，方法
//        order.orderPrivate=4;
//        order.methodPrivate();
 
    }
}

 以下是在我们的不同包下的子类中suborder中的代码，从中我我们可以看见，其不能调用order类中声明为private何缺省权限的结构。

package power2;
import power.Order;
public class suborder extends Order{
    public void method(){
        orderProtected=1;
        orderPublic=2;
 
        methodProtected();;
        methodPublic();;
        //在不同包的子类中，不能调用order类中声明为private和缺省权限的结构
    }
 
}

以下是在我们ordertest中的代码，也就是在同一个工程，不包，不是子类的情况下只能调用public权限的方法。 

package power2;
 
import power.Order;
 
public class ordertest {
    public  static void main(String[] args){
        Order order=new Order();
        order.orderPublic=1;
        order.methodPublic();
 
        //不同包下的普通类（非子类）要使用Order类，不可以调用声明为private、缺省、protected权限的属性、方法。
    }
}

对于class的权限修饰符只可以用public和default（缺省）

public类可以在任意地方被访问

default类只可以被同一个包内部的类访问

拓展：封装性的体现：①如上②不对外暴露的私有的方法③单列模式

总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。

class Animal {
    String name;
    int age;
    private int legs;//修饰legs的权限，使不能直接修改legs的值。
 
    public void setlegs(int l) {
        legs=l;
    }
 
    public void eat() {
        System.out.println("动物进食");
    }
 
    public void show() {
        System.out.println(name + age + legs);
    }
 
    //对属性的获取
    public int getlegs() {
        return legs;
    }
 
    //提供关于属性age的get和set方法
    public int getage() {
        return age;
    }
 
    public void setage(int a) {
        age = a;
    }
 
    public class Order {
        private int orderPrivate;
        int orderDefault;
        public int orderPublic;
 
        public void methodPrivate() {
            orderPrivate = 1;
        }
 
        void methodDefault() {
        }
 
        public void methodPublic() {
        }
    }
}
class test{
    public static void main(String[] args)
    {
        Animal a1=new Animal();
        a1.setlegs(2);
        System.out.println("legs="+a1.getlegs());
    }
}

从上面的代码中可以看出，我们在声明了private的属性的legs之后，外界不能对这个属性进行直接修改，必须要调用setlegs和getlegs的方法才能够修改

练习 

1•创建程序，在其中定义两个类：Person和PersonTest类。定义如下：

用setAge（）设置人的合法年龄（0~130），用getAge（）返回人的年龄。

在PersonTest类中实例化Person类的对象b，调用setAge()和getAge()方法，体会Java的封装性

class Person{
    private int age;
        public void setAge(int a){
        if(a<0||a>130){
            throw new RuntimeException("传入的数据非法");
//也可以采用下面的写法来代替上面的throw行的写法
//            System.out.println("传入的数据非法！");
//            return;
        }
             age=a;
        }
public int getAge(){
        return age;
        }
//绝对不要这样写！不要把get和set的功能混合在一起。
public int doAge(int a){
        age=a;
        return age;
        }
}
class test{
    public static void main(String[] args){
        Person p1=new Person();
        p1.setAge(10);
        System.out.println("年龄是"+p1.getAge());
    }
}

二、继承性

面向对象的特征之二：继承性 why?

一、继承性的好处：

①减少了代码的冗余

②便于功能的扩展

③为之后的多态性的使用提供了前提

二、继承性的格式：class A extends B{}

A：子类、派生类、subclass

B：父类、基类、superclass

2.1  体现：一旦子类A继承父类B之后，子类A中获取父类B中生命的所有的结构、属性、方法

特别的，父类中声明为private的属性或方法，子类继承父类以后，任然认为获取了父类中私有的结构。只有因为封装性的影响，使子类不能直接调用父类的结构而已。

2.2  子类继承父类之后，还可以声明自己特有的属性和方法，实现功能的扩展

子类和父类的关系不同于子集和集合的关系。

extends:延展、扩展

三、Java中关于继承性的规定

Java只支撑单继承和多层继承（下图是多层继承的情况，是被允许的）

不允许多重继承，下图这种情况是不被允许的 

一个子类只能有一个父类

一个父类可以派生出多个子类

class SubDemo extends Demo{}//ok

class SubDemo extends Demo1,Demo2…//error

1.一个类可以被多个子类继承。

2.一个类只能有一个父类。

3.子类和父类是相对的概念。

4.子类直接继承的父类称为直接父类。简介继承的父类称为：间接父类

5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明得属性和方法

6.ctrl+t查看继承结构

四、object类说明

       1.如果我们没有显示的声明一个类的父类的话，则此类继承于Java.lang.Object类

       2.所有的Java类（除Java.lang.Objevt类之外）都直接或间接继承于java.lang.Object类

       3.意味着所有的Java类都具有Java.lang.Object类声明功能。

class Person{
    String name;
    int age;
    public Person(){
    }
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}
 
class Student extends Person{
        String name;
        int age;
        String major;
 
public Student(String name,int age,String major){
        this.name=name;
        this.age=age;
        this.major=major;
        }
public void eat(){
            System.out.println("吃饭");
            }
        }
 
class ExtendTest{
    public static void main(String[] args){
        Person p1=new Person();
        p1.age=1;
        p1.eat();
        Student s1=new Student("zhuyuan",10,"搬砖");
        s1.eat();
        s1.sleep();
    }
}

 从上面的代码中我们可以看出我们的Student类继承了我们person类，从而也能使用person类中的方法。

方法的重写override/overwrite 

在上面的代码中，我们发现在person中的有些类在student中也定义过，这个时候就会发生方法的重写。

定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

要求：

1.子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表

2.子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型

3.子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限

子类不能重写父类中声明为private权限的方法

4.子类方法抛出的异常不能大于父类被重写的方法的异常

注意：

子类与父类中同名同参数的方法必须同时声明为非static的（即为重写），或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

例子 

package person;
 
public class Person {
    String name;
    int age;
 
    public Person(){
    }
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void eat(){
        System.out.println("吃饭");
    }
    public void walk(int distance){
        System.out.println("走路的距离是"+distance+"km");
    }
}

package person;
 
public class student extends Person{
    String major;
    public student(){
    }
    public student(String major){
        this.major=major;
    }
 
    public void study(){
        System.out.println("学习，专业是："+major);
    }
 
    public void eat(){
        System.out.println("吃饭饭");
    }
}

当我们重写完代码之后，编译器是会有提示的。 

package person;
 
public class test {
    public static void main(String[] args){
        student s1=new student("计算机科学与技术");
        s1.eat();
        s1.walk(10);
        s1.study();
    }
}

方法的重写（override/overwrite）

1.重写，子类继承父类之后，可以对父类中同名同参数的方法，进行覆盖操作

2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。

3.重写的规定

方法的声明：权限修饰符 返回值类型 方法名（形参列表）throw 异常的类型{

                //方法体

        }

约定俗成：子类中的叫重写的方法，父类中的叫被重写的方法

①子类重写的方法名和形参列表与父类中被重写的方法名和形参列表相同

②子类重写的方法的权限修饰符不小于父类中被重写的方法的权限修饰符，如果权限变小，会产生下面的报错。

 >特殊情况：子类不能重写父类中声明为private的方法。（重写方法的提示消失了）

 ③返回值类型：

>如果父类被重写的方法的返回类型是void，则子类重写的方法的返回值类型也只能是void

>父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类。（在我们下面的代码中，我们的父类所写的返回值类型为Object，但是我们子类中的类型为String，编译器提示这个也是可以构成重写的。）

 

 

 

 >父类被重写的方法的返回值类型是基本数据类型（比如：double），则子类重写的方法的返回值类型必须是相同的基本数据类型（double）

在下面的示例中我们的person类中的返回值类型为double，而我们的student类中返回的类型为int类型时，就会报错。

 

 

 ④子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

子类和父类中的同名同参数的方法要么都声明为static的，要么都声明为非static的。（不是重写） 

Super关键字的使用

1.super理解为父类的……

2.super可以用来调用：属性、方法、构造器

3.super的使用：调用属性和方法

3.1我们可以在子类的方法或者构造器中，通过使用“super.属性”或"super.方法”的方式，显式地调用我们的父类中声明的属性或方法。但是，在通常情况下，我们习惯省略“super”

3.2特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中生命的属性，则必须显式地使用“super.属性”的防暑，表名使用的是父类中的方法或者属性。

3.3特殊情况：当子类中重写了父类中的方法以后，我们想在子类的方法中调用弗雷德被重写的方法时，则必须显式的使用“super.方法”的方式，表名调用的是父类中被重写的方法。

 举例：

以下是我们的文件结构 

以下是我们在Person中定义的方法和属性 

package person;
 
public class Person {
    String name;
    int age;
    int id=330021;//身份证号
    public Person(){
    }
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void eat(){
        System.out.println("吃饭");
    }
    public void walk(int distance){
        System.out.println("走路的距离是"+distance+"km");
    }
    public Object info(){
        return null;
    }
    public double info1(){
        return 1.0;
    }
}

 以下是我们在student类中定义的方法和属性

package person;
 
public class student extends Person{
    String major;
    int id=1001;//学号
 
    public student(){
    }
    public student(String major){
        this.major=major;
    }
 
    public void study(){
        System.out.println("学习，专业是："+major);
    }
 
    public void eat(){
        System.out.println("吃饭饭：吃自己想吃的");
    }
 
    public String info(){
        return null;
    }
    public double info1(){
        return 1.0;
    }
 
    public void show(){
        System.out.println("name="+this.name+"   age="+super.age+"     id"+id+"    id"+super.id);
        this.eat();
        super.eat();
    }
}

 以下是我们测试文件中的代码

package person;
 
public class test {
    public static void main(String[] args){
        student s1=new student("计算机科学与技术");
        s1.show();
    }
}

我们发现在父类和子类重名的方法下，只要我们使用了super指令，返回的结果就是父类的，如果我们使用的是this指令，我们得到的返回结果就是子类的。 

 

 4.super调用构造器

4.1我们可以在子类的构造器中显式的使用“super（形参列表）”的方式，调用父类中声明的指定的构造器

4.2“super（形参列表）”的使用，必须声明在子类构造器的首行

4.3我们在类的构造器中，针对于“this（形参列表）”或“super（形参列表）”只能二选一，不能同时出现。

4.4当在构造器的首行，没有显式地声明“this（形参列表）”或“super（形参列表）”则默认调用的是父类中的空参的构造器。

（所以，如果父类中没有空参构造器的话，就会在子类中产生报错的现象）

4.5在类的多个构造器中，至少有一个类的构造器使用了“super（形参列表）”，调用父类中的构造器。

测试 

以下是我们父类中的定义 

package person;
 
public class Person {
    String name;
    int age;
    int id=330021;//身份证号
    public Person(){
    }
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
 
}

以下是我们子类中的方法，在下面public student中我们所调用的super(name,student)就是我们上述中的使用super调用构造器的做法 

package person;
 
public class student extends Person{
    String major;
    int id=1001;//学号
 
    public student(String name,int age,String major)
    {
        super(name, age);
        this.major=major;
    }
    public void show(){
        System.out.println("name="+this.name+"   age="+super.age+"     id"+id+"    id"+super.id);
 
    }
}

 以下为测试代码

package person;
 
public class test {
    public static void main(String[] args){
        student s1=new student("TOM",21,"IT");
        s1.show();
    }
}

 子类实例化父类对象的过程

1.从结果上来看：（继承性）

        子类继承父类之后，就获取了父类中声明的属性或方法

创建子类的对象，在堆空间中，就会加载所有父类中声明的属性

2.从过程上来看：

        当我们通过子类的构造器创造子类对象时，我们一定会直接或者间接地调用父类的构造器，进而调用父类的父类的构造器，直到调用了java.lang.Object类中空参的构造器的为止。正因为加载过所有负累的结构，所以才可以看到内存中有父类中的结构。。子类对象才可以考虑进行调用。

明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类的对象。

三、多态性

1.理解多态性：可以理解为一个事物的多种形态

2.何为多态性：

        对象的多态性：弗雷德引用指向子类的队形（或者子类的对象赋给父类的引用）

3.多态的使用：虚拟方法调用

        有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在执行期，我们实际执行的是子类重写父类的方法。

总结：编译看左边，运行，看右边。

4.多态性的使用前提：①要有类的继承关系。②要有方法的重写。

5.对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

对象的多态性：父类的引用指向子类的对象

可以直接应用在抽象类和接口上

JAVA引用变量有两个类型：编译时类型和运算时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边，运行时看右边

>若编译时类型和运行时的类型不一样，就出现了对象的多态性(Polymorphism)

>多态情况下，“看左边”：看得是父类的引用（父类中不具备子类特有的方法）

                          “看右边”：看得是子类的对象（实际运行的是子类重写父类的方法）

举例：

以下是我们文件的结构

 以下是我们写在Person中的代码

package person;
 
public class Person {
    String name;
    int age;
    int id=330021;//身份证号
    public Person(){
    }
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void eat(){
        System.out.println("吃饭");
    }
    public void walk(int distance){
        System.out.println("走路的距离是"+distance+"km");
    }
    public Object info(){
        return null;
    }
    public double info1(){
        return 1.0;
    }
}

以下是我们写在man中的方法和属性

package person;
 
public class Man extends Person{
    boolean isSmoking;
    public void earnMoney(){
        System.out.println("赚钱养家");
    }
    public void walk(){
        System.out.println("大步走路");
    }
 
    public void eat(){
        System.out.println("撸串");
    }
}

以下是我们写在Woman中的属性和方法

package person;
 
public class Woman extends Person{
    boolean isBeauty;
    public void goShopping(){
        System.out.println("购物");
    }
    public void walk(){
        System.out.println("小步走路");
    }
 
    public void eat(){
        System.out.println("减肥，不想吃");
    }
}

以下是我们写在测试文件中的代码

package person;
 
public class test {
    public static void main(String[] args){
        Person p1=new Person();
        p1.eat();
 
        Man man=new Man();
        man.eat();
        man.age=25;
        man.earnMoney();
 
        //对象的多态性：父类的引用指向子类的对象
        Person p2=new Man();
        //当调用字符类同名同参数的方法时，实际执行的是子类重写父类的方法--虚拟方法调用。
        p2.eat();
        p2.walk(12);
        Person p3=new Woman();
    }
}

 为什么要有多态性

在下面的代码中给我们先创建了一个动物类，狗类和猫类，然后我们使用了多态性的特点，定义我们的func(Animal animal)然后我们在调用的时候，就可以直接写test.func(Dog dog)。因此我们不需要重写下面注释部分的代码，为我们提供了极大的便利。

在真实情况中，如果我们需要连接不同的数据库，我们同样可以利用多态性的方法，仿照下面的代码，进行定义，这样我们就不需要对每一个数据库都进行一个方法的重载。

package person;
 
public class AnimalTest {
    public static void main(String[] args){
        AnimalTest test=new AnimalTest();
        test.func(new Dog());
        test.func(new Cat());
    }
    public void func(Animal animal)
    {
        animal.eat();
        animal.shout();
    }
    
//    public void func(Dog dog){
//        dog.eat();
//        dog.shout();
//    }
//    public void func(Cat cat){
//        cat.eat();
//        cat.shout();
//    }
}
class Animal{
    public void eat(){
        System.out.println("进食");
    }
    public void shout(){
        System.out.println("动物，叫");
    }
}
 
class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃骨头");
    }
    public void shout(){
        System.out.println("汪汪汪");
    }
}
 
class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void shout(){
        System.out.println("喵喵喵");
    }
}

虚拟方法的调用

正常的方法调用：

Person e=new Person();

e.getinfo();

Student e =new Student();

e.getinfo();

虚拟方法调用（多态情况下）

子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用再编译期是无法确定的

Person e=new Student();

e.getInfo();//调用的是Student类的getinfo()方法

编译时类型的和运行时类型

编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getinfo()方法。--动态绑定

关键字instanceof操作符的调用

 x instanceof A ：检验x是否为类A的对象，返回值为boolean型

>要求x所属的类与类A必须是子类和父类的关系，否则编译错误

>如果x属于类A的子类B，x instanceof A值也为true

 ​​​​​​​

 在下面的代码中，我们将我们的p2类型强制类型转换成了man之后，我们就能够使用man类型中的方法了。 

package person;
 
public class test {
    public static void main(String[] args){
        Person p1=new Person();
        p1.eat();
 
        Man man=new Man();
        man.eat();
        man.age=25;
        man.earnMoney();
 
        //对象的多态性：父类的引用指向子类的对象
        Person p2=new Man();
        //当调用字符类同名同参数的方法时，实际执行的是子类重写父类的方法--虚拟方法调用。
        p2.eat();
        p2.walk(12);
        //有了对象的多态性以后，内存中实际上是加载了子类所特有的属性和方法，但是由于变量声明为父类类型，导致
        //编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用
 
        //如何才能调用子类特有的属性和方法？
        //向下转型使用强制类型转换符
        Man m1=(Man) p2;
        m1.isSmoking=true;
        m1.earnMoney();
    }
}

 

 使用强制类型转换时，可能出现ClassCastException的异常。为了避免出现这种情况，我们创建了instanceof关键字

Woman w1=(Woman) p2;
w1.goShopping();

 a instanceof A：判断对象a是否是类A的实例。如果是，返回TRUE，如果不是返回false

使用情景：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof操作判断，一旦返回true，就进行向下转型。如果返回false，则不进行向下转型。

如果 a instanceof A 返回true，则a instanceof B也返回true.

其中类B是A的父类。

package person;
 
public class test {
    public static void main(String[] args){
        Person p1=new Person();
        //对象的多态性：父类的引用指向子类的对象
        Person p2=new Man();
        //有了对象的多态性以后，内存中实际上是加载了子类所特有的属性和方法，但是由于变量声明为父类类型，导致
        //编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用
 
        //如何才能调用子类特有的属性和方法？
        //向下转型使用强制类型转换符
        Man m1=(Man) p2;
        if(p2 instanceof Woman){
            Woman w1=(Woman) p2;
            w1.goShopping();
        }
        if(p2 instanceof Man){
            Man w1=(Man) p2;
            w1.earnMoney();
        }
 
    }
}