目录
1. 类和对象
面向对象和面向过程的思想对比 :
面向过程 ：是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的
面向对象 ：是一种以对象为中心的编程思想，通过指挥对象实现具体的功能
1.1 类和对象的关系
客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。
-
类
-
类的理解
-
类是对现实生活中一类具有共同属性和行为的事物的抽象
-
类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
-
简单理解：类就是对现实事物的一种描述
-
-
类的组成
-
属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
-
行为：指事物能执行的操作，例如：手机事物（打电话，发短信）
-
-
-
类和对象的关系
-
类：类是对现实生活中一类具有共同属性和行为的事物的抽象
-
对象：是能够看得到摸的着的真实存在的实体
-
简单理解：类是对事物的一种描述，对象则为具体存在的事物
-
1.2 类的定义【应用】
类的组成是由属性和行为两部分组成
-
属性：在类中通过成员变量来体现（类中方法外的变量）
-
行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）
类的定义步骤：
① 定义类
② 编写类的成员变量
③ 编写类的成员方法
public class Student {
// 属性 : 姓名, 年龄
// 成员变量: 跟之前定义变量的格式一样, 只不过位置发生了改变, 类中方法外
String name;
int age;
// 行为 : 学习
// 成员方法: 跟之前定义方法的格式一样, 只不过去掉了static关键字.
public void study(){
System.out.println("学习");
}
}
1.3 对象的创建和使用
-
创建对象的格式：
-
类名 对象名 = new 类名();
-
-
调用成员的格式：
-
对象名.成员变量
-
对象名.成员方法();
-
-
示例代码 :
package com.wedu.object1;
public class TestStudent {
/*
创建对象的格式:
类名 对象名 = new 类名();
调用成员变量的格式:
对象名.变量名
调用成员方法的格式:
对象名.方法名();
*/
public static void main(String[] args) {
// 类名 对象名 = new 类名();
Student stu = new Student();
// 对象名.变量名
// 默认初始化值
System.out.println(stu.name); // null
System.out.println(stu.age); // 0
stu.name = "张三";
stu.age = 23;
System.out.println(stu.name); // 张三
System.out.println(stu.age); // 23
// 对象名.方法名();
stu.study();
// com.wedu.object1.Student@b4c966a
// 全类名(包名 + 类名)
System.out.println(stu);
}
}1.4 案例-手机类的创建和使用
需求 ：首先定义一个手机类，然后定义一个手机测试类，在手机测试类中通过对象完成成员变量和成员方法的使用
分析 ：
-
成员变量：品牌, 价格
-
成员方法：打电话, 发短信
-
示例代码：
package com.wedu.test1;
public class Phone {
// 品牌, 价格
String brand;
int price;
// 打电话, 发短信
public void call(String name){
System.out.println("给"+name+"打电话");
}
public void sendMessage(){
System.out.println("群发短信");
}
}
package com.wedu.test1;
public class TestPhone {
public static void main(String[] args) {
// 1. 创建对象
Phone p = new Phone();
// 2. 给成员变量进行赋值
p.brand = "大米";
p.price = 2999;
// 3. 打印赋值后的成员变量
System.out.println(p.brand + "..." + p.price);
// 4. 调用成员方法
p.call("阿强");
p.sendMessage();
}
}2. 对象内存图
2.1 单个对象内存图【理解】
2.2 多个对象内存图【理解】
-
总结：
多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份
2.3 多个对象指向相同内存图【理解】
-
-
总结 :
当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的）
只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象进行数据获取，都是修改后的数据。
3. 成员变量和局部变量
3.1 成员变量和局部变量的区别
-
类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
-
内存中位置不同：成员变量（堆内存）局部变量（栈内存）
-
生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）
-
初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）
4. 封装
4.1 private关键字
概述 : private是一个修饰符，可以用来修饰成员（成员变量，成员方法）
特点 : 被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用， 提供相应的操作
提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
示例代码：
/*
学生类
*/
class Student {
//成员变量
String name;
private int age;
//提供get/set方法
public void setAge(int a) {
if(a<0 || a>120) {
System.out.println("你给的年龄有误");
} else {
age = a;
}
}
public int getAge() {
return age;
}
//成员方法
public void show() {
System.out.println(name + "," + age);
}
}
/*
学生测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
//给成员变量赋值
s.name = "林青霞";
s.setAge(30);
//调用show方法
s.show();
}
}4.2 private关键字的使用
-
需求：
-
定义标准的学生类，要求name和age使用private修饰
-
并提供set和get方法以及便于显示数据的show方法
-
测试类中创建对象并使用，最终控制台输出 林青霞，30
-
-
示例代码：
/* 学生类 */ class Student { //成员变量 private String name; private int age; //get/set方法 public void setName(String n) { name = n; } public String getName() { return name; } public void setAge(int a) { age = a; } public int getAge() { return age; } public void show() { System.out.println(name + "," + age); } } /* 学生测试类 */ public class StudentDemo { public static void main(String[] args) { //创建对象 Student s = new Student(); //使用set方法给成员变量赋值 s.setName("林青霞"); s.setAge(30); s.show(); //使用get方法获取成员变量的值 System.out.println(s.getName() + "---" + s.getAge()); System.out.println(s.getName() + "," + s.getAge()); } }
4.3 this关键字【应用】
概述 : this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
-
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
-
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量
代码实现 :
public class Student {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void show() {
System.out.println(name + "," + age);
}
}4.4 this内存原理【理解】
-
注意 : this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象
-
图解 ：
-
-
4.5 封装思想
-
封装概述 是面向对象三大特征之一（封装，继承，多态） 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
-
封装原则 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法
-
封装好处 通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性
5. 构造方法
5.1 构造方法的格式和执行时机
-
格式注意 :
-
方法名与类名相同，大小写也要一致
-
没有返回值类型，连void都没有
-
没有具体的返回值（不能由retrun带回结果数据）
-
-
执行时机 ：
-
创建对象的时候调用，每创建一次对象，就会执行一次构造方法
-
不能手动调用构造方法
-
-
示例代码：
class Student {
private String name;
private int age;
//构造方法
public Student() {
System.out.println("无参构造方法");
}
public void show() {
System.out.println(name + "," + age);
}
}
/*
测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
s.show();
}
}5.2 构造方法的作用
-
用于给对象的数据（属性）进行初始化
package com.wedu.constructor;
public class Student {
/*
格式:
1. 方法名需要跟类名相同, 大小写也要一致
2. 没有返回值类型, 连void都没有
3. 没有具体的返回值(不能由return带回具体的结果)
*/
private String name;
private int age;
// 1. 如果一个类中没有编写任何构造方法, 系统将会提供一个默认的无参数构造方法
public Student(){}
// 2. 如果手动编写了构造方法, 系统就不会再提供默认的无参数构造方法了
public Student(String name, int age){
this.name = name;
this.age = age;
System.out.println("我是Student类的构造方法");
}
public void show(){
System.out.println(name + "..." + age);
}
}
package com.wedu.constructor;
public class TestStudent {
public static void main(String[] args) {
Student stu1 = new Student("张三",23);
stu1.show();
Student stu2 = new Student();
}
}5.3 构造方法的注意事项
构造方法的创建 :
如果没有定义构造方法，系统将给出一个默认的无参数构造方法
如果定义了构造方法，系统将不再提供默认的构造方法
构造方法的创建 :
如果没有定义构造方法，系统将给出一个默认的无参数构造方法如果定义了构造方法，系统将不再提供默认的构造方法
推荐的使用方式 :
无论是否使用，都手动书写无参数构造方法，和带参数构造方法
5.4 标准类的代码编写和使用
代码 :
package com.wedu.test3;
/*
JavaBean类: 封装数据
*/
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
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 void show(){
System.out.println(name + "..." + age);
}
}
package com.wedu.test3;
public class TestStudent {
public static void main(String[] args) {
// 1. 无参数构造方法创建对象, 通过setXxx方法给成员变量进行赋值
Student stu1 = new Student();
stu1.setName("张三");
stu1.setAge(23);
stu1.show();
// 2. 通过带参数构造方法, 直接给属性进行赋值
Student stu2 = new Student("李四",24);
stu2.show();
}
}6. 继承
6.1 继承的实现（掌握）
-
继承的概念
-
继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法
-
-
实现继承的格式
-
继承通过extends实现
-
格式：class 子类 extends 父类 { }
-
举例：class Dog extends Animal { }
-
-
-
继承带来的好处
-
继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。
-
-
示例代码
public class Fu { public void show() { System.out.println("show方法被调用"); } } public class Zi extends Fu { public void method() { System.out.println("method方法被调用"); } } public class Demo { public static void main(String[] args) { //创建对象，调用方法 Fu f = new Fu(); f.show(); Zi z = new Zi(); z.method(); z.show(); } }
6.2 继承的好处和弊端（理解）
-
继承好处
-
提高了代码的复用性(多个类相同的成员可以放到同一个类中)
-
提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
-
-
继承弊端
-
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
-
-
继承的应用场景：
-
使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承
-
is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类
-
-
6.3. Java中继承的特点（掌握）
-
Java中继承的特点
-
Java中类只支持单继承，不支持多继承
-
错误范例：class A extends B, C { }
-
-
Java中类支持多层继承
-
-
多层继承示例代码：
public class Granddad { public void drink() { System.out.println("爷爷爱喝酒"); } } public class Father extends Granddad { public void smoke() { System.out.println("爸爸爱抽烟"); } } public class Mother { public void dance() { System.out.println("妈妈爱跳舞"); } } public class Son extends Father { // 此时，Son类中就同时拥有drink方法以及smoke方法 }
7. 继承中的成员访问特点
7.1 继承中变量的访问特点（掌握）
在子类方法中访问一个变量，采用的是就近原则。
子类局部范围找
子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)
-
示例代码
class Fu { int num = 10; } class Zi { int num = 20; public void show(){ int num = 30; System.out.println(num); } } public class Demo1 { public static void main(String[] args) { Zi z = new Zi(); z.show(); // 输出show方法中的局部变量30 } } -
7.2 super（掌握）
-
this&super关键字：
-
this：代表本类对象的引用
-
super：代表父类存储空间的标识(可以理解为父类对象引用)
-
-
this和super的使用分别
-
成员变量：
-
this.成员变量 - 访问本类成员变量
-
super.成员变量 - 访问父类成员变量
-
-
成员方法：
-
this.成员方法 - 访问本类成员方法
-
super.成员方法 - 访问父类成员方法
-
-
-
构造方法：
-
this(…) - 访问本类构造方法
-
super(…) - 访问父类构造方法
-
7.3 继承中构造方法的访问特点（理解）
注意：子类中所有的构造方法默认都会访问父类中无参的构造方法
子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()
问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？
1. 通过使用super关键字去显示的调用父类的带参构造方法 2. 子类通过this去调用本类的其他构造方法,本类其他构造方法再通过super去手动调用父类的带参的构造方法 注意: this(…)super(…) 必须放在构造方法的第一行有效语句，并且二者不能共存
7.4 继承中成员方法的访问特点（掌握）
通过子类对象访问一个方法
子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)
7.5 super内存图（理解）
-
对象在堆内存中，会单独存在一块super区域，用来存放父类的数据
7.6 方法重写（掌握）
-
1、方法重写概念
-
子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
-
-
2、方法重写的应用场景
-
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
-
-
3、Override注解
-
用来检测当前的方法，是否是重写的方法，起到【校验】的作用
-
7.7 方法重写的注意事项（掌握）
-
方法重写的注意事项
私有方法不能被重写(父类私有成员子类是不能继承的)
子类方法访问权限不能更低(public > 默认 > 私有)
静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法
-
示例代码
public class Fu {
private void show() {
System.out.println("Fu中show()方法被调用");
}
void method() {
System.out.println("Fu中method()方法被调用");
}
}
public class Zi extends Fu {
/* 编译【出错】，子类不能重写父类私有的方法*/
@Override
private void show() {
System.out.println("Zi中show()方法被调用");
}
/* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
@Override
private void method() {
System.out.println("Zi中method()方法被调用");
}
/* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
@Override
public void method() {
System.out.println("Zi中method()方法被调用");
}
}7.8 权限修饰符 (理解)
7.9 文峰信息管理系统使用继承改进 (掌握)
-
需求
把学生类和老师类共性的内容向上抽取,抽取到出一个 Person 父类,让学生类和老师类继承 Person 类
-
实现步骤
-
抽取Person类
-
优化StudentController类中，inputStudentInfo方法，将setXxx赋值方式，改进为构造方法初始化
注意：直接修改这种操作方式，不符合我们开发中的一个原则
开闭原则 ( 对扩展开放对修改关闭 ) : 尽量在不更改原有代码的前提下以完成需求
解决：重新创建一个OtherStudentController类
编写新的inputStudentInfo方法
-
根据StudentController类、OtherStudentController类，向上抽取出BaseStudentController类 再让StudentController类、OtherStudentController类，继承BaseStudentController类
-
-
代码实现
Person类及学生类和老师类
public class Person { private String id; private String name; private String age; private String birthday; public Person() { } public Person(String id, String name, String age, String birthday) { this.id = id; this.name = name; this.age = age; this.birthday = birthday; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAge() { return age; } public void setAge(String age) { this.age = age; } public String getBirthday() { return birthday; } public void setBirthday(String birthday) { this.birthday = birthday; } } // Student类 public class Student extends Person { public Student() { } public Student(String id, String name, String age, String birthday) { super(id, name, age, birthday); } } // Teacher类 public class Teacher extends Person { public Teacher() { } public Teacher(String id, String name, String age, String birthday) { super(id, name, age, birthday); } }BaseStudentController类
public abstract class BaseStudentController { // 业务员对象 private StudentService studentService = new StudentService(); private Scanner sc = new Scanner(System.in); // 开启学生管理系统, 并展示学生管理系统菜单 public void start() { //Scanner sc = new Scanner(System.in); studentLoop: while (true) { System.out.println("--------欢迎来到 <学生> 管理系统--------"); System.out.println("请输入您的选择: 1.添加学生 2.删除学生 3.修改学生 4.查看学生 5.退出"); String choice = sc.next(); switch (choice) { case "1": // System.out.println("添加"); addStudent(); break; case "2": // System.out.println("删除"); deleteStudentById(); break; case "3": // System.out.println("修改"); updateStudent(); break; case "4": // System.out.println("查询"); findAllStudent(); break; case "5": System.out.println("感谢您使用学生管理系统, 再见!"); break studentLoop; default: System.out.println("您的输入有误, 请重新输入"); break; } } } // 修改学生方法 public void updateStudent() { String updateId = inputStudentId(); Student newStu = inputStudentInfo(updateId); studentService.updateStudent(updateId, newStu); System.out.println("修改成功!"); } // 删除学生方法 public void deleteStudentById() { String delId = inputStudentId(); // 3. 调用业务员中的deleteStudentById根据id, 删除学生 studentService.deleteStudentById(delId); // 4. 提示删除成功 System.out.println("删除成功!"); } // 查看学生方法 public void findAllStudent() { // 1. 调用业务员中的获取方法, 得到学生的对象数组 Student[] stus = studentService.findAllStudent(); // 2. 判断数组的内存地址, 是否为null if (stus == null) { System.out.println("查无信息, 请添加后重试"); return; } // 3. 遍历数组, 获取学生信息并打印在控制台 System.out.println("学号\t\t姓名\t年龄\t生日"); for (int i = 0; i < stus.length; i++) { Student stu = stus[i]; if (stu != null) { System.out.println(stu.getId() + "\t" + stu.getName() + "\t" + stu.getAge() + "\t\t" + stu.getBirthday()); } } } // 添加学生方法 public void addStudent() { // StudentService studentService = new StudentService(); // 1. 键盘接收学生信息 String id; while (true) { System.out.println("请输入学生id:"); id = sc.next(); boolean flag = studentService.isExists(id); if (flag) { System.out.println("学号已被占用, 请重新输入"); } else { break; } } Student stu = inputStudentInfo(id); // 3. 将学生对象,传递给StudentService(业务员)中的addStudent方法 boolean result = studentService.addStudent(stu); // 4. 根据返回的boolean类型结果, 在控制台打印成功\失败 if (result) { System.out.println("添加成功"); } else { System.out.println("添加失败"); } } // 键盘录入学生id public String inputStudentId() { String id; while (true) { System.out.println("请输入学生id:"); id = sc.next(); boolean exists = studentService.isExists(id); if (!exists) { System.out.println("您输入的id不存在, 请重新输入:"); } else { break; } } return id; } // 键盘录入学生信息 // 开闭原则: 对扩展内容开放, 对修改内容关闭 public Student inputStudentInfo(String id){ return null; } }StudentController类
public class StudentController extends BaseStudentController { private Scanner sc = new Scanner(System.in); // 键盘录入学生信息 // 开闭原则: 对扩展内容开放, 对修改内容关闭 @Override public Student inputStudentInfo(String id) { System.out.println("请输入学生姓名:"); String name = sc.next(); System.out.println("请输入学生年龄:"); String age = sc.next(); System.out.println("请输入学生生日:"); String birthday = sc.next(); Student stu = new Student(); stu.setId(id); stu.setName(name); stu.setAge(age); stu.setBirthday(birthday); return stu; } } OtherStudentController类 public class OtherStudentController extends BaseStudentController { private Scanner sc = new Scanner(System.in); // 键盘录入学生信息 // 开闭原则: 对扩展内容开放, 对修改内容关闭 @Override public Student inputStudentInfo(String id) { System.out.println("请输入学生姓名:"); String name = sc.next(); System.out.println("请输入学生年龄:"); String age = sc.next(); System.out.println("请输入学生生日:"); String birthday = sc.next(); Student stu = new Student(id,name,age,birthday); return stu; } }
8.抽象类
8.1抽象类的概述（理解）
当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！
8.2抽象类的特点（记忆）
-
抽象类和抽象方法必须使用 abstract 关键字修饰
//抽象类的定义 public abstract class 类名 {} //抽象方法的定义 public abstract void eat(); -
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
-
抽象类不能实例化
-
抽象类可以有构造方法
-
抽象类的子类
要么重写抽象类中的所有抽象方法
要么是抽象类
8.3抽象类的案例（应用）
-
案例需求
定义猫类(Cat)和狗类(Dog)
猫类成员方法：eat（猫吃鱼）drink（喝水…）
狗类成员方法：eat（狗吃肉）drink（喝水…）
-
实现步骤
-
猫类和狗类中存在共性内容，应向上抽取出一个动物类（Animal）
-
父类Animal中，无法将 eat 方法具体实现描述清楚，所以定义为抽象方法
-
抽象方法需要存活在抽象类中，将Animal定义为抽象类
-
让 Cat 和 Dog 分别继承 Animal，重写eat方法
-
测试类中创建 Cat 和 Dog 对象，调用方法测试
-
-
代码实现
-
动物类
public abstract class Animal { public void drink(){ System.out.println("喝水"); } public Animal(){ } public abstract void eat(); }-
猫类
public class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } }-
狗类
public class Dog extends Animal { @Override public void eat() { System.out.println("狗吃肉"); } }-
测试类
public static void main(String[] args) { Dog d = new Dog(); d.eat(); d.drink(); Cat c = new Cat(); c.drink(); c.eat(); //Animal a = new Animal(); //a.eat(); } -
8.4模板设计模式
-
设计模式
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。 使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
-
模板设计模式
把抽象类整体就可以看做成一个模板，模板中不能决定的东西定义成抽象方法 让使用模板的类（继承抽象类的类）去重写抽象方法实现需求
-
模板设计模式的优势
模板已经定义了通用结构，使用者只需要关心自己需要实现的功能即可
-
示例代码
模板类
/* 作文模板类 */ public abstract class CompositionTemplate { public final void write(){ System.out.println("<<我的爸爸>>"); body(); System.out.println("啊~ 这就是我的爸爸"); } public abstract void body(); }实现类A
public class Tom extends CompositionTemplate { @Override public void body() { System.out.println("那是一个秋天, 风儿那么缠绵,记忆中, " + "那天爸爸骑车接我放学回家,我的脚卡在了自行车链当中, 爸爸蹬不动,他就站起来蹬..."); } }实现类B
public class Tony extends CompositionTemplate { @Override public void body() { } /*public void write(){ }*/ }测试类
public class Test { public static void main(String[] args) { Tom t = new Tom(); t.write(); } }
8.5final（应用）
-
final关键字的作用
-
final代表最终的意思，可以修饰成员方法，成员变量，类
-
-
final修饰类、方法、变量的效果
-
final修饰类：该类不能被继承（不能有子类，但是可以有父类）
-
final修饰方法：该方法不能被重写
-
final修饰变量：表明该变量是一个常量，不能再次赋值
-
变量是基本类型,不能改变的是值
-
变量是引用类型,不能改变的是地址值,但地址里面的内容是可以改变的
-
举例
public static void main(String[] args){ final Student s = new Student(23); s = new Student(24); // 错误 s.setAge(24); // 正确 }
-
-
8.6文峰信息管理系统使用抽象类改进 (应用)
-
需求
-
使用抽象类的思想，将BaseStudentController 中的 inputStudentInfo 方法，定义为抽象方法
-
将不希望子类重写的方法，使用 final 进行修饰
-
-
代码实现
BaseStudentController类
public abstract class BaseStudentController { // 业务员对象 private StudentService studentService = new StudentService(); private Scanner sc = new Scanner(System.in); // 开启学生管理系统, 并展示学生管理系统菜单 public final void start() { //Scanner sc = new Scanner(System.in); studentLoop: while (true) { System.out.println("--------欢迎来到 <学生> 管理系统--------"); System.out.println("请输入您的选择: 1.添加学生 2.删除学生 3.修改学生 4.查看学生 5.退出"); String choice = sc.next(); switch (choice) { case "1": // System.out.println("添加"); addStudent(); break; case "2": // System.out.println("删除"); deleteStudentById(); break; case "3": // System.out.println("修改"); updateStudent(); break; case "4": // System.out.println("查询"); findAllStudent(); break; case "5": System.out.println("感谢您使用学生管理系统, 再见!"); break studentLoop; default: System.out.println("您的输入有误, 请重新输入"); break; } } } // 修改学生方法 public final void updateStudent() { String updateId = inputStudentId(); Student newStu = inputStudentInfo(updateId); studentService.updateStudent(updateId, newStu); System.out.println("修改成功!"); } // 删除学生方法 public final void deleteStudentById() { String delId = inputStudentId(); // 3. 调用业务员中的deleteStudentById根据id, 删除学生 studentService.deleteStudentById(delId); // 4. 提示删除成功 System.out.println("删除成功!"); } // 查看学生方法 public final void findAllStudent() { // 1. 调用业务员中的获取方法, 得到学生的对象数组 Student[] stus = studentService.findAllStudent(); // 2. 判断数组的内存地址, 是否为null if (stus == null) { System.out.println("查无信息, 请添加后重试"); return; } // 3. 遍历数组, 获取学生信息并打印在控制台 System.out.println("学号\t\t姓名\t年龄\t生日"); for (int i = 0; i < stus.length; i++) { Student stu = stus[i]; if (stu != null) { System.out.println(stu.getId() + "\t" + stu.getName() + "\t" + stu.getAge() + "\t\t" + stu.getBirthday()); } } } // 添加学生方法 public final void addStudent() { // StudentService studentService = new StudentService(); // 1. 键盘接收学生信息 String id; while (true) { System.out.println("请输入学生id:"); id = sc.next(); boolean flag = studentService.isExists(id); if (flag) { System.out.println("学号已被占用, 请重新输入"); } else { break; } } Student stu = inputStudentInfo(id); // 3. 将学生对象,传递给StudentService(业务员)中的addStudent方法 boolean result = studentService.addStudent(stu); // 4. 根据返回的boolean类型结果, 在控制台打印成功\失败 if (result) { System.out.println("添加成功"); } else { System.out.println("添加失败"); } } // 键盘录入学生id public String inputStudentId() { String id; while (true) { System.out.println("请输入学生id:"); id = sc.next(); boolean exists = studentService.isExists(id); if (!exists) { System.out.println("您输入的id不存在, 请重新输入:"); } else { break; } } return id; } // 键盘录入学生信息 // 开闭原则: 对扩展内容开放, 对修改内容关闭 public abstract Student inputStudentInfo(String id); }
9.代码块
9.1代码块概述 (理解)
在Java中，使用 { } 括起来的代码被称为代码块
9.2代码块分类 (理解)
-
局部代码块
-
位置: 方法中定义
-
作用: 限定变量的生命周期，及早释放，提高内存利用率
-
示例代码
public class Test { /* 局部代码块 位置：方法中定义 作用：限定变量的生命周期，及早释放，提高内存利用率 */ public static void main(String[] args) { { int a = 10; System.out.println(a); } // System.out.println(a); } }
-
-
构造代码块
-
位置: 类中方法外定义
-
特点: 每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行
-
作用: 将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性
-
示例代码
public class Test { /* 构造代码块: 位置：类中方法外定义 特点：每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行 作用：将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性 */ public static void main(String[] args) { Student stu1 = new Student(); Student stu2 = new Student(10); } } class Student { { System.out.println("好好学习"); } public Student(){ System.out.println("空参数构造方法"); } public Student(int a){ System.out.println("带参数构造方法..........."); } }
-
-
静态代码块
-
位置: 类中方法外定义
-
特点: 需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
-
作用: 在类加载的时候做一些数据初始化的操作
-
示例代码
public class Test { /* 静态代码块: 位置：类中方法外定义 特点：需要通过static关键字修饰，随着类的加载而加载，并且只执行一次 作用：在类加载的时候做一些数据初始化的操作 */ public static void main(String[] args) { Person p1 = new Person(); Person p2 = new Person(10); } } class Person { static { System.out.println("我是静态代码块, 我执行了"); } public Person(){ System.out.println("我是Person类的空参数构造方法"); } public Person(int a){ System.out.println("我是Person类的带...........参数构造方法"); } }
-
9.3文峰信息管理系统使用代码块改进 (应用)
-
需求
使用静态代码块，初始化一些学生数据
-
实现步骤
-
在StudentDao类中定义一个静态代码块，用来初始化一些学生数据
-
将初始化好的学生数据存储到学生数组中
-
-
示例代码
StudentDao类
public class StudentDao { // 创建学生对象数组 private static Student[] stus = new Student[5]; static { Student stu1 = new Student("wedu001","张三","23","1999-11-11"); Student stu2 = new Student("wedu002","李四","24","2000-11-11"); stus[0] = stu1; stus[1] = stu2; } // 添加学生方法 public boolean addStudent(Student stu) { // 2. 添加学生到数组 //2.1 定义变量index为-1，假设数组已经全部存满，没有null的元素 int index = -1; //2.2 遍历数组取出每一个元素，判断是否是null for (int i = 0; i < stus.length; i++) { Student student = stus[i]; if(student == null){ index = i; //2.3 如果为null，让index变量记录当前索引位置，并使用break结束循环遍历 break; } } // 3. 返回是否添加成功的boolean类型状态 if(index == -1){ // 装满了 return false; }else{ // 没有装满, 正常添加, 返回true stus[index] = stu; return true; } } // 查看学生方法 public Student[] findAllStudent() { return stus; } public void deleteStudentById(String delId) { // 1. 查找id在容器中所在的索引位置 int index = getIndex(delId); // 2. 将该索引位置,使用null元素进行覆盖 stus[index] = null; } public int getIndex(String id){ int index = -1; for (int i = 0; i < stus.length; i++) { Student stu = stus[i]; if(stu != null && stu.getId().equals(id)){ index = i; break; } } return index; } public void updateStudent(String updateId, Student newStu) { // 1. 查找updateId, 在容器中的索引位置 int index = getIndex(updateId); // 2. 将该索引位置, 使用新的学生对象替换 stus[index] = newStu; } }
10.接口
10.1文峰信息管理系统集合改进 (应用)
-
使用数组容器的弊端
-
容器长度是固定的，不能根据添加功能自动增长
-
没有提供用于赠删改查的方法
-
-
优化步骤
-
创建新的StudentDao类，OtherStudentDao
-
创建ArrayList集合容器对象
-
OtherStudentDao中的方法声明，需要跟StudentDao保持一致
注意：如果不一致，StudentService中的代码就需要进行修改
-
完善方法（添加、删除、修改、查看）
-
替换StudentService中的Dao对象
-
-
代码实现
OtherStudentDao类
public class OtherStudentDao { // 集合容器 private static ArrayList<Student> stus = new ArrayList<>(); static { Student stu1 = new Student("heima001","张三","23","1999-11-11"); Student stu2 = new Student("heima002","李四","24","2000-11-11"); stus.add(stu1); stus.add(stu2); } // 添加学生方法 public boolean addStudent(Student stu) { stus.add(stu); return true; } // 查看学生方法 public Student[] findAllStudent() { Student[] students = new Student[stus.size()]; for (int i = 0; i < students.length; i++) { students[i] = stus.get(i); } return students; } public void deleteStudentById(String delId) { // 1. 查找id在容器中所在的索引位置 int index = getIndex(delId); stus.remove(index); } public int getIndex(String id){ int index = -1; for (int i = 0; i < stus.size(); i++) { Student stu = stus.get(i); if(stu != null && stu.getId().equals(id)){ index = i; break; } } return index; } public void updateStudent(String updateId, Student newStu) { // 1. 查找updateId, 在容器中的索引位置 int index = getIndex(updateId); stus.set(index, newStu); } }StudentService类
public class StudentService { // 创建StudentDao (库管) private OtherStudentDao studentDao = new OtherStudentDao(); // 其他方法没有变化,此处省略... }
10.2文峰信息管理系统抽取Dao (应用)
-
优化步骤
-
将方法向上抽取，抽取出一个父类 （ BaseStudentDao ）
-
方法的功能实现在父类中无法给出具体明确，定义为抽象方法
-
让两个类分别继承 BaseStudentDao ，重写内部抽象方法
-
-
代码实现
BaseStudentDao类
public abstract class BaseStudentDao { // 添加学生方法 public abstract boolean addStudent(Student stu); // 查看学生方法 public abstract Student[] findAllStudent(); // 删除学生方法 public abstract void deleteStudentById(String delId); // 根据id找索引方法 public abstract int getIndex(String id); // 修改学生方法 public abstract void updateStudent(String updateId, Student newStu); }StudentDao类
public class StudentDao extends BaseStudentDao { // 其他内容不变,此处省略 }OtherStudentDao类
public class OtherStudentDao extends BaseStudentDao { // 其他内容不变,此处省略 }
10.3接口的概述（理解）
-
接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
-
Java中接口存在的两个意义
-
用来定义规范
-
用来做功能的拓展
-
10.4接口的特点（记忆）
-
接口用关键字interface修饰
public interface 接口名 {} -
类实现接口用implements表示
public class 类名 implements 接口名 {} -
接口不能实例化
我们可以创建接口的实现类对象使用
-
接口的子类
要么重写接口中的所有抽象方法
要么子类也是抽象类
10.5接口的成员特点（记忆）
-
成员特点
-
成员变量
只能是常量 默认修饰符：public static final
-
构造方法
没有，因为接口主要是扩展功能的，而没有具体存在
-
成员方法
只能是抽象方法
默认修饰符：public abstract
关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解
-
-
代码演示
-
接口
public interface Inter { public static final int NUM = 10; public abstract void show(); }-
实现类
class InterImpl implements Inter{ public void method(){ // NUM = 20; System.out.println(NUM); } public void show(){ } }-
测试类
public class TestInterface { /* 成员变量: 只能是常量 系统会默认加入三个关键字 public static final 构造方法: 没有 成员方法: 只能是抽象方法, 系统会默认加入两个关键字 public abstract */ public static void main(String[] args) { System.out.println(Inter.NUM); } } -
10.6类和接口的关系（记忆）
-
类与类的关系
继承关系，只能单继承，但是可以多层继承
-
类与接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
-
接口与接口的关系
继承关系，可以单继承，也可以多继承
10.7文峰信息管理系统使用接口改进 (应用)
-
实现步骤
-
将 BaseStudentDao 改进为一个接口
-
让 StudentDao 和 OtherStudentDao 去实现这个接口
-
-
代码实现
BaseStudentDao接口
public interface BaseStudentDao { // 添加学生方法 public abstract boolean addStudent(Student stu); // 查看学生方法 public abstract Student[] findAllStudent(); // 删除学生方法 public abstract void deleteStudentById(String delId); // 根据id找索引方法 public abstract int getIndex(String id); // 修改学生方法 public abstract void updateStudent(String updateId, Student newStu); }StudentDao类
public class StudentDao implements BaseStudentDao { // 其他内容不变,此处省略 }OtherStudentDao类
public class OtherStudentDao implements BaseStudentDao { // 其他内容不变,此处省略 }
10.8文峰信息管理系统解耦合改进 (应用)
-
实现步骤
-
创建factory包，创建 StudentDaoFactory（工厂类）
-
提供 static 修改的 getStudentDao 方法，该方法用于创建StudentDao对象并返回
-
-
代码实现
StudentDaoFactory类
public class StudentDaoFactory { public static OtherStudentDao getStudentDao(){ return new OtherStudentDao(); } }StudentService类
public class StudentService { // 创建StudentDao (库管) // private OtherStudentDao studentDao = new OtherStudentDao(); // 通过学生库管工厂类, 获取库管对象 private OtherStudentDao studentDao = StudentDaoFactory.getStudentDao(); }
11.接口组成更新
11.1接口组成更新概述【理解】
-
常量
public static final
-
抽象方法
public abstract
-
默认方法(Java 8)
-
静态方法(Java 8)
-
私有方法(Java 9)
11.2接口中默认方法【应用】
-
格式
public default 返回值类型 方法名(参数列表) { }
-
作用
解决接口升级的问题
-
范例
public default void show3() {
}
-
注意事项
-
默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字
-
public可以省略，default不能省略
-
如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写
-
11.3接口中静态方法【应用】
-
格式
public static 返回值类型 方法名(参数列表) { }
-
范例
public static void show() { } -
注意事项
-
静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
-
public可以省略，static不能省略
-
11.4接口中私有方法【应用】
-
私有方法产生原因
Java 9中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性
-
定义格式
-
格式1
private 返回值类型 方法名(参数列表) { }
-
范例1
private void show() { } -
格式2
private static 返回值类型 方法名(参数列表) { }
-
范例2
private static void method() { }
-
-
注意事项
-
默认方法可以调用私有的静态方法和非静态方法
-
静态方法只能调用私有的静态方法
-
12.多态
12.1多态的概述（记忆）
-
什么是多态
同一个对象，在不同时刻表现出来的不同形态
-
多态的前提
-
要有继承或实现关系
-
要有方法的重写
-
要有父类引用指向子类对象
-
-
代码演示
class Animal { public void eat(){ System.out.println("动物吃饭"); } } class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } } public class Test1Polymorphic { /* 多态的前提: 1. 要有(继承 \ 实现)关系 2. 要有方法重写 3. 要有父类引用, 指向子类对象 */ public static void main(String[] args) { // 当前事物, 是一只猫 Cat c = new Cat(); // 当前事物, 是一只动物 Animal a = new Cat(); a.eat(); } }
12.2多态中的成员访问特点（记忆）
-
成员访问特点
-
成员变量
编译看父类，运行看父类
-
成员方法
编译看父类，运行看子类
-
-
代码演示
class Fu { int num = 10; public void method(){ System.out.println("Fu.. method"); } } class Zi extends Fu { int num = 20; public void method(){ System.out.println("Zi.. method"); } } public class Test2Polymorpic { /* 多态的成员访问特点: 成员变量: 编译看左边 (父类), 运行看左边 (父类) 成员方法: 编译看左边 (父类), 运行看右边 (子类) */ public static void main(String[] args) { Fu f = new Zi(); System.out.println(f.num); f.method(); } }
12.3多态的好处和弊端（记忆）
-
好处
提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
-
弊端
不能使用子类的特有成员
12.4多态中的转型（应用）
-
向上转型
父类引用指向子类对象就是向上转型
-
向下转型
格式：子类型 对象名 = (子类型)父类引用;
-
代码演示
class Fu { public void show(){ System.out.println("Fu..show..."); } } class Zi extends Fu { @Override public void show() { System.out.println("Zi..show..."); } public void method(){ System.out.println("我是子类特有的方法, method"); } } public class Test3Polymorpic { public static void main(String[] args) { // 1. 向上转型 : 父类引用指向子类对象 Fu f = new Zi(); f.show(); // 多态的弊端: 不能调用子类特有的成员 // f.method(); // A: 直接创建子类对象 // B: 向下转型 // 2. 向下转型 : 从父类类型, 转换回子类类型 Zi z = (Zi) f; z.method(); } }
12.5多态中转型存在的风险和解决方案 (应用)
-
风险
如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException
-
解决方案
-
关键字
instanceof
-
使用格式
变量名 instanceof 类型
通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果
-
-
代码演示
abstract class Animal { public abstract void eat(); } class Dog extends Animal { public void eat() { System.out.println("狗吃肉"); } public void watchHome(){ System.out.println("看家"); } } class Cat extends Animal { public void eat() { System.out.println("猫吃鱼"); } } public class Test4Polymorpic { public static void main(String[] args) { useAnimal(new Dog()); useAnimal(new Cat()); } public static void useAnimal(Animal a){ // Animal a = new Dog(); // Animal a = new Cat(); a.eat(); //a.watchHome(); // Dog dog = (Dog) a; // dog.watchHome(); // ClassCastException 类型转换异常 // 判断a变量记录的类型, 是否是Dog if(a instanceof Dog){ Dog dog = (Dog) a; dog.watchHome(); } } }
12.6文峰信息管理系统多态改进 (应用)
-
实现步骤
-
StudentDaoFactory类中方法的返回值定义成父类类型BaseStudentDao
-
StudentService中接收方法返回值的类型定义成父类类型BaseStudentDao
-
-
代码实现
StudentDaoFactory类
public class StudentDaoFactory { public static BaseStudentDao getStudentDao(){ return new OtherStudentDao(); } }StudentService类
public class StudentService { // 创建StudentDao (库管) // private OtherStudentDao studentDao = new OtherStudentDao(); // 通过学生库管工厂类, 获取库管对象 private BaseStudentDao studentDao = StudentDaoFactory.getStudentDao(); }
13.内部类
13.1 内部类的基本使用（理解）
-
内部类概念
-
在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类
-
-
内部类定义格式
-
格式&举例：
/* 格式： class 外部类名{ 修饰符 class 内部类名{ } } */ class Outer { public class Inner { } }
-
-
内部类的访问特点
-
内部类可以直接访问外部类的成员，包括私有
-
外部类要访问内部类的成员，必须创建对象
-
-
示例代码：
/* 内部类访问特点： 内部类可以直接访问外部类的成员，包括私有 外部类要访问内部类的成员，必须创建对象 */ public class Outer { private int num = 10; public class Inner { public void show() { System.out.println(num); } } public void method() { Inner i = new Inner(); i.show(); } }
13.2 成员内部类（理解）
-
成员内部类的定义位置
-
在类中方法，跟成员变量是一个位置
-
-
外界创建成员内部类格式
-
格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
-
举例：Outer.Inner oi = new Outer().new Inner();
-
-
私有成员内部类
-
将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。
-
示例代码：
class Outer { private int num = 10; private class Inner { public void show() { System.out.println(num); } } public void method() { Inner i = new Inner(); i.show(); } } public class InnerDemo { public static void main(String[] args) { //Outer.Inner oi = new Outer().new Inner(); //oi.show(); Outer o = new Outer(); o.method(); } }
-
-
静态成员内部类
-
静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
-
静态成员内部类中的静态方法：外部类名.内部类名.方法名();
-
示例代码
class Outer { static class Inner { public void show(){ System.out.println("inner..show"); } public static void method(){ System.out.println("inner..method"); } } } public class Test3Innerclass { /* 静态成员内部类演示 */ public static void main(String[] args) { // 外部类名.内部类名 对象名 = new 外部类名.内部类名(); Outer.Inner oi = new Outer.Inner(); oi.show(); Outer.Inner.method(); } }
-
13.3 局部内部类（理解）
-
局部内部类定义位置
-
局部内部类是在方法中定义的类
-
-
局部内部类方式方式
-
局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
-
该类可以直接访问外部类的成员，也可以访问方法内的局部变量
-
-
示例代码
class Outer { private int num = 10; public void method() { int num2 = 20; class Inner { public void show() { System.out.println(num); System.out.println(num2); } } Inner i = new Inner(); i.show(); } } public class OuterDemo { public static void main(String[] args) { Outer o = new Outer(); o.method(); } }
13.4 匿名内部类（应用）
-
匿名内部类的前提
-
存在一个类或者接口，这里的类可以是具体类也可以是抽象类
-
-
匿名内部类的格式
-
格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }
-
举例：
new Inter(){ @Override public void method(){} }
-
-
匿名内部类的本质
-
本质：是一个继承了该类或者实现了该接口的子类匿名对象
-
-
匿名内部类的细节
-
匿名内部类可以通过多态的形式接受
Inter i = new Inter(){ @Override public void method(){ } }
-
-
匿名内部类直接调用方法
interface Inter{ void method(); } class Test{ public static void main(String[] args){ new Inter(){ @Override public void method(){ System.out.println("我是匿名内部类"); } }.method(); // 直接调用方法 } }
13.4 匿名内部类在开发中的使用（应用）
-
匿名内部类在开发中的使用
-
当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码
-
-
示例代码：
/* 游泳接口 */ interface Swimming { void swim(); } public class TestSwimming { public static void main(String[] args) { goSwimming(new Swimming() { @Override public void swim() { System.out.println("铁汁, 我们去游泳吧"); } }); } /** * 使用接口的方法 */ public static void goSwimming(Swimming swimming){ /* Swimming swim = new Swimming() { @Override public void swim() { System.out.println("铁汁, 我们去游泳吧"); } } */ swimming.swim(); } }
14.Lambda表达式
14.1体验Lambda表达式【理解】
-
代码演示
/* 游泳接口 */ interface Swimming { void swim(); } public class TestSwimming { public static void main(String[] args) { // 通过匿名内部类实现 goSwimming(new Swimming() { @Override public void swim() { System.out.println("铁汁, 我们去游泳吧"); } }); /* 通过Lambda表达式实现 理解: 对于Lambda表达式, 对匿名内部类进行了优化 */ goSwimming(() -> System.out.println("铁汁, 我们去游泳吧")); } /** * 使用接口的方法 */ public static void goSwimming(Swimming swimming) { swimming.swim(); } } -
函数式编程思想概述
在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”
面向对象思想强调“必须通过对象的形式来做事情”
函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”
而我们要学习的Lambda表达式就是函数式思想的体现
14.2Lambda表达式的标准格式【理解】
-
格式：
(形式参数) -> {代码块}
-
形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
-
->：由英文中画线和大于符号组成，固定写法。代表指向动作
-
代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
-
-
组成Lambda表达式的三要素：
-
形式参数，箭头，代码块
-
14.3Lambda表达式练习1【应用】
-
Lambda表达式的使用前提
-
有一个接口
-
接口中有且仅有一个抽象方法
-
-
练习描述
无参无返回值抽象方法的练习
-
操作步骤
-
定义一个接口(Eatable)，里面定义一个抽象方法：void eat();
-
定义一个测试类(EatableDemo)，在测试类中提供两个方法
-
一个方法是：useEatable(Eatable e)
-
一个方法是主方法，在主方法中调用useEatable方法
-
-
-
示例代码
//接口 public interface Eatable { void eat(); } //实现类 public class EatableImpl implements Eatable { @Override public void eat() { System.out.println("一天一苹果，医生远离我"); } } //测试类 public class EatableDemo { public static void main(String[] args) { //在主方法中调用useEatable方法 Eatable e = new EatableImpl(); useEatable(e); //匿名内部类 useEatable(new Eatable() { @Override public void eat() { System.out.println("一天一苹果，医生远离我"); } }); //Lambda表达式 useEatable(() -> { System.out.println("一天一苹果，医生远离我"); }); } private static void useEatable(Eatable e) { e.eat(); } }
14.4Lambda表达式练习2【应用】
-
练习描述
有参无返回值抽象方法的练习
-
操作步骤
-
定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);
-
定义一个测试类(FlyableDemo)，在测试类中提供两个方法
-
一个方法是：useFlyable(Flyable f)
-
一个方法是主方法，在主方法中调用useFlyable方法
-
-
-
示例代码
public interface Flyable { void fly(String s); } public class FlyableDemo { public static void main(String[] args) { //在主方法中调用useFlyable方法 //匿名内部类 useFlyable(new Flyable() { @Override public void fly(String s) { System.out.println(s); System.out.println("飞机自驾游"); } }); System.out.println("--------"); //Lambda useFlyable((String s) -> { System.out.println(s); System.out.println("飞机自驾游"); }); } private static void useFlyable(Flyable f) { f.fly("风和日丽，晴空万里"); } }
14.5Lambda表达式练习3【应用】
-
练习描述
有参有返回值抽象方法的练习
-
操作步骤
-
定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);
-
定义一个测试类(AddableDemo)，在测试类中提供两个方法
-
一个方法是：useAddable(Addable a)
-
一个方法是主方法，在主方法中调用useAddable方法
-
-
-
示例代码
public interface Addable { int add(int x,int y); } public class AddableDemo { public static void main(String[] args) { //在主方法中调用useAddable方法 useAddable((int x,int y) -> { return x + y; }); } private static void useAddable(Addable a) { int sum = a.add(10, 20); System.out.println(sum); } }
14.6Lambda表达式的省略模式【应用】
-
省略的规则
-
参数类型可以省略。但是有多个参数的情况下，不能只省略一个
-
如果参数有且仅有一个，那么小括号可以省略
-
如果代码块的语句只有一条，可以省略大括号和分号，和return关键字
-
-
代码演示
public interface Addable { int add(int x, int y); } public interface Flyable { void fly(String s); } public class LambdaDemo { public static void main(String[] args) { // useAddable((int x,int y) -> { // return x + y; // }); //参数的类型可以省略 useAddable((x, y) -> { return x + y; }); // useFlyable((String s) -> { // System.out.println(s); // }); //如果参数有且仅有一个，那么小括号可以省略 // useFlyable(s -> { // System.out.println(s); // }); //如果代码块的语句只有一条，可以省略大括号和分号 useFlyable(s -> System.out.println(s)); //如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉 useAddable((x, y) -> x + y); } private static void useFlyable(Flyable f) { f.fly("风和日丽，晴空万里"); } private static void useAddable(Addable a) { int sum = a.add(10, 20); System.out.println(sum); } }
14.7Lambda表达式的使用前提【理解】
-
使用Lambda必须要有接口
-
并且要求接口中有且仅有一个抽象方法
14.8Lambda表达式和匿名内部类的区别【理解】
-
所需类型不同
-
匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
-
Lambda表达式：只能是接口
-
-
使用限制不同
-
如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
-
如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
-
-
实现原理不同
-
匿名内部类：编译之后，产生一个单独的.class字节码文件
-
Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成
-
扫一扫
726
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
