JAVA面向对象-定义及使用继承封装多态

Bin Bin

已于 2022-11-20 15:31:14 修改

阅读量149

点赞数

文章标签： python 开发语言

于 2022-11-17 00:23:36 首次发布

本文链接：https://blog.csdn.net/m0_65068333/article/details/127895910

版权

1、什么是面向过程？
面向过程：

就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

举例来说（办证）需要几步？

按照面向过程思想：

第一步：找到办事的人

第二步：给办事的准备资料

第三步：办完证，证件反馈给我

这里我们就看出来，面向过程就是把一件事按步骤一步一步来实现

代码表示

public void find(){}

public void handle(){}

public void feedback(){}

依次调用这些方法就行

2、什么是面向对象？

对 Java 语言来说，一切皆是对象。把现实世界中的对象抽象地体现在编程世界中，一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计，这些对象可以是独立存在的，也可以是从别的对象继承过来的。对象之间通过相互作用传递信息，实现程序开发。

对象，就是对问题中的事物的抽象。

面向对象：

就是把现实中的事物都抽象为“对象”。每个对象是唯一的，且都可以拥有它的属性与行为。我们就可以通过调用这些对象的方法、属性去解决问题。

用面向对象思想解决大象装进冰箱

大致的了解到了对象这个概念，可以说是对现实事物的一种抽象映射。

例如在这个事件中：

冰箱作为一个对象；

大象作为一个对象。

冰箱有这些功能：开门、装物体、关门

class fridge{
public void open(大象){} //开门
public void putIn(大象){} //放进冰箱
public void close(大象){} //关门
}
class elephant{
public void eat(){} //吃
}

每个对象是独立的，有属于它自己的功能，只需要实现自己的功能就好。所以在建立对象的时候，只关注对象有什么的功能，先不考虑如何实现这些功能。

面向对象的好处，就包括有很好的延展性，比如我给大象赋予了一个吃的功能，它通过调用就可以在冰箱里去吃东西。面向对象就是把现实问题抽象为对象，通过调用每个对象的属性或功能去解决问题。

如果我要修改我的需求，把大象换成小狗，我用面向过程是不是得把每个步骤中的大象改为小狗。而用面向对象解决，我甚至可以重新创一个小狗对象，仅仅在调用的时候选择小狗就行了。

二、类的定义
类的概念：

类（Class）是面向对象程序设计（OOP，Object-Oriented Programming）实现信息封装的基础。类是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。

对象的概念:

Java 是面向对象的编程语言，对象就是面向对象程序设计的核心。所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。

对象有以下特点：

1.对象具有属性和行为。

2.对象具有变化的状态。

3.对象具有唯一性。

4.对象都是某个类别的实例。

5.一切皆为对象，真实世界中的所有事物都可以视为对象。

类是对象的抽象，对象是类的具体。

事物与类的对比
现实世界的一类事物:
属性: 事物的状态信息。行为: 事物能够做什么。

java中用class描述事物也是如此:
成员变量: 对应事物的属性。成员方法: 对应事物的行为。

类的定义格式
public class ClassName{
//成员变量

//成员方法

}

定义类:就是定义类的成员，包括成员变量和成员方法。
成员变量:和以前定义变量几乎是一样的。只不过位置发生了改变，在类中，方法外。
成员方法:和以前定义方法几乎是一样的。只不过把static去掉。
讲解，
类的定义格式举例:

public class Student{

//成员变量

String name; //姓名

int age; //年龄

}

三、基本特征：封装、继承、多态
1、封装
（一）基本概念

将一类事物的属性和行为抽象成一个类，使其属性私有化，行为公开化，提高了数据的隐秘性的同时，使代码模块化。这样做使得代码的复用性更高。

意义：

1.将属性和方法放到一起做为一个整体，然后通过实例化对象来处理；

2.隐藏内部实现细节，只需要和对象及其属性和方法交互就可以了；

3.对类的属性和方法增加访问权限控制。

（二）四种访问控制级别

public：对外公开，访问级别最高

protected：只对同一个包中的类或者子类公开

默认：只对同一个包中的类公开

private：不对外公开，只能在对象内部访问，访问级别最低

（三）封装使用

把尽可能多的东西藏起来，对外提高简洁的接口

加入某种属性允许外界访问，那么提供访问该属性的公开方法。假如狗类有一个名字、年龄属性，不允许外界直接访问属性，但允许提供get和set方法来访问。

使用private方法，不能直接被外部访问，需要getter、setter方法

**
 * 封装 :把属性私有化，实现了对外界的隐藏，然后通过共有的getter和setter方法对属性进行获取和赋值，保证了操作的安全性。
 * 一般属性私有化(private)，方法公有化(public)，除非方法只是用来内部调用，可以private修饰
 * 1.对属性使用private私有化进行修饰，实现了对外界的隐藏，外界不能够直接操作类的属性。
 * 2.定义针对属性的getter和setter方法，完成对属性的获放和设置值，在发放中可以完成完会验证。
 *
 * 注意:
 * 属性私有化后也可以通过有参数的构造方法进行赋值，且在有参构造方法中进行安全验证。
 */
public class Student {
 
