Java6、7章复习 5.4

目录

 面向对象概述

6.12类

6.1.3面向对象程序设计的特点 

成员方法在Java语言中，成员方法对应于类对象的行为，它主要用来定义类可执行的操作，它是包含一系列语句的代码块，本节将对成员方法进行详细讲解。1.成员方法的定义

 2. 成员方法的参数 

包-package3.1.1包包允许将类组合成较小的单元（类似文件夹），它基本上隐藏了类，并避免了名称上的冲突。包允许在更广泛的范围内保护类、数据和方法。你可以在包内定义类，而在包外的代码不能访问该类。这使你的类相互之间有隐私，但不被其他世界所知。

4.2面对对象特性之多态 

多态

ArrayLIst列表类的使用 ArrayList 类ArrayList 类实现了可变数组的大小，存储在内的数据称为元素。它还提供了快速基于索引访问元素的方式，对尾部成员的增加和删除支持较好。使用 ArrayList 创建的集合，允许对集合中的元素进行快速的随机访问，不过，向 ArrayList 中插入与删除元素的速度相对较慢。

---

 面向对象概述

人们开始将另一种开发思想引入程序中即面向对象的开发思想。它将所有预处理的问题抽象为对象，同时了解这些时能些相应的属性以及行为，以解决这些对象面临的一些实际问题，这样就在程序开发中引入了象设计的概念，面向对象设计实质上就是对现实世界的对象进行建模操作。

对象具有属性和行为。
对象具有变化的状态。
对象具有唯一性。
对象都是某个类别的实例。
 一切皆为对象，真实世界中的所有事物都可以视为对象。

6.12类

如果需要对同一类事物统称，就不得不说明类这个概念。
类就是同一类事物的统称，如果将现实世界中的一个事物抽象成对象，类就是这类对象的统称，如鸟类、家禽类、人类等。类是构造对象时所依赖的规范，如一只鸟具有一对翅膀，它可以用这对翅膀飞行，而基本上所有的鸟都具有翅膀这个特性和飞行的技能，这样具有相同特性和行为的一类事物就称为类，类的思想就是这样产生的。对象就是符合某个类的定义所产生出来的实例。更为恰当的描述是，类是世间事物的抽象称呼，而对象则是这个事物相对应的实体。如果面临实际问题，通常需要实例化类对象来解决。

6.1.3面向对象程序设计的特点 

面向对象程序设计具有以下特点：
封装性。
继承性。
多态性。

1. 封装

封装是面向对象编程的核心思想。将对象的属性和行为封装起来，其载体就是类户隐藏其实现细节，这就是封装的思想。例如，用户使用计算机时，只需要使用手指能地以实现一些功能，无须知道计算机内部是如何工作的，即使可能知道计算机的工作原理， 个计算机时也并不完全依赖于计算机工作原理这些细节。 
采用封装的思想保证了类内部数据结构的完整性，应用该类的用户不能轻易地直接结构，只能执行类允许公开的数据。这样就避免了外部操作对内部数据的影响，提高了程序的可维护性

2.继承
2.继承性主要利用特定对象之间的共有属性。例如，平行四边形是四边形，正方形、矩形也是四边形，平行四边形与四边形具有共同特性，就是拥有4条边，可以将平行四边形类看作四边形的延伸，平行四边形复用了四边形的属性和行为，同时添加了平行四边形独有的属性和行为，如平行四边形的对边平行且相等。这里可以将平行四边形类看作是从四边形类中继承的。在Java语言中将类似于平行四边形的类称为子类，将类似于四边形的类称为父类或超类。值得注意的是，可以说平行四边形是特殊的四边形，但不能说四边形是平行四边形，也就是说子类的实例都是父类的实例，但不能说父类的实例是子类的实例。

 类的特征与行为

类和对象的关系
在面向对象中，类和对象是最基本、最重要的组成单元。类实际上是表示一个客观世界某类群体的一些基本特征抽象。对象就是表示一个个具体的东西。所以说类是对象的抽象，对象是类的具体。

让我们来看看人类所具有的一些特征，这些特征包括属性（一些参数、数值）以及方法（一些行为，他能干什么）。

每个人都有身高、体重、年龄、血型等属性，人会劳动、会直立行走、会用自己的头脑去创造工具等方法。人之所以能区别于其他类型的动物，是因为每个人都具有“人”这个群体的属性与方法。

 面向对象的编程

成员方法
在Java语言中，成员方法对应于类对象的行为，它主要用来定义类可执行的操作，它是包含一系列语句的代码块，本节将对成员方法进行详细讲解。
1.成员方法的定义

定义成员方法的语法格式如下：

