06 Java面向对象编程（四）——面向对象三大特性

最新推荐文章于 2024-10-19 22:23:18 发布

气运2020

最新推荐文章于 2024-10-19 22:23:18 发布

阅读量93

点赞数

分类专栏： JavaSE笔记-狂神文章标签： java

本文链接：https://blog.csdn.net/weixin_46307478/article/details/120209343

版权

JavaSE笔记-狂神专栏收录该内容

47 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的面向对象三大特性：封装、继承和多态。封装强调数据隐藏和访问控制，提高代码安全性及可维护性；继承允许子类继承父类属性和方法，实现代码复用；多态则提供了动态编译和方法重写，增强了程序的灵活性。文中通过示例代码展示了如何实现这些特性，并探讨了它们在实际编程中的应用。

摘要由CSDN通过智能技术生成

四、面向对象三大特性（重点）

1.封装

程序设计要求“高内聚，低耦合”。

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

低耦合：仅仅暴露少量的方法给外部使用。

封装就是对数据的隐藏。通常，应该禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这成为信息隐藏。

封装的核心：属性私有，set/get <----- private

封装的意义：

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
增加系统的可维护性

package com.oop.demo02;

//类
public class Student {

    //属性私有
    private String name;
    private int age;
    private int id;
    private char sex;

    //提供一些可以操作这个属性的方法
    //提供一些public的get、set方法

    //get  获得这个数据
    public String getName() {
        return this.name;
    }

    //set 给这数据设置值
    public void setName(String name) {
        this.name = name;
    }

    //Alt+insert 可以自动生成get、set方法 Setter and Getter


    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0) {
            this.age = age;
        } else {
            this.age = 3;
        }

    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

package com.oop.demo02;

public class Application {
    public static void main(String[] args) {

        Student st = new Student();

        st.setName("zhangsan");
        System.out.println(st.getName());

        st.setAge(999);//不合法
        System.out.println(st.getAge());
    }
}

2.继承

继承的本质是对某一批类的抽象，从而实现对现实世界的更好建模。

extends的意思是扩展，子类是父类的扩展。

Java中类只有单继承（直接仅一个，可以间接多个），没有多继承！

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

1）Object类

在Java中所有的类，都默认直接或者间接继承Object类

Ctrl+H 快捷键，打开树结构。

package com.oop.demo03;

//在Java中所有的类，都默认直接或者间接继承object类

//父类
public class Person {

    //父类中public的，子类可以继承
    //父类中的private，子类不可以继承！
    private int money =100000000;

    public void say() {
        System.out.println("说了一句话");
    }

}

package com.oop.demo03;

//子类（派生类）
public class Student extends Person{
}

package com.oop.demo03;

//子类（派生类）
public class Teacher extends Person{
}

package com.oop.demo03;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();

        Person person = new Person();
    }
}

2）super

super注意点：

super调用父类的构造方法，必须在构造方法的第一行；
super只能出现在子类的方法或者构造方法中；
super和this不能同时调用构造方法（因为都必须放在第一行）

super VS. this

代表的对象不同：this表示本身调用者这个对象；super代表父类对象
前提：this没有继承也可以使用；super只能在继承条件下才能使用
构造方法：this()本类的构造；super()父类的构造

package com.oop.demo04;

public class Person {

    public Person() {
        System.out.println("Person类的无参构造执行了");
    }

    //提示：若写了有参构造，一定要将无参构造显示的定义出来，否则子类默认还会调用无参构造，报错
    public Person(String name) {
        System.out.println("Person类的有参构造执行了");
    }

    protected String name = "Father";

    //若改为private,私有的东西无法被子类继承
    public void print() {
        System.out.println("Person");
    }


}

package com.oop.demo04;


import java.util.Optional;

public class Student extends Person {

    public Student() {
        //隐藏代码，默认先去执行父类的构造，再执行子类的
        //super();//若显示调用父类的构造器，必须在子类构造器的第一行
        System.out.println("Student类的无参构造执行了");
    }

    private String name = "Son";

    public void print() {
        System.out.println("Student");
    }

    public void test(String name) {
        System.out.println(name);//songsong
        System.out.println(this.name);//Student  this指代调用者本身，此处即为子类
        System.out.println(super.name);//Person  super指代父类的
    }

    public void test1() {
        print();//Student
        this.print();//Student  this指代调用者本身，此处即为子类
        super.print();//Person  super指代父类的
    }

}

package com.oop.demo04;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("songsong");
        System.out.println("===============");
        student.test1();
    }
}

3）方法重写

重写都是方法的重写，和属性无关。

静态方法和非静态方法区别很大！

重写与静态方法无关，只与非静态方法有关：

对于静态方法，方法的调用只和左边定义的类型有关
对于非静态方法，子类可以重写父类的方法，子类重写了父类的方法后，就执行子类

重写（需要有继承关系，子类重写父类的方法）

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大但是不可以缩小 public>protected>Default>private
抛出的异常：范围可以缩小，但不能扩大 ClassNotFoundExection --> Exception(大)