    //成员变量 （属性）-----变量----储存数据的
    private String name;
    private String sex;
    private  int age;
    private  double height;
 
    /**
     * 构造方法：用来初始化对象（构造方法是用来创建对象的）
     * 语法：  访问修饰符 类名（参数列表..）{}
     */
    //无参构造方法
    public Student(){
        System.out.println("无参的构造方法被调用！");
    }
    //有参构造方法:可以实现对类的属性进行赋值
    public Student(String name, String sex, int age, double height) {
        System.out.println("有参的构造方法被调用！");
        this.name = name;
        this.sex = sex;
        if(age>=0&&age<=100){
            this.age = age;
        }
        if (height>0){
            this.height = height;
        }
    }
 
    //getter setter
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getSex() {
        return sex;
    }
 
    public void setSex(String sex) {
        this.sex = sex;
    }
 
    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;
    }
 
    //toString：打印类的对象是打印的内存地址，重写了该方法，打印时就显示的是类的属性值列表
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
 
    //成员方法（行为）----方法----完成---完成一些功能的---面向对象的体现
    public void introduce(){
        System.out.println("我是"+name+",性别"+sex+",今年"+age+"岁,身高:"+height);
    }
}

public class Test {
    public static void main(String[] args){
        //调用构造方法，实例化类的对象
        Student stu = new Student();
        stu.setName("张三");
        stu.setSex("男");
        stu.setAge(18);
        stu.setHeight(185.3);
        stu.introduce();
        System.out.println(stu);
 
        System.out.println("----------------------");
        Student stu1 = new Student("李四","男",29,217);
        stu1.introduce();
    }
}

2、继承
让某个类型的对象获得另一个类型的对象的属性和方法。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

好处

1、提高代码的复用性

2、类与类之间产生了关系，是多态的前提

通过extends关键字，可以声明一个子类继承另一个父类，定义格式如下：

class 子类 extends 父类{}

继承父类成员变量/方法hanqishi继承了父类Dog

class Dog{
 
 public String name="小白";
 
  public void say(){
 
     System.out.println("汪汪汪");
 
   }
 
}
 
//哈奇士
 
class haqishi extends Dog {
 
    public void test(){
 
       System.out.println(name);
 
        say();
 
    }

调用haqishi的test()方法，测试如下：

小白

汪汪汪

测试结果：子类haqishi继承了父类的成员变量和成员方法

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

重写父类方法

子类haqishi重写父类Dog的say方法


class Dog{
 
   public String name="小白";
 
    public void say(){
 
      System.out.println("汪汪汪");
 
    }
 
}
 
//哈奇士
 
class haqishi extends Dog {
 
    public void say() {
 
       //super.say();    继承父类原有方法
 
       System.out.println("哈哈哈");    }
 
}

调用子类say方法，测试如下：

哈哈哈

重载父类方法

重载方法必须满足以下条件：

1、方法名相同

2、方法的参数类型、个数、顺序至少有一项不同

3、方法的返回类型可以不同

4、方法的修饰符可以不相同


class Dog{
 
    public String name="小白";
 
    public void say(){
 
        System.out.println("汪汪汪");
 
    }
 
}
 
//哈奇士
 
class haqishi extends Dog {
 
   //重载 改变参数
 
    public void say(String name) {
 
       System.out.println(name+"汪汪汪");
 
    }
 
//重载 改变参数+返回值
 
    public int say(int age) {
 
        System.out.println("汪汪汪"+age);
 
        return age;
 
    }


分别调用:/

haqishi h = new haqishi();

h.say();

h.say(“哈奇士”);

h.say(6);

结果如下：

汪汪汪

哈奇士汪汪汪

汪汪汪6

注意事项：

1.子类方法覆盖父类方法，必须要保证权限大于等于父类权限
2.子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

3接口

1什么是接口

接口是一种特殊的内部类，它里面的所有方法都没有实现。

2. 接口的特点：

1.接口中成员默认访问修饰符都是public，即便你不写。
2.定义接口必须interface关键字完成
3.接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量。
4. 接口中可以定义方法，方法也有固定的修饰符，public abstract
5. 接口中的成员都是公共的。
6. 接口不可以创建对象。
7. 子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类
8.接口最重要的体现：解决java单继承的弊端：类继承（继承基础功能）类同时实现接口（扩展功能）；
接口多继承，多个接口之间可以使用extends进行继承；

3接口语法的实现

先声明USB接口：其中规定了要实现USB接口就必须实现接口规定实现的read( )和write( )这两个方法

interface USB {
    void read();

    void write();
}

然后在写一个两个类，这两个类都去实现USB接口。（实现其中的方法）

class Jinshidun implements USB {
    @Override
    public void read() {
        System.out.println("金士顿正在通过USB功能读取数据");
    }
    @Override
    public void write() {
        System.out.println("金士顿正在通过USB功能写入数据");
    }
}

class Shandi implements USB {
    @Override
    public void read() {
        System.out.println("闪迪正在通过USB功能读取数据");
    }
    @Override
    public void write() {
        System.out.println("闪迪正在通过USB功能写入数据");
    }
}

那么，现在两个类都实现了USB功能，也就是说两个类都能够调用USB接口中规定的方法，并且他们实现的方式都不一样。