封装继承多态

最新推荐文章于 2024-01-27 11:10:35 发布

Mr. pangfu

最新推荐文章于 2024-01-27 11:10:35 发布

阅读量158

点赞数

分类专栏： javaSE笔记文章标签： java 编程语言

本文链接：https://blog.csdn.net/qq_41483240/article/details/118544437

版权

javaSE笔记专栏收录该内容

15 篇文章 0 订阅

订阅专栏

初识面向对象

面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么
- 面对过程适合处理一些较为简单的问题
面向对象思想
- 物以类聚，分类的思维磨市，思考问题首先会解决问题需要那些分类，再对分类进行单独思考，最后才对某个分类下的细节进行面向过程的思索
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题
对于复杂描述的十五，为了从宏观上把握，从整体上合理分析，我们需要使用面向都对象的思路来分析整个系统。但是具体到围观操作，仍然需要面向过程的思路去处理
面向对象编程：Object-Oriented PrOgamming(OOP)
面向对象编程的本质是：以类的方式组织代码，以对象组织（封装）数据
三大特性：
- 封装
- 继承
- 多态
从人数论角度考虑是先有对象后有类，对象是具体的事物，类是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象，类是对象的模板

回顾方法及加深

方法的定义
- 修饰符
- 返回类型
- break和return的区别
  - break：跳出当前循环
  - return：结束方法，返回一个结果
- 方法名：驼峰原则，见名知意
- 参数列表（参数类型，参数名）…
- 异常突出（后面讲解）

方法的调用

静态方法

非静态方法

public class Demo02 {
    public static void main(String[] args) {
        Student student=new Student();
        student.say();
    }
    //静态方法 static
    /*1.新建一个Student类，并创建如下静态方法
    public static void say(){
        System.out.println("学生说话了");
    }
    2.在其他类中可以随意调用上面的静态方法，如果去掉static（即非静态），则不能调用
    3.那么要如何才能调用非静态方法呢==》实例化这个类即可，如下（以Student为例）
        Student student=new Student();
        student.say();
     */


    //非静态方法
    /*实例化这个类
    Student student=new Student();
        student.say();
     */
}

形参和实参

public class Demo03 {
    public static void main(String[] args) {
        add(2,3);
    }
    public static int add(int a,int b){
        return a+b;
    }
}
/*
实参：2；3
形参：a;b
*/

值传递和引用传递

//引用传递：传递的是对象，实质还是值传递
public class Demo04 {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);//null
        Demo04.change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){
        person.name="qinjiang";
    }
}
//定义一个Person类，有一个属性name
class Person{
    String name;
}

this关键字

类跟对象的关系

类是一种抽象的数据类型，它是某一类事物整体描述/定义，但是并不能代表某一个具体的事物
- Person类，Pet类，Car类等，这些类都是用来描述/定义某一类具体事物应该具备的特点和行为
对象是抽象概念的具体实例
- 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例
- 能够体现出特点，展现功能的是具体的实例而不是一个抽象的概念

创建和初始化对象

使用new关键字创建对象
使用new关键字创建对象的时候，除了分配内存空间之外，还会给创建好的对象进行默认初始化以及对类中构造器的调用
类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的，并且构造器有以下两个特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void

构造器(有参构造器无参构造器)必须要掌握

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    
    //显示的定义构造器
    String name ;//null
    //实例化初始值
    //无参构造

    //1.使用new关键字，本质是在调用构造器
    //2.用来初始化值
    public Person(){
        this.name="qinjang1";
    }

    //有参构造  一旦定义了有参构造，无参构造就必须显示定义
    public Person(String name){
        this.name=name;
    }
    //alt+insert
}
/*
构造器
  1.方法名和类名相同
  2.没有返回值
作用
  1.new：本质在调用构造方法
  2.初始化对象的值
  注意点：定义了有参构造之后，如果想调用无参构造，需要显示的（重新）定义一个无参的构造（构造一个空的构造器）
  快捷键： Alt + Insert
  this.*
 */

//一个项目应该只有一个main方法//总测试类

public class Application {
    public static void main(String[] args) {
        //使用new关键词实例化了一个对象person1
        Person person1=new Person();
        Person person2=new Person("qiangjang2");
        System.out.println(person1.name);
        System.out.println(person2.name);
    }
}
/*
qinjang1
qiangjang2
*/