[权限修饰符][这回值尖型)万法名([效突型李效名］)[throws 异常类型] (
…1/方法体
return 返回值；

其中，“权限修饰符”可以是private、public、protected中的任一个，也可以不写，主要用来控制方法的访问权限，关于权限修饰符将在下一章中详细讲解；“返回值类型”指定方法返回数据的类型，可以是任何类型，如果方法不需要返回值，则使用void关键字；一个成员方法既可以有参数，山可以县其本数据类型的变量。

 2. 成员方法的参数 

调用方法时可以给该方法传递一个或多个值，传给方法的值叫做实参，在方法内部。
的变量叫做形参，形参的声明语法与变量的声明语法一样。形参只在方法内部有效。langs参数主要有3种，分别为值参数、引用参数和不定长参数，下面分别进行讲解。
(1)值参数
值参数表明实参与形参之间按值传递，当使用值参数的方法被调用时，编译器为形参的单元，然后将对应的实参的值复制到形参中，由于是值类型的传递方式，所以，在方法中的的形参的修改并不会影响实参

3.多态
上面介绍了继承，了解了父类和子类，其实将父类对象应用于子类的特征就是多态，多态的实现并不依赖具体类，而是依赖于抽象类和接口。
下面以图形类来说明多态。
图形类作为所有图形的父类，具有绘制图形的能力，这个方法可称为“绘制图形”，但如果要执行这个“绘制图形”的命令，没有人知道应该画什么样的图形，并且如果要在图形类中抽象出一个图形对象，没有人能说清这个图形究竟是什么图形，所以使用“抽象”这个词来描述图形类比较恰当。在Java语言中称这样的类为抽象类，抽象类不能实例化对象。在多态的机制中，父类通常会被定义为抽象类，在抽象类中给出一个方法的标准，而不给出实现的具体流程。实质上这个方法也是抽象的，如图形类中的“绘制图形”方法只提供一个可以绘制图形的标准，并没有提供具体绘制图形的流程，

因为没有人知道究竟需要绘制什么形状的图形。
每个图形都拥有绘制自己的能力，这个能力可看作是该类具有的行为，如果将子类的对象统一看作是父类的实例对象，这样当绘制图形时，简单地调用父类也就是图形类绘制图形的方法即可绘制任何图形，这就是多态最基本的思想。图6.7的图形类中绘制图形的方法很好地体现了面向对象的多态思想

 创建类的实例对象

 

 

 

 成员变量的定义

 

public class Method {
    public String isOddNumber(int num) {
        if (num % 2 == 0) {//如果num输入除于2为0，那么输出偶数
            return "偶数";
        } else {//如果num输入除于2不为0，那么输出奇数
            return "奇数";
        }
    }
        public static void main(String[] args){
        int a = 10;
        if (a % 2 == 0) {//如果a输入除于2为0，那么输出偶数
            System.out.println(a + "是偶数");
        } else {//如果b输入除于2不为0，那么输出奇数
            System.out.println(a + "是奇数");
        }
        int b = 5;
        if (b % 2 == 0) {//如果b输入除于2为0，那么输出偶数
            System.out.println(b + "是偶数");
        } else {//如果b输入除于2不为0，那么输出奇数
            System.out.println(b + "是奇数");
        }
    }}

包-package
3.1.1包
包允许将类组合成较小的单元（类似文件夹），它基本上隐藏了类，并避免了名称上的冲突。包允许在更广泛的范围内保护类、数据和方法。你可以在包内定义类，而在包外的代码不能访问该类。这使你的类相互之间有隐私，但不被其他世界所知。

包的 3 个作用如下：

区分相同名称的类。
能够较好地管理大量的类。
控制访问范围。

Java 中使用 package 语句定义包，package 语句应该放在源文件的第一行，在每个源文件中只能有一个包定义语句，并且 package 语句适用于所有类型（类、接口、枚举和注释）的文件。定义包语法格式如下：
package 包名;

Java 包的命名规则如下：
包名全部由小写字母（多个单词也全部小写）。
如果包名包含多个层次，每个层次用“.”分割。
包名一般由倒置的域名开头，比如 com.baidu，不要有 www

1. 自定义包不能 java 开头。
2. 

 

包的命名规范

example.Test test = new example.Test();

 

3.2访问修饰符 

在 Java 语言中提供了多个作用域修饰符，其中常用的有 public、private、protected、final、abstract、static、transient 和 volatile，这些修饰符有类修饰符、变量修饰符和方法修饰符。本文将详细介绍访问控制修饰符。

在实际生活中，如果要获取某件物品，与其直接穿过堡垒的墙壁，从而导致墙壁毁灭和破坏，不如通过门口的警卫请求进入堡垒的许可。一般而言，这对对象同样适用：没有对象的许可（即对象的属性是私有的），不能直接访问该对象的私有属性。

信息隐藏是 OOP 最重要的功能之一，也是使用访问修饰符的原因。在编写程序时，有些核心数据往往不希望被用户调用，需要控制这些数据的访问。

对类成员访问的限制是面向对象程序设计的一个基础，这有利于防止对象的误用。只允许通过一系列定义完善的方法来访问私有数据，就可以（通过执行范围检查）防止数据赋予不正当的值。例如，类以外的代码不可能直接向一个私有成员赋值。同时，还可以精确地控制如何以及何时使用对象中的数据。

当正确实现对类成员的方法控制后，类就可以创建一个可用的“黑箱”，其内部动作不会被打开而任意篡改。

通过使用访问控制修饰符来限制对对象私有属性的访问，可以获得 3 个重要的好处。

防止对封装数据的未授权访问。
有助于保证数据完整性。
当类的私有实现细节必须改变时，可以限制发生在整个应用程序中的“连锁反应”。

访问控制符是一组限定类、属性或方法是否可以被程序里的其他部分访问和调用的修饰符。类的访问控制符只能是空或者 public，方法和属性的访问控制符有 4 个，分别是 public、 private、protected 和 friendly，其中 friendly 是一种没有定义专门的访问控制符的默认情况。访问控制修饰符的权限如表 1 所示。

 

3.3面对对象特性之封装
封装将类的某些信息隐藏在类内部，不允许外部程序直接访问，只能通过该类提供的方法来实现对隐藏信息的操作和访问。例如：一台计算机内部极其复杂，有主板、CPU、硬盘和内存， 而一般用户不需要了解它的内部细节，不需要知道主板的型号、CPU 主频、硬盘和内存的大小，于是计算机制造商将用机箱把计算机封装起来，对外提供了一些接口，如鼠标、键盘和显示器等，这样当用户使用计算机就非常方便。

封装的特点：

只能通过规定的方法访问数据。
隐藏类的实例细节，方便修改和实现。

实现封装的具体步骤如下：

修改属性的可见性来限制对属性的访问，一般设为 private。
为每个属性创建一对赋值（setter）方法和取值（getter）方法，一般设为 public，用于属性的读写。
在赋值和取值方法中，加入属性控制语句（对属性值的合法性进行判断）。

 

public class Employee {
    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;
    }
}

public class EmployeeTest {
    public static void main(String[] args) {
        Employee people = new Employee();
        people.setName("王丽丽");
        people.setAge(35);
        people.setPhone("13653835964");
        people.setAddress("河北省石家庄市");
        System.out.println("姓名：" + people.getName());
        System.out.println("年龄：" + people.getAge());
        System.out.println("电话：" + people.getPhone());
        System.out.println("家庭住址：" + people.getAddress());
    }
}

 .4对成员变量进行读写封装

public class BookTest {
    public static void main(String[] args) {
        Book book1 = new Book();
        book1.setBookName("《红与黑》");
        book1.setBookTotalNum(190);
        book1.details();
        System.out.println("************************************");
        Book book2 = new Book();
        book2.setBookName("《格林童话》");
        book2.setBookTotalNum(520);
        book2.details();
    }
}

 

面对对象特性之继承 
继承是面向对象的三大特征之一。继承和现实生活中的“继承”的相似之处是保留一些父辈的特性，从而减少代码冗余，提高程序运行效率。

Java 中的继承就是在已经存在类的基础上进行扩展，从而产生新的类。已经存在的类称为父类、基类或超类，而新产生的类称为子类或派生类。在子类中，不仅包含父类的属性和方法，还可以增加新的属性和方法。
 

1. 修饰符 class class_name extends extend_class {

2. // 类的主体

3. }

 

 

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);
    }
}

 

 

