Java面向对象

52Hertzℕℕ

已于 2022-11-26 17:52:42 修改

阅读量144

点赞数

文章标签： java 开发语言

于 2022-11-20 19:01:53 首次发布

本文链接：https://blog.csdn.net/m0_71385552/article/details/127949493

版权

java面向对象的三大特性包括：封装，继承，多态。

一、封装

1.什么是封装

封装就是把客观事物封装成抽象的类，并且类可以把⾃⼰的数据和⽅法只让可信的类或者对象操作，对不可信的进⾏信息隐藏。

2.封装的使用

一般属性私有化(private)，方法公有化(public)，除非方法只是用来内部调用，可以使用private来修饰。

1.对属性使用private私有化来进行修饰，实现了对外界的隐藏，外界不能直接操作类的属性。

public class Student {
    //成员属性(变量)------存储数据的
    private String name;
    private int age;
    private double height;
}

2.定义针对属性的getter和setter方法，完成对属性的获取和设置值。

    /**
     * getter和setter方法
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

3.属性私有化后也可以通过有参数的构造方法进行赋值，且在有参构造方法中进行安全验证。

    //有参数的构造方法，可以实现对类的属性进行赋值
    public Student(String name,int age,double height){
        System.out.println("有参数的构造方法被调用!!!");
        this.name=name;
        if (age>=0 && age<=150){
            this.age=age;
        }
        if (height>=0){
            this.height=height;
        }
    }

//根据构造方法赋值
public static void main(String[] args) {

      Student student=new Student("张三",18,180.5);

}

3.封装的使用提高了代码的可重用性和安全性。

二、继承

1.继承关键字使用：extends

2.继承的含义

继承就是把及各类中相同的属性和方法抽离出来定义在基类中，子类不再需要定义这些属性和方法，继承之后，就相当于拥有了这些属性和方法。

1.子类继承父类，父类定义的公共的实行和方法子类会拥有，但是父类定义的私有化的属性和方法，子类不能继承。

2.父类继承过来方法，子类可以进行改造，重新实现功能（方法的重写）,调用的时候执行的是子类新实现的方法。

3.人的继承案例

person

//人类的功能和属性
public class Person {
    //属性
    public String name;
    public int age;
    public double height;

    //吃饭的功能
    public void eat(){
        System.out.println("按时吃饭");
    }
    
    //学习的功能
    public void study(){
        System.out.println("学习");
    }

    //睡觉的功能
    public void sleep(){
        System.out.println("睡觉");
    }
}

Student

//学生类继承人类
public class Student extends Person{
    //学生的学号
    public String stuId;

    //学生的无参构造方法(系统默认生成的，不写也可以)
    public Student() {
    }

    //学生娱乐的功能
    public void paly(){
        System.out.println("学生在娱乐");
    }
}

Teacher

//教师类继承人类
public class Teacher extends Person{

    //老师的工号属性
    private String teacherNo;

    //老师在工作的功能
    public void work(){
        System.out.println("老师在工作");
    }

}

测试类

public class Test01 {
    public static void main(String[] args) {
        //创建Student类对象
        Student student=new Student();
        student.eat();
        student.paly();
        
        System.out.println("----------------------------");
        
        //创建teachert类对象
        Teacher teacher=new Teacher();
        teacher.eat();
        teacher.work();

    }
}

运行结果如下所示：

三、多态

1.概叙

1.1 多态是继封装、继承之后，面向对象的第三大特性。

生活中，比如跑的动作，小猫小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来不同的形态。多态，描述的就是这样的状态。

1.2 定义

多态：是指同一行为，具有多个不同表现形式(调用同样的方法，执行的是不同的功能)。

1.3 前提

1.发生在有继承(extends)或者实现(implements)接口的情况下。 { 注：二选一 }

2.在子类中对方法进行了重写(意义体现：不重写，无意义)

3.父类引用指向子类对象（格式体现）

2.多态的使用

多态使用的格式：

父类类型变量名 = new 子类对象();

变量名.方法名();

父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

代码如下所示：

动物类

//动物类
public class Animal {
    public void call(){
        System.out.println("动物的叫声");
    }
}

猫类

//猫类
public class Cat extends Animal{
    public void call(){
        System.out.println("猫的叫声");
    }
}

狗类

//狗类
public class Dog extends Animal{
    public void call(){
        System.out.println("狗的叫声");
    }
}

测试类

//测试类
public class Test {
    public static void main(String[] args) {
        Animal a1 = new Cat();
        Animal a2 = new Dog();
        a1.call();
        a2.call();
    }
}

输出结果如下所示：

3.多态的好处

在开发中，可以把父类(或接口类型)类型定义为方法的形参，在实际调用的时候传入的实际参数就比较灵活，可以传入父类类型的对象，也可以传入任意一个子类类型的对象。

4.引用类型转换

多态的转型分为向上转型与向下转型两种：

4.1 向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

当父类引用指向子类对象时，便是向上转型。

使用格式：父类类型变量名 = new 子类类型();

如：Animal a = new Cat();

代码如下：

public class Test {
    public static void main(String[] args) {
        Animal a1 = new Cat();
        Animal a2 = new Dog();
        a1.call();
        a2.call();
    }
}

4.2 向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

使用格式：子类类型变量名 =(子类对象) 父类变量名;

如：Cat c = (Cat) a;

代码如下：

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

        Cat c= (Cat) new Animal();
        c.call();

    }
}

注意：向上转型是自动转换，不会存在问题，但是向下转型是强制转换，可能存在问题。

5. 转型的意义

当使用多态方法调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误，也就是说不能调用子类拥有而父类没有的方法，编译都错误更别说运行了。这也是多态给我们带来的一点"小麻烦" 。所以，想要调用子类特有的方法，必须做向下转型。

6. 补充

调用类里面的方法有两种方法：

1. 静态方法：类名 . 方法名;

2. 非静态方法：实例化对象 (new 类名() )，然后对象名 . 方法名();

四、抽象类及抽象方法

1.由来

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

2.抽象类

①. 抽象类里面不是必须有抽象方法。

②. 一个类里面有抽象方法，这个类必须是抽象的。

3.抽象方法

①. 方法只有声明没有方法体; 声明即规定方法三要数：方法名、参数列表、返回值类型

②. 要使用abstract关键字进行修饰。

③. 抽象方法定义格式：修饰符 abstract 返回值类型方法名（参数列表）；

代码举例：

public abstract void run();

3. 定义抽象方法的意义

①. 能够对子类进行约束：子类必须实现父类的抽象方法，或者子类声明为抽象类；

②. 抽象类通过定义抽象方法就实现了一种规范，要求他的子类必须具备某种功能，具体如何实现以子类的具体实现为准。

五、接口

1. 接口的概叙

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK7及以前），默认方法和静态方法（JDK8），私有方法（JDK9）。

2.接口的定义

他与定义类方法相似，但是使用 interface 关键字。他也会被编译成 .class 文件，但是一定要明确他并不是类，二十另外一种引用数据类型。

引用数据类型：数组，类，接口。

3.接口的使用

它不能创建对象，但是可以被实现（implements，类似于被继承）。一个实现接口的类（可以看作是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

4.定义格式

含有抽象方法

抽象方法：使用abstract关键字修饰，可以省略，没有方法体，该方法共子类实现使用。

代码如下：

public interface InterFaceName{

    public abstract void method();

}

含有默认方法和静态方法

默认方法：使用default修饰，不可省略，供子类调用或重写。

静态方法：使用static修饰，供接口直接调用。

代码如下：

public interface InterfaceName {
    //抽象方法
   // public abstract void method();
    
    //默认方法
    public default void method(){
        System.out.println("默认方法");
    }
    
    //静态方法
    public static void method2(){
        System.out.println("静态方法");
    }
}

含私有方法和私有静态方法

私有方法：使用private修饰，供接口中的默认方法或静态方法调用。

代码如下： 注意：仅JDK9版本支持此方法

public interface InterfaceName {

    //私有方法
    private void test1(){
        System.out.println("私有方法");
    }

    //私有静态方法
    private static void test1(){
        System.out.println("私有方法");
    }

}

六、this、super

1. this和super的含义

this：代表当前对象的引用（谁调用就代表谁）。

super：代表父类的存储空间表示（可以理解为父亲的引用）。

2. this和super的用法

this.成员变量表示本类的

super.成员变量表示父类的

this.成员方法名() 表示本类的方法

super.成员方法名() 表示父类的方法

用法演示，代码如下：

class Animal {

public void eat(){
    system.out.println("动物：eat");

    }
}

class Cat extends Animal {
    public void eat(){
        system.out.println("猫：eat")
    }

    public void eatTest(){
        this.eat();    //this    调用本类的方法
        super.eat();   //super    调用父类的方法
    }

}