封装详解

该露的露，该藏的藏
- 我们程序设计师追求高内聚，低耦合。高内聚就是类的内部数据操作细节自己完成，不允许外不干涉；低耦合就是暴露少量的方法给外部使用
- 封装的特点：
  - 只能通过规定的方法访问数据。
  - 隐藏类的实例细节，方便修改和实现。
封装：（数据的隐藏）
- 通常应该禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏
实现封装的具体步骤如下：
1. 修改属性的可见性来限制对属性的访问，一般设为 private。
2. 为每个属性创建一对赋值（setter）方法和取值（getter）方法，一般设为 public，用于属性的读写。getXxx/setXxx
3. 在赋值和取值方法中，加入属性控制语句（对属性值的合法性进行判断）。(比如对人的年龄进行合理性判断)

以下是对个人信息的封装：

public class Person {
    private String name; // 姓名
    private int age; // 年龄
    private String phone; // 联系电话
    private String address; // 家庭住址
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //创建公用的取值赋值方法来对私有属性进行读写
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        // 对年龄进行限制
        if (age < 18 || age > 40) {
            System.out.println("年龄必须在18到40之间！");
            this.age = 20; // 默认年龄
        } else {
            this.age = age;
        }
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

使用 private 关键字修饰属性，这就意味着除了Person类本身外，其他任何类都不可以访问这些属性。但是，可以通过这些属性的 setXxx() 方法来对其进行赋值，通过 getXxx() 方法来访问这些属性。

编写测试类PersonTest，在该类的 main() 方法中调用 Person属性的 setXxx() 方法对其相应的属性进行赋值，并调用 getXxx() 方法访问属性，代码如下：

public class PersonTest {
    public static void main(String[] args) {
        Person people1 = new Person();
        people1.setName("王某");//给Person类的属性赋值
        people1.setAge(35);
        people1.setPhone("18730296717");
        people1.setAddress("河北省保定市");
        System.out.println("姓名：" + people1.getName());//调用Person类的属性
        System.out.println("年龄：" + people1.getAge());
        System.out.println("电话：" + people1.getPhone());
        System.out.println("家庭住址：" + people1.getAddress());
    }
}

练习：要求编写表示图书的 Book 类，实现以下需求：
基本信息包括图书名称（bookName）、总页数（bookTotalNum），其中页数不能少于 200 页，否则输出错误信息，并赋予默认值 200。
为各个属性设置赋值和取值方法。

具有 details() 方法，该方法在控制台输出每本图书的名称和总页数。

/*创建Book类，
1.添加bookName，并封装，getBookName/setBookname
2.添加bookTotalNum属性，并封装,getBookTotalNum/setBookTotalNum
3.在Book类中添加公有的details()方法，输出图书的名称和总页数
*/
public class Book {
    // 书名
    private String bookName; 
    public String getBookName() {
        return bookName;
    }
    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
    // 图书总页数
    private int bookTotalNum; 
    public int getBookTotalNum() {
        return bookTotalNum;
    }
    public void setBookTotalNum(int bookTotalNum) {
        if (bookTotalNum < 200) {
        System.out.println(this.bookName + "这本书的页数不能少于 200 页");
        this.bookTotalNum = 200;
    } else {
        this.bookTotalNum = bookTotalNum;
    }
    }
    public void details() {
    System.out.println(this.bookName + "这本书的总页数是：" + this.bookTotalNum);
    }
}

public class BookTest {
    public static void main(String[] args) {
        Book book1 = new Book();
        book1.setBookName("《简爱》");
        book1.setBookTotalNum(100);
        book1.details();
        
        Book book2 = new Book();
        book2.setBookName("《龙族》");
        book2.setBookTotalNum(520);
        book2.details();
    }
}
/*
简爱总页数不能少于200页
书名：简爱 总页数200
书名：龙族 总页数520
*/

继承详解

继承是面向对象的三大特征之一，继承与显示生活的"继承"的相识之处是保留一些父辈的特性，从而减少代码冗余，提高程序的运行效率
java中的继承就是在已经存在类的基础上进行扩展，从而产生新的类。已经存在的类称为父类、基类或超类，而新产生的类称为子类或派生类。在子类中，不仅包含父类的属性和方法，还可以增加新的属性和方法
extends的意思是说”扩展“。子类是父类的扩展
```
修饰符 class class_name extends extend_class {
    // 类的主体
}
```
其中，class_name 表示子类（派生类）的名称；extend_class 表示父类（基类）的名称；extends 关键字直接跟在子类名之后，其后面是该类要继承的父类名称。例如：
```
public class Student extends Person{}
```
JAVA中类只有单继承，没有多继承(一个儿子只有一个爸爸，一个爸爸可能有多个儿子)
继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等(子类继承父类所有的方法)
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
例一：

创建人类 People，并定义 name、age、sex、sn 属性，代码如下：

public class People {
    public String name; // 姓名
    public int age; // 年龄
    public String sex; // 性别
    public String sn; // 身份证号
    public People(String name, int age, String sex, String sn) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.sn = sn;
    }
    public String toString() {
        return "姓名：" + name + "\n年龄：" + age + "\n性别：" + sex + "\n身份证号：" + sn;
    }
}