4.2面对对象特性之多态 

 

多态

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

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

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

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

 

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

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());
    }
}

 

实现多态的关键是接口

 抽象类是从多个类中抽象出来的模板，如果将这种抽象进行的更彻底，则可以提炼出一种更加特殊的“抽象类”——接口（Interface）。接口是 Java 中最重要的概念之一，它可以被理解为一种特殊的类，不同的是接口的成员没有执行体，是由全局常量和公共的抽象方法所组成。

1. [public] interface interface_name [extends interface1_name[, interface2_name,…]] {

2. // 接口体，其中可以包含定义常量和声明方法

3. [public] [static] [final] type constant_name = value; // 定义常量

4. [public] [abstract] returnType method_name(parameter_list); // 声明方法

5. }

public 表示接口的修饰符，当没有修饰符时，则使用默认的修饰符，此时该接口的访问权限仅局限于所属的包；
interface_name 表示接口的名称。接口名应与类名采用相同的命名规则，即如果仅从语法角度来看，接口名只要是合法的标识符即可。如果要遵守 Java 可读性规范，则接口名应由多个有意义的单词连缀而成，每个单词首字母大写，单词与单词之间无需任何分隔符。
extends 表示接口的继承关系；
interface1_name 表示要继承的接口名称；
constant_name 表示变量名称，一般是 static 和 final 型的；
returnType 表示方法的返回值类型；
parameter_list 表示参数列表，在接口中的方法是没有方法体的。