重写：子类的方法和父类必要一致，方法体不同！

为什么需要重写？

父类的功能，子类不一定需要，或者不一定能满足。

静态方法：

//静态方法
package com.oop.demo05;

//子类
public class A extends B {

    public static void test() {
        System.out.println("A---->test()");
    }
}



package com.oop.demo05;

//父类
public class B {
    public static void test() {
        System.out.println("B---->test()");
    }
}



package com.oop.demo05;

public class Application {
    public static void main(String[] args) {

        //对于静态方法，方法的调用只和左边定义的类型有关

        A a = new A();
        a.test();//A

        //父类的引用指向子类(即可以进行类型转换）
        B b = new A();
        b.test();//B
    }
}

非静态方法：

package com.oop.demo05;

//子类
public class A extends B {

    //Alt+Insert Override,重写
    @Override //注解：有功能的注释
    public void test() {
        //super.test();//默认调用父类的，也可以自己重写
        System.out.println("A---->test");
    }
}


package com.oop.demo05;

//父类
public class B {
    public void test() {
        System.out.println("B---->test()");
    }
}


package com.oop.demo05;

public class Application {
    public static void main(String[] args) {

        //静态方法方法的调用只和左边定义的类型有关
        //非静态方法，子类重写了父类的方法后，就执行子类
        A a = new A();
        a.test();//A

        //父类的引用指向子类(即可以进行类型转换）
        B b = new A();
        b.test();//A
    }
}

3.多态

动态编译：可扩展性

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用类型有很多。

对象能执行那些方法，主要看对象左边的类型，和右边关系不大；当子类重写了父类的方法后，执行的是子类的。

多态的注意：

多态是方法的多态，属性没有多态
父类和子类，有联系，类型转换异常（ClassCaseExeception）
存在条件：继承关系，方法需要重写，父类引用指向子类对象（Person s2 = new Student();）

static方法属于类，不属于实例，不能重写；
final是常量，不能重写；
private方法，不能重写

package com.oop.demo06;

public class Person {

    public void run() {
        System.out.println("Father");
    }
}

package com.oop.demo06;

public class Student extends Person {
    @Override
    public void run() {
        System.out.println("son");
    }

    public void eat() {
        System.out.println("son");
    }
}

package com.oop.demo06;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student
        //new Person

        //可以指向的引用类型不确定:父类的引用指向子类
        Student s1 = new Student();//子类Student能调用的方法都是自己的，或者继承父类的
        Person s2 = new Student();//父类Person,可以指向子类，但是不能调用子类独有的方法
        Object s3 = new Student();


        //一个类的实际类型是确定的，但是可以指向不同的引用类型
        s1.run();//son  子类重写了父类的方法，执行子类的方法
        s2.run();//son

        //对象能执行那些方法，主要看对象左边的类型，和右边关系不大
        s1.eat();
        //s2.eat();不能执行
        ((Student) s2).eat();//把Person强制转换为Student类型，可以执行


    }
}

类型转换（instanceof)

可以判断一个对象是什么类型，判断两个类之间是否有父子关系

System.out.println(X instanceof Y);//能不能编译通过，主要看X和Y之间有没有父子关系
结果是true还是false，取决于 X实际指向的类型是否是 Y的子类型

多态总结：

父类可以指向引用子类的对象
把子类转换成父类，向上转型，自动；
把父类转换成子类，向下转型，强制转换
方便方法的调用（无需重新new一个类，通过升级降级来调用）

package com.oop.demo07.demo06;

import java.awt.event.WindowStateListener;

public class Application {
    public static void main(String[] args) {

        //Object > String
        //Object > Person > Student
        //Object > Person > Teacher

        Object object = new Student();

        //System.out.println(X instanceof Y);//能不能编译通过，主要看X和Y之间有没有父子关系
        //结果是true还是false，取决于 X实际指向的类型 是否是 Y的子类型

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false

        System.out.println("================");

        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
        //System.out.println(person instanceof String);//编译报错，没有任何关系

        System.out.println("================");

        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);//编译报错，没有任何关系
        //System.out.println(student instanceof String);//编译报错，没有任何关系

    }
}

package com.oop.demo07.demo06;

public class Person {
    public void run() {
        System.out.println("father-->run");
    }

}



package com.oop.demo07.demo06;

public class Student extends Person {
    public void go() {
        System.out.println("son-->go");
    }

}



package com.oop.demo07.demo06;


public class Application {
    public static void main(String[] args) {

        //类型转换（高转低）

        //高  ------>   低（父类转换成子类，强制转换）
        Person obj = new Student();
        //将obj这个Person类型的对象转换成Student类型，我们就可以使用Student类型的方法了（高转低，强制转换）

        Student student = (Student) obj;
        student.go();//强制转换后，可以使用子类的方法
        //((Student) obj).go();


        //低  ------>   高（子类转换成父类，可能会丢失一些方法）
        Student stu = new Student();
        stu.go();
        Person per = stu;//低转高，自动即可转换，无需强制转换
        per.run();

    }
}