创建 People 类的子类 Student 类，并定义 stuNo 和 department 属性，代码如下：

public class Student extends People {
    private String stuNo; // 学号
    private String department; // 所学专业
    public Student(String name, int age, String sex, String sn, String stuno, String department) {
        super(name, age, sex, sn); // 调用父类中的构造方法
        this.stuNo = stuno;
        this.department = department;
    }
    public String toString() {
        return "姓名：" + name + "\n年龄：" + age + "\n性别：" + sex + "\n身份证号：" + sn + "\n学号：" + stuNo + "\n所学专业：" + department;
    }
}

由于 Student 类继承自 People 类，因此，在 Student 类中同样具有 People 类的属性和方法，这里重写了父类中的 toString() 方法。

创建 People 类的另一个子类 Teacher，并定义 tYear 和 tDept 属性，代码如下：

public class Teacher extends People {
    private int tYear; // 教龄
    private String tDept; // 所教专业
    public Teacher(String name, int age, String sex, String sn, int tYear, String tDept) {
        super(name, age, sex, sn); // 调用父类中的构造方法
        this.tYear = tYear;
        this.tDept = tDept;
    }
    public String toString() {
        return "姓名：" + name + "\n年龄：" + age + "\n性别:" + sex + "\n身份证号：" + sn + "\n教龄：" + tYear + "\n所教专业：" + tDept;
    }
}

编写测试类 PeopleTest，在该类中创建 People 类的不同对象，分别调用它们的 toString() 方法，输出不同的信息。具体的代码如下：

public class PeopleTest {
    public static void main(String[] args) {
        // 创建Student类对象
        People stuPeople = new Student("王丽丽", 23, "女", "410521198902145589", "00001", "计算机应用与技术");
        System.out.println("----------------学生信息---------------------");
        System.out.println(stuPeople);
        // 创建Teacher类对象
        People teaPeople = new Teacher("张文", 30, "男", "410521198203128847", 5, "计算机应用与技术");
        System.out.println("----------------教师信息----------------------");
        System.out.println(teaPeople);
    }
}
/*
----------------学生信息---------------------
姓名：王丽丽
年龄：23
性别：女
身份证号：410521198902145589
学号：00001
所学专业：计算机应用与技术
----------------教师信息----------------------
姓名：张文
年龄：30
性别:男
身份证号：410521198203128847
教龄：5
所教专业：计算机应用与技术
*/

object类（ctrl+H 打开继承树）
- 在Java中，所有的类都默认间接直接继承object类
由于子类不能继承父类的构造方法，因此，如果要调用父类的构造方法，可以使用 super 关键字。super 可以用来访问父类的构造方法、普通方法和属性。

super 关键字的功能：
- 在子类的构造方法中显式的调用父类构造方法
- 访问父类的成员方法和变量。

super调用父类构造方法

super 关键字可以在子类的构造方法中显式地调用父类的构造方法，基本格式如下：

super(parameter-list);

其中，parameter-list 指定了父类构造方法中的所有参数。super( ) 必须是在子类构造方法的方法体的第一行。

声明父类 Person，类中定义两个构造方法。示例代码如下：

public class Person {
    public Person(String name, int age) {
    }
    public Person(String name, int age, String sex) {
    }
}

