Java6-7章总结复习
目录
2.1介绍类与对象
2.1.1世间万物皆对象
2.1.2类是对象的模板
2.1.3类的特征与行为
2.1.4类和对象的关系
编辑2.1.5面向对象的编程
2.1.6java创建类的用法
编辑 2.1.7java创建类的语法
2.1.8创建类的实例对象
2.1.9对象的命名规则
2.2IDEA创建类与对象
2.3成员变量
2.3.1成员变量
2.3.2成员变量的定义 2.3.3成员变量的使用编辑
2.4方法-method的作用
2.4.1什么是方法
3.1包-package
3.1.1包
3.1.2包的命名规范
3.2访问修饰符
3.3面对对象特性之封装
3.4对成员变量进行读写封装
4.1面对对象特性之继承
4.2面对对象特性之多态
4.2.1多态
4.2.2实现多态的关键是接口
4.2.3实现接口
4.4ArrayLIst列表类的使用
2.1介绍类与对象
2.1.1世间万物皆对象
Java 是面向对象的编程语言，对象就是面向对象程序设计的核心。所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。对象有以下特点：
对象具有属性和行为。
对象具有变化的状态。
对象具有唯一性。
对象都是某个类别的实例。
一切皆为对象，真实世界中的所有事物都可以视为对象。
2.1.2类是对象的模板
例如，在真实世界的学校里，会有学生和老师等实体，学生有学号、姓名、所在班级等属性（数据），学生还有学习、提问、吃饭和走路等操作。学生只是抽象的描述，这个抽象的描述称为“类”。在学校里活动的是学生个体，即张同学、李同学等，这些具体的个体称为“对象”，“对象”也称为“实例”。
2.1.3类的特征与行为
2.1.4类和对象的关系
在面向对象中，类和对象是最基本、最重要的组成单元。类实际上是表示一个客观世界某类群体的一些基本特征抽象。对象就是表示一个个具体的东西。所以说类是对象的抽象，对象是类的具体。
让我们来看看人类所具有的一些特征，这些特征包括属性（一些参数、数值）以及方法（一些行为，他能干什么）。
每个人都有身高、体重、年龄、血型等属性，人会劳动、会直立行走、会用自己的头脑去创造工具等方法。人之所以能区别于其他类型的动物，是因为每个人都具有“人”这个群体的属性与方法。
2.1.5面向对象的编程
2.1.6java创建类的用法
public class Student {
// 学生类
}
2.1.7java创建类的语法
2.1.8创建类的实例对象
new关键字是创建实例对象最重要的标志（要点）
2.1.9对象的命名规则
public static void main(String[] args) {
Student zhang = new Student(); // 创建第一个实例
zhang.Name = "张子同";
String isMan = zhang.isSex() ? "女" : "男";
System.out.println("姓名：" + zhang.Name + "性别：" + isMan + "年龄：" + zhang.Age);
Student li = new Student(); // 创建第二个实例
li.Name = "李子文";
li.Sex = true;
li.Age = 15;
String isWoman = li.isSex() ? "女" : "男";
System.out.println("姓名：" + li.Name + "性别：" + isWoman + "年龄：" + li.Age);
}
2.2IDEA创建类与对象
使用IDEA
2.3成员变量
2.3.1成员变量
2.3.2成员变量的定义
2.3.3成员变量的使用
2.4方法-method的作用
2.4.1什么是方法
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 + "是奇数");
}
}}3.1包-package
3.1.1包
包允许将类组合成较小的单元（类似文件夹），它基本上隐藏了类，并避免了名称上的冲突。包允许在更广泛的范围内保护类、数据和方法。你可以在包内定义类，而在包外的代码不能访问该类。这使你的类相互之间有隐私，但不被其他世界所知。
包的 3 个作用如下：
区分相同名称的类。
能够较好地管理大量的类。
控制访问范围。
Java 中使用 package 语句定义包，package 语句应该放在源文件的第一行，在每个源文件中只能有一个包定义语句，并且 package 语句适用于所有类型（类、接口、枚举和注释）的文件。定义包语法格式如下：
package 包名;
Java 包的命名规则如下：
包名全部由小写字母（多个单词也全部小写）。
如果包名包含多个层次，每个层次用“.”分割。
包名一般由倒置的域名开头，比如 com.baidu，不要有 www
自定义包不能 java 开头。
3.1.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());
}
}
3.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();
}
}
4.1面对对象特性之继承
继承是面向对象的三大特征之一。继承和现实生活中的“继承”的相似之处是保留一些父辈的特性，从而减少代码冗余，提高程序运行效率。
Java 中的继承就是在已经存在类的基础上进行扩展，从而产生新的类。已经存在的类称为父类、基类或超类，而新产生的类称为子类或派生类。在子类中，不仅包含父类的属性和方法，还可以增加新的属性和方法。
修饰符 class class_name extends extend_class {
// 类的主体
}
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面对对象特性之多态
4.2.1多态
多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。
对面向对象来说，多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的方法。通过编译之后会变成两个不同的方法，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是大家通常所说的多态性。
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());
}
}
4.2.2实现多态的关键是接口
抽象类是从多个类中抽象出来的模板，如果将这种抽象进行的更彻底，则可以提炼出一种更加特殊的“抽象类”——接口（Interface）。接口是 Java 中最重要的概念之一，它可以被理解为一种特殊的类，不同的是接口的成员没有执行体，是由全局常量和公共的抽象方法所组成。
[public] interface interface_name [extends interface1_name[, interface2_name,…]] {
// 接口体，其中可以包含定义常量和声明方法
[public] [static] [final] type constant_name = value; // 定义常量
[public] [abstract] returnType method_name(parameter_list); // 声明方法
}
public 表示接口的修饰符，当没有修饰符时，则使用默认的修饰符，此时该接口的访问权限仅局限于所属的包；
interface_name 表示接口的名称。接口名应与类名采用相同的命名规则，即如果仅从语法角度来看，接口名只要是合法的标识符即可。如果要遵守 Java 可读性规范，则接口名应由多个有意义的单词连缀而成，每个单词首字母大写，单词与单词之间无需任何分隔符。
extends 表示接口的继承关系；
interface1_name 表示要继承的接口名称；
constant_name 表示变量名称，一般是 static 和 final 型的；
returnType 表示方法的返回值类型；
parameter_list 表示参数列表，在接口中的方法是没有方法体的。
4.2.3实现接口
接口的主要用途就是被实现类实现，一个类可以实现一个或多个接口，继承使用 extends 关键字，实现则使用 implements 关键字。因为一个类可以实现多个接口，这也是 Java 为单继承灵活性不足所作的补充。类实现接口的语法格式如下：
class [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));
}
}
4.4ArrayLIst列表类的使用
- ArrayList 类
- ArrayList 类实现了可变数组的大小，存储在内的数据称为元素。它还提供了快速基于索引访问元素的方式，对尾部成员的增加和删除支持较好。使用 ArrayList 创建的集合，允许对集合中的元素进行快速的随机访问，不过，向 ArrayList 中插入与删除元素的速度相对较慢。
- ArrayList 类的常用构造方法有如下两种重载形式：
- ArrayList()：构造一个初始容量为 10 的空列表。
- ArrayList(Collectionc)：构造一个包含指定 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);
}
}
}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() + "、");
}
}