4.2.3实现接口
接口的主要用途就是被实现类实现，一个类可以实现一个或多个接口，继承使用 extends 关键字，实现则使用 implements 关键字。因为一个类可以实现多个接口，这也是 Java 为单继承灵活性不足所作的补充。类实现接口的语法格式如下：

<public> class <class_name> [extends superclass_name] [implements interface1_name[, interface2_name…]] {
    // 主体
}
对以上语法的说明如下：

public：类的修饰符；
superclass_name：需要继承的父类名称；
interface1_name：要实现的接口名称。

实现接口需要注意以下几点：

实现接口与继承父类相似，一样可以获得所实现接口里定义的常量和方法。如果一个类需要实现多个接口，则多个接口之间以逗号分隔。
一个类可以继承一个父类，并同时实现多个接口，implements 部分必须放在 extends 部分之后。
一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也就是重写这些抽象方法）；否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。

public class MathClass implements IMath {
    private int num1;    // 第 1 个操作数
    private int num2;    // 第 2 个操作数
    public MathClass(int num1,int num2) {
        // 构造方法
        this.num1 = num1;
        this.num2 = num2;
    }
    // 实现接口中的求和方法
    public int sum() {
        return num1 + num2;
    }
    // 实现接口中的获取较大数的方法
    public int maxNum(int a,int b) {
        if(a >= b) {
            return a;
        } else {
            return b;
        }
    }
}

public class NumTest {
    public static void main(String[] args) {
        // 创建实现类的对象
        MathClass calc = new MathClass(100, 300);
        System.out.println("100 和 300 相加结果是：" + calc.sum());
        System.out.println("100 比较 300，哪个大：" + calc.maxNum(100, 300));
    }
}

 

ArrayLIst列表类的使用 
ArrayList 类
ArrayList 类实现了可变数组的大小，存储在内的数据称为元素。它还提供了快速基于索引访问元素的方式，对尾部成员的增加和删除支持较好。使用 ArrayList 创建的集合，允许对集合中的元素进行快速的随机访问，不过，向 ArrayList 中插入与删除元素的速度相对较慢。

ArrayList 类的常用构造方法有如下两种重载形式：

ArrayList()：构造一个初始容量为 10 的空列表。
ArrayList(Collection<?extends E>c)：构造一个包含指定 Collection 元素的列表，这些元素是按照该 Collection 的迭代器返回它们的顺序排列的。
注意：当调用 List 的 set(int index, Object element) 方法来改变 List 集合指定索引处的元素时，指定的索引必须是 List 集合的有效索引。例如集合长度为 4，就不能指定替换索引为 4 处的元素，也就是说这个方法不会改变 List 集合的长度。 

import java.util.ArrayList;
import java.util.List;
 
public class Method {
 
        public static void main(String[] args) {
            List bookList = new ArrayList<>();
            bookList.add("水浒传");
            bookList.add("西游记");
            bookList.add("三国演义");
            bookList.add("三国志");
            bookList.add(0,"镜花缘");
            System.out.println(bookList);
        }
}

 

public class Test {
    public static void main(String[] args) {
        Product pd1 = new Product(4, "木糖醇", 10);
        Product pd2 = new Product(5, "洗发水", 12);
        Product pd3 = new Product(3, "热水壶", 49);
        List list = new ArrayList(); // 创建集合
        list.add(pd1);
        list.add(pd2);
        list.add(pd3);
        System.out.println("*************** 商品信息 ***************");
        for (int i = 0; i < list.size(); i++) {
            // 循环遍历集合，输出集合元素
            Product product = (Product) list.get(i);
            System.out.println(product);
        }
    }
}

 

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
	public static void main(String[] args) {
	    List list = new ArrayList();
	    list.add("One");
	    list.add("Two");
	    list.add("Three");
	    list.add("Four");
	    list.add("Five");
	    list.add("Six");
	    list.add("Seven");
	    System.out.println("list 集合中的元素数量：" + list.size());
	    System.out.println("list 集合中的元素如下：");
	    Iterator it = list.iterator();
	    while (it.hasNext()) {
	        System.out.print(it.next() + "、");
	    }
	    List sublist = new ArrayList();
	    sublist = list.subList(2, 5); // 从list集合中截取索引2~5的元素，保存到sublist集合中
	    System.out.println("\nsublist 集合中元素数量：" + sublist.size());
	    System.out.println("sublist 集合中的元素如下：");
	    it = sublist.iterator();
	    while (it.hasNext()) {
	        System.out.print(it.next() + "、");
	    }
	}}