子类 Student 继承了 Person 类，使用 super 语句来定义 Student 类的构造方法。示例代码如下：

public class Student extends Person {
    public Student(String name, int age, String birth) {
        super(name, age); // 调用父类中含有2个参数的构造方法
    }
    public Student(String name, int age, String sex, String birth) {
        super(name, age, sex); // 调用父类中含有3个参数的构造方法
    }
}

super调用成员属性/成员方法

public class Person {
    int age=25;
     public void infor(){
        System.out.println("this is person class!");
    }
}

public class Student extends Person {
    int age=18;
    void age1() {
        System.out.println("学生年龄：" + super.age);
    }
    void age2() {
        System.out.println("学生年龄：" + this.age);
    }
       void age3() {
        super.infor();
    }
}

public class Test {

        public static void main(String[] args) {
            Student stu = new Student();
            stu.age1();
            stu.age2();
            stu.age3();
        }
}
/*
学生年龄：25
学生年龄：18
this is person class!
*/

this 和 super的区别

this 指的是当前对象的引用，super 是当前对象的父对象的引用。下面先简单介绍一下 super 和 this 关键字的用法。

super 关键字的用法：

super.父类属性名：调用父类中的属性
super.父类方法名：调用父类中的方法
super()：调用父类的无参构造方法
super(参数)：调用父类的有参构造方法

如果构造方法的第一行代码不是 this() 和 super()，则系统会默认添加 super()。
this 关键字的用法：

this.属性名：表示当前对象的属性
this.方法名(参数)：表示调用当前对象的方法

方法重载

java允许同一个类中定义多个同名方法，只要它们的形参列表不同即可。如果同一个类中包含了两个或两个以上方法名相同的方法，但形参列表不同，这种情况被称为方法重载（overload）

//在 JDK 的 java.io.PrintStream 中定义了十多个同名的 println() 方法。
public void println(int i){…}
public void println(double d){…}
public void println(String s){…}

法重载的要求是两同一不同：同一个类中方法名相同，参数列表不同。至于方法的其他部分，如方法返回值类型、修饰符等，与方法重载没有任何关系。

方法重写

定义在子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写（override），又称为方法覆盖。当父类中的方法无法满足子类需求或子类具有特有功能的时候，需要方法重写。

子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强
在重写方法时，需要遵循下面的规则：
- 参数列表必须完全与被重写的方法参数列表相同。
- 返回的类型必须与被重写的方法的返回类型相同（Java1.5 版本之前返回值类型必须一样，之后的 Java 版本放宽了限制，返回值类型必须小于或者等于父类方法的返回值类型）。
- 访问权限不能比父类中被重写方法的访问权限更低（public>protected>default>private）。
- 重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常。例如，父类的一个方法声明了一个检査异常 IOException，在重写这个方法时就不能抛出 Exception，只能拋出 IOException 的子类异常，可以抛出非检査异常。
注意：
- 重写的方法可以使用 @Override 注解来标识。
- 父类的成员方法只能被它的子类重写。
- 声明为 final 的方法不能被重写。
- 声明为 static 的方法不能被重写，但是能够再次声明。
- 构造方法不能被重写。
- 子类和父类在同一个包中时，子类可以重写父类的所有方法，除了声明为 private 和 final 的方法。
- 子类和父类不在同一个包中时，子类只能重写父类的声明为 public 和 protected 的非 final 方法。
- 如果不能继承一个方法，则不能重写这个方法。

例

每种动物都有名字和年龄属性，但是喜欢吃的食物是不同的，比如狗喜欢吃骨头、猫喜欢吃鱼等，因此每种动物的介绍方式是不一样的。

下面编写 Java 程序，在父类 Animal 中定义 getInfo() 方法，并在子类 Cat 中重写该方法，实现猫的介绍方式。父类 Animal 的代码如下：

public class Animal {
    public String name; // 名字
    public int age; // 年龄
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getInfo() {
        return "我叫" + name + "，今年" + age + "岁了。";
    }
}

子类 Cat 的代码如下：

public class Cat extends Animal {
    private String hobby;
    public Cat(String name, int age, String hobby) {
        super(name, age);
        this.hobby = hobby;
    }
    public String getInfo() {
        return "喵！大家好！我叫" + this.name + "，我今年" + this.age + "岁了，我爱吃" + hobby + "。";
    }
    public static void main(String[] args) {
        Animal animal = new Cat("小白", 2, "鱼");
        System.out.println(animal.getInfo());
    }
}
/*
喵！大家好！我叫小白，我今年2岁了，我爱吃鱼。
*/

在 Animal 类中定义了一个返回值类型为 String、名称为 getInfo() 的方法，而 Cat 类继承自该类，因此 Cat 类同样含有与 Animal 类中相同的 getInfo() 方法。但是我们在 Cat 类中又重新定义了一个 getInfo() 方法，即重写了父类中的 getInfo() 方法。

多态详解

定义：多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。

对面向对象来说，多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的方法。通过编译之后会变成两个不同的方法，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是大家通常所说的多态性。

java实现多态有 3 个必要条件：继承、重写和向上转型。只有满足这 3 个条件，开发人员才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而执行不同的行为。

继承：在多态中必须存在有继承关系的子类和父类。
重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才既能可以调用父类的方法，又能调用子类的方法。

通过一个例子来演示重写如何实现多态性。例子使用了类的继承和运行时多态机制，具体步骤如下。

1）创建 Figure 类，在该类中首先定义存储二维对象的尺寸，然后定义有两个参数的构造方法，最后添加 area() 方法，该方法计算对象的面积。代码如下：

public class Figure {
    double dim1;
    double dim2;
    Figure(double d1, double d2) {
        // 有参的构造方法
        this.dim1 = d1;
        this.dim2 = d2;
    }
    double area() {
        // 用于计算对象的面积
        System.out.println("父类中计算对象面积的方法，没有实际意义，需要在子类中重写。");
        return 0;
    }
}

创建继承自 Figure 类的 Rectangle 子类，该类调用父类的构造方法，并且重写父类中的 area() 方法。代码如下：

public class Rectangle extends Figure {
    Rectangle(double d1, double d2) {
        super(d1, d2);
    } 
    double area() {//方法重写
        System.out.println("长方形的面积：");
        return super.dim1 * super.dim2;
    }
}

创建继承自 Figure 类的 Triangle 子类，该类与 Rectangle 相似。代码如下：

public class Triangle extends Figure {
    Triangle(double d1, double d2) {
        super(d1, d2);
    }
    double area() {//方法重写
        System.out.println("三角形的面积：");
        return super.dim1 * super.dim2 / 2;
    }
}

创建 Test 测试类，在该类的 main() 方法中首先声明 Figure 类的变量 figure，然后分别为 figure 变量指定不同的对象，并调用这些对象的 area() 方法。代码如下：

public class Test {
    public static void main(String[] args) {
        Figure figure; // 声明Figure类的变量
        figure = new Rectangle(9, 9);
        System.out.println(figure.area());
        System.out.println("===============================");
        figure = new Triangle(6, 8);
        System.out.println(figure.area());
        System.out.println("===============================");
        figure = new Figure(10, 10);
        System.out.println(figure.area());
    }
}
/*
长方形的面积：
81.0
===============================
三角形的面积：
24.0
===============================
父类中计算对象面积的方法，没有实际意义，需要在子类中重写。
0.0
*/

动态编译：类型，可扩展性
即同一个方法可以通过根据发送对象的不同而采取多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型很多(父类，有关系的类)
多态存在的条件
- 有继承关系
- 子类重写父类的方法
- 父类引用指向子类对象
注意：多态是方法的多态，属性没有多态

<部分代码来源于网络>

Mr. pangfu

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
封装继承多态

初识面向对象面向过程思想步骤清晰简单，第一步做什么，第二步做什么面对过程适合处理一些较为简单的问题面向对象思想物以类聚，分类的思维磨市，思考问题首先会解决问题需要那些分类，再对分类进行单独思考，最后才对某个分类下的细节进行面向过程的思索面向对象适合处理复杂的问题，适合处理需要多人协作的问题对于复杂描述的十五，为了从宏观上把握，从整体上合理分析，我们需要使用面向都对象的思路来分析整个系统。但是具体到围观操作，仍然需要面向过程的思路去处理面向对象编程：Object-Oriented
复制链接

扫一扫