【Java基础】面向对象（中）（下）、

五、面向对象(中)

01-OOP特征二：继承性(inheritance)

1、为什么要有继承？多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
2、类继承语法规则：class Subclass extends SuperClass{ }
3、 继承的出现让类与类之间产生了关系，提供了多态的前提。【注意】：不要仅为了获取其他类中某个功能而去继承。

继承性的使用和理解

• Creature 类

public class Creature {
	public void breathe(){
		System.out.println("呼吸");
	}
}

• Person类

public class Person extends Creature{
    String name;
    private int age;

    public Person() {}

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private void sleep() {
        System.out.println("睡觉");
    }

    public void eat() {
        System.out.println("吃饭");
        sleep();
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

• Student 类

public class Student extends Person{
//    String name;
//    int age;
    String major;

    public Student() {}

//    public Student(String name, int age, String major) {
//        super(name, age);
//        this.major = major;
//    }


    public Student(String name, int age, String major) {
        this.name = name;
//        this.age = age;
        setAge(age);
        this.major = major;
    }

    public void study() {
        System.out.println("学习");
    }

    public void show() {
        System.out.println("name: " + name + ", age = " + getAge());
    }
}

• 测试类ExtendsTest

public class ExtendsTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.eat(); // 吃饭 睡觉

        System.out.println("***************");

        Student s1 = new Student();
        s1.eat(); // 吃饭 睡觉
//      s1.sleep();
        s1.name = "Tom";
        s1.show(); // name: Tom, age = 0
        s1.breathe(); // 呼吸
        s1.setAge(18);
        System.out.println(s1.getAge()); // 18

        Creature c = new Creature();
        System.out.println(c.toString()); // com.rujun.inherit.sept1322.Creature@1b6d3586
    }
}

02-方法的重写(override/overwrite)

概念

重写方法举例

03-四种访问权限修饰符

访问控制举例

class Child extends Parent{ //设父类和子类在同一个包内
	private int c1 = 21;
	public int c2 = 22;
	private void cm1(){
		System.out.println("in cm1() c1=" + c1);
	}
	public void cm2(){
		System.out.println("in cm2() c2=" + c2);
	}
	public static void main(String[] args){
		int i; 
		Parent p = new Parent();
		i = p.f2; // i = p.f3; i = p.f4;
		p.fm2(); // p.fm3(); p.fm4();
		Child c = new Child();
		i = c.f2; // i = c.f3; i = c.f4;
		i = c.c1; // i = c.c2;
		c.cm1(); // c.cm2(); c.fm2(); c.fm3(); c.fm4()
	}
}

class Parent{
	private int f1 = 1;
	int f2 = 2;
	protected int f3 = 3;
	public int f4 = 4;
	private void fm1() {
		System.out.println("in fm1() f1=" + f1);
	}
	void fm2() {
		System.out.println("in fm2() f2=" + f2);
	}
	protected void fm3() {
		System.out.println("in fm3() f3=" + f3);
	}
	public void fm4() {
		System.out.println("in fm4() f4=" + f4);
	}
}

04-关键字：super

1、在Java类中使用 super 来调用父类中的指定操作：

• super可用于访问父类中定义的属性。
• super可用于调用父类中定义的成员方法。
• super可用于在子类构造器中调用父类的构造器。

2、【注意】尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员。super的追溯不仅限于直接父类。 super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识。

05-子类对象实例化过程

06-OOP特征三：多态性

07-Object类的使用

08-包装类的使用

01-每天一考
02-复习：封装性与构造器
03-复习：this_package_import
04-Eclipse 常用快捷键 1
05-Eclipse 常用快捷键 2
06-Eclipse 常用快捷键 3
07-回顾 Bank 练习的难点
08-项目二功能演示
09-项目二软件结构设计
10-项目二 CMUtility 工具类的功能介绍
11-项目二：Customer 类的设计
12-项目二：CustomerList 类的设计
13-项目二：CustomerView 的整体框架的搭建
14-项目二：CustomerView 退出功能的实现
15-项目二：CustomerView 客户列表功能的实现
16-项目二：CustomerView 添加客户功能的实现
17-项目二：CustomerView 修改客户功能的实现
18-项目二：CustomerView 删除客户功能的实现
19-项目二：总结
20-继承性的理解
21-继承性的使用
22-继承性的再说明
23-Object 类的理解

day12_面向对象(中)

01-每天一考
02-复习：项目二
03-复习：继承性
04-继承性练习 1：基本操作
05-继承性练习 2：基本操作
06-Eclipse Debug 的使用
07-项目二中使用 Debug 调试
08-解决 Debug 中 step into 功能失灵问题
09-方法重写的理解
10-方法重写的细节
11-方法重写的练习
12-测试 4 种不同的权限修饰
13-super 调用属性和方法
14-super 调用构造器
15-子类对象实例化的全过程
16-继承和 super 课后练习
17-多态性的使用
18-多态性使用举例
19-多态性不适用于属性
20-虚拟方法调用的再理解

day13_面向对象(中)

01-每天一考
02-复习：重写与 super
03-复习：子类对象实例化过程及多态性
04-向下转型的使用
05-instanceof 关键字的使用
06-向下转型的几个常见问题
07-多态练习：调用方法和属性
08-多态性练习：基本操作
09-多态性练习：几何图形
10-多态性练习：重写方法
11-Object 类结构的剖析
12- ==运算符的回顾
13-equals()的使用
14-重写 equals()
15-总结==与 equals()
16-equals()练习 1：代码实现
17-equals()练习 2：代码实现
18-toString()的使用
19-Object 类综合练习
20-单元测试方法的使用
21-包装类的理解
22-基本数据类型转换为包装类
23-包装类转换为基本数据类型
24-新特性：自动装箱与自动拆箱
25-基本数据类型包装类与 String 的相互转换
26-包装类常见面试题
27-包装类的课后练习

day14_面向对象(下)

01-每天一考
02-复习：多态性
03-复习：Object 类及内部方法
04-复习：单元测试与包装类
05-static 关键字的引入
06-静态变量与实例变量的对比
07-static 修饰属性的其它说明
08-类变量和实例变量的内存解析
09-static 修饰方法
10-属性或方法是否应该 static 的经验之谈
11-自定义 ArrayUtil 工具类的优化
12-static 的应用举例
13-static 课后练习：账户信息
14-设计模式与单例设计模式
15-单例的饿汉式实现
16-单例的懒汉式实现
17-饿汉式和懒汉式的对比
18-单例模式的使用场景
19-理解 main()方法的语法
20-类中代码块结构的使用
21-开发中代码块的使用举例
22-代码块的课后练习
23-属性赋值的先后顺序(完结篇)
24-final 修饰类和方法
25-final 修饰属性
26-final 修饰局部变量
27-final 课后练习

day15_面向对象(下)

01-每天一考
02-复习：static
03-复习：单例模式
04-复习：main()
05-复习：代码块和 final
06-抽象类与抽象方法的使用
07-抽象的应用场景举例
08-abstract 使用中的注意点
09-抽象性的练习：基本操作
10-创建抽象类的匿名子类对象
11-模板方法的设计模式及应用场景
12-抽象类的课后练习
13-接口的理解
14-接口的定义与使用
15-接口的多实现与接口的继承性
16-实例演示接口是一种规范
17-创建接口匿名实现类的对象
18-接口应用：代理模式
19-接口应用：工厂模式
20-接口课后两道笔试题
21-接口练习：比较对象大小
22-Java8 中接口的新特性
23-Java8 接口新特性的应用
24-内部类的分类
25-成员内部类的特点
26-如何实例化成员内部类
27-成员内部类中调用外部类的结构
28-局部内部类的使用

day16_异常处理

01-每天一考
02-复习：抽象类
03-复习：接口
04-复习：内部类
05-局部内部类使用的一个注意点
06-异常概述
07-异常的分类
08-常见异常的举例
09-异常处理方式概述
10-处理异常：try-catch 方式
11-finally 的使用
12-编译时异常和运行时异常的不同处理
13-处理异常：throws 方式
14-重写方法异常抛出的规则
15-开发中如何选择哪种方式处理异常
16-手动抛出异常对象
17-如何自定义异常
18-异常处理练习：基本使用
19-异常处理练习：综合练习
20-异常处理章节总结

day17_项目三

01-Java 语言基础部分小结
02-项目三介绍与演示
03-项目三软件架构
04-项目三 TSUtility 和 Data 类的说明
05-项目三中 Equipment 及其实现类的完成
06-项目三中 Employee 及其子类的实现
07-项目三 NameListService 属性和构造器的实现
08-项目三 NameListService 中两个方法及 TeamException 的完成
09-项目三测试 NameListService 的 getAllEmployees()
10-项目三测试 NameListService 的 getEmployee()
11-项目三 TeamService 中属性和 getTeam()的完成
12-项目三 TeamService 中 addMember()的完成
13-项目三 TeamService 中三个小问题的理解
14-项目三 TeamService 中 removeMember()的实现
15-项目三 TeamView 整体框架的搭建
16-项目三 TeamView 退出功能的实现
17-项目三 TeamView 中显示所有员工的功能
18-项目三 TeamView 中显示开发团队成员
19-项目三 TeamView 中添加开发团队成员
20-项目三 TeamView 中删除开发团队成员

Java 高级

day01_IDEA 的使用与多线程

01-Java 语言高级的概述
02-IDEA 的卸载
03-IDEA 的介绍
04-IDEA 的安装
05-启动 IDEA 并完成 HelloWorld
06-Module 的理解和创建
07-IDEA 的常用设置
08-快捷键的设置
09-模板的使用和设置
10-章节概述_程序进程线程的概念
11-单核与多核 CPU 的任务执行_并行与并发
12-多线程的优点等
13-创建多线程方式一：继承 Thread 类
14-创建过程中两个问题的说明
15-继承方式的课后练习
16-线程的常用方法
17-线程优先级的设置
18-例题：继承 Thread 方式，多窗口卖票
19-创建多线程的方式二：实现 Runnable 接口
20-例题：实现 Runnable 方式，多窗口卖票
21-两种创建方式的对比

day02_多线程

01-每天一考
02-复习：IDEA 使用与多线程基本概念
03-复习：线程的创建与常用方法
04-线程的生命周期
05-理解线程的安全问题
06-线程安全问题的举例和解决措施
07-同步代码块处理实现 Runnable 的线程安全问题
08-同步代码块处理继承 Thread 类的线程安全问题
09-同步方法处理实现 Runnable 的线程安全问题
10-同步方法处理继承 Thread 类的线程安全问题
11-线程安全的单例模式之懒汉式
12-死锁的问题
13-Lock 锁方式解决线程安全问题
14-同步机制的课后练习
15-线程通信的例题
16-sleep()和 wait()的异同
17-线程通信：生产者消费者例题
18-创建多线程的方式三：实现 Callable 接口
19-使用线程池的好处
20-创建多线程的方式四：使用线程池

day03_常用类

01-每天一考
02-复习：生命周期与同步机制
03-复习：线程通信和新的线程创建方式等
04-Java 常用类的概述
05-String 类的概述
06-理解 String 的不可变性
07-String 不同实例化方式的对比
08-String 不同拼接操作的对比
09-String 的一道面试题
10-JVM 中涉及字符串的内存结构
11-String 的常用方法 1
12-String 的常用方法 2
13-String 的常用方法 3
14-回顾 String 与基本数据类型包装类的转换
15-String 与 char[]之间的转换
16-String 与 byte[]之间的转换
17-解决一个拼接问题
18-面试中 String 算法考查的说明
19-StringBuffer 和 StringBuilder 的介绍
20-StringBuffer 的源码分析
21-StringBuffer 中的常用方法
22-String、StringBuffer、StringBuilder 效率对比
23-System 类中获取时间戳的方法
24-Java 中两个 Date 类的使用

day04_常用类

01-每天一考
02-复习：String 类
03-复习：StringBuffer、StringBuilder
04-复习：日期时间的 API
05-String 课后算法题目 1
06-String 课后算法题目 2
07-String 课后算法题目 3
08-String 课后算法题目 3 拓展
09-IDEA 中 Debug 调试
10-SimpleDateFormat 的使用
11-SimpleDateFormat 的课后练习 1
12-SimpleDateFormat 的课后练习 2
13-Calendar 日历类的使用
14-JDK8 中日期时间 API 的介绍
15-LocalDate、LocalTime、LocalDateTime 的使用
16-Instant 类的使用
17-DateTimeFormatter 的使用
18-其它日期时间相关 API 的使用
19-IDEA 的使用：导入 Module
20-Java 比较器概述
21-Comparable 自然排序举例
22-自定义类实现 Comparable 自然排序
23-使用 Comparator 实现定制排序
24-System、Math、BigInteger、BigDecimal 的使用

day05_枚举类与注解

01-每天一考
02-复习：日期时间 API
03-复习：Java 比较器等
04-枚举类的理解
05-自定义枚举类
06-使用 enum 关键字定义枚举类
07-Enum 类中的常用方法
08-使用 enum 关键字定义的枚举类实现接口
09-IDEA 中导入 Eclipse 项目三修改 Status 为 enum 的定义
10-注解的理解
11-Annotation 的使用示例
12-JDK 内置的三个基本注解
13-如何自定义注解
14-jdk 中 4 个基本的元注解的使用 1
15-jdk 中 4 个基本的元注解的使用 2
16-jdk8 新特性：可重复注解
17-jdk8 新特性：类型注解
18-可重复注解中元注解不一致的问题解决
19-集合框架与数组的对比及概述
20-集合框架涉及到的 API
21-Collection 接口中的常用方法 1

day06_集合

01-每天一考
02-复习：枚举类
03-复习：注解
04-复习：Collection
05-Collection 接口的常用方法 2
06-Collection 接口的常用方法 3
07-Collection 接口的常用方法 4
08-使用 Iterator 遍历 Collection
09-迭代器 Iterator 的执行原理
10-Iterator 遍历集合的两种错误写法
11-Iterator 迭代器 remove()的使用
12-新特性 foreach 循环遍历集合或数组
13-List 接口常用实现类的对比
14-ArrayList 的源码分析
15-LinkedList 的源码分析
16-Vector 的源码分析
17-List 接口中的常用方法测试
18-List 遍历及方法总结
19-List 的一个面试小题
20-Set 接口实现类的对比
21-Set 的无序性与不可重复性的理解
22-HashSet 中元素的添加过程
23-关于 hashCode()和 equals()的重写
24-LinkedHashSet 的使用
25-TreeSet 的自然排序
26-TreeSet 的定制排序

day07_集合

01-每天一考
02-复习：Collection 及 Collection 的遍历
03-复习：List 接口
04-复习：Set 接口
05-TreeSet 的课后练习
06-Set 课后两道面试题
07-Map 接口及其多个实现类的对比
08-Map 中存储的 key-value 的特点
09-HashMap 在 JDK7 中的底层实现原理
10-HashMap 在 JDK8 中的底层实现原理
11-HashMap 在 JDK7 中的源码分析
12-HashMap 在 JDK8 中的源码分析
13-LinkedHashMap 的底层实现
14-Map 中的常用方法 1
15-Map 中的常用方法 2
16-TreeMap 两种添加方式的使用
17-Properties 处理属性文件
18-Collections 工具类常用方法的测试
19-集合课后几道练习题说明
20-Java 版数据结构简述

day08_泛型与 File

01-每天一考
02-复习 1：Map
03-复习 2：Collections 和数据结构
04-为什么要使用泛型
05-集合中使用泛型举例
06-集合中使用泛型的练习
07-自定义泛型类举例
08-自定义泛型类泛型接口的注意点
09-自定义泛型方法举例
10-举例泛型类和泛型方法的使用情境
11-泛型在继承方面的体现
12-通配符的使用
13-使用通配符后数据的读取和写入要求
14-有限制条件的通配符的使用
15-自定义泛型类练习
16-File 类的实例化
17-File 类的常用方法 1
18-File 类的常用方法 2
19-File 类的课后练习

day09_IO 流

01-每天一考
02-复习：集合中使用泛型
03-复习：自定义泛型结构与通配符
04-复习：File 类的使用
05-IO 流概述与流的分类
06-IO 流的体系结构
07-FileReader 读入数据的基本操作
08-FileReader 中使用 read(char[] cbuf)读入数据
09-FileWriter 写出数据的操作
10-使用 FileReader 和 FileWriter 实现文本文件的复制
11-字符流不能处理图片文件的测试
12-使用 FileInputStream 不能读取文本文件的测试
13-使用 FileInputStream 和 FileOutputStream 读写非文本文件
14-使用 FileInputStream 和 FileOutputStream 复制文件的方法测试
15-缓冲流(字节型)实现非文本文件的复制
16-缓冲流与节点流读写速度对比
17-缓冲流(字符型)实现文本文件的复制
18-缓冲流课后练习 1
19-缓冲流课后练习 2
20-转换流概述与 InputStreamReader 的使用
21-转换流实现文件的读入和写出
22-多种字符编码集的说明
23-标准的输入、输出流
24-打印流的使用
25-数据流的使用

day10_IO 流与网络编程

01-每天一考
02-复习：IO 流概述
03-复习：节点流
04-复习：缓冲流与转换流
05-复习：其它几个处理流
06-对象序列化机制的理解
07-对象流序列化与反序列化字符串操作
08-自定义类实现序列化与反序列化操作
09-serialVersionUID 的理解
10-自定义类可序列化的其它要求
11-RandomAccessFile 实现数据的读写操作
12-RandomAccessFile 实现数据的插入
13-NIO 介绍及 NIO2 中 Path、Paths、Files 的介绍
14-使用第三方 jar 包实现数据读写
15-网络编程概述
16-IP 的理解与 InetAddress 类的实例化
17-端口号的理解
18-TCP 和 UDP 网络通信协议的对比
19-TCP 网络编程例题 1
20-TCP 网络编程例题 2
21-TCP 网络编程例题 3
22-浏览器访问 Tomcat 服务器资源操作
23-UDP 网络编程举例
24-URL 类的理解与实例化
25-URL 网络编程实现 Tomcat 服务端数据下载

day11_反射

01-每天一考
02-复习：对象序列化机制
03-复习：其他 IO 流内容
04-复习：网络通信要素
05-复习：TCP、UDP、URL 网络编程
06-反射的概述
07-反射之前，类的实例化等操作
08-使用反射，实现同上的操作
09-反射的强大：调用类的私有结构
10-如何看待反射和封装性两个技术
11-Class 类的理解
12-获取 Class 实例的 4 种方式
13-Class 实例对应的结构的说明
14-理解类的加载过程
15-ClassLoader 的理解
16-使用 ClassLoader 加载配置文件
17-通过反射，创建运行时类的对象
18-举例体会反射的动态性
19-提供结构丰富 Person 类
20-获取运行时类的属性结构及其内部结构
21-获取运行时类的方法结构
22-获取运行时类的方法的内部结构
23-获取运行时类的构造器结构
24-获取运行时类的父类及父类的泛型
25-获取运行时类的接口、所在包、注解等
26-调用运行时类中的指定属性
27-调用运行时类中的指定方法
28-调用运行时类中的指定构造器

day12_动态代理与 Java8 新特性

01-每天一考
02-复习：反射与 Class
03-复习：ClassLoader 与反射的应用
04-代理模式与动态代理
05-静态代理举例
06-动态代理举例
07-AOP 与动态代理的举例
08-Java8 新特性内容概述
09-Java8 新特性的好处
10-Lambda 表达式使用举例
11-Lambda 表达式语法的使用 1
12-Lambda 表达式语法的使用 2
13-函数式接口的介绍
14-Java 内置的函数式接口介绍及使用举例
15-方法引用的使用情况 1
16-方法引用的使用情况 2
17-方法引用的使用情况 3
18-构造器引用与数组引用的使用
19-Stream API 的概述
20-Stream 的实例化
21-Stream 的中间操作：筛选与切片
22-Stream 的中间操作：映射
23-Stream 的中间操作：排序
24-Stream 的终止操作：匹配与查找
25-Stream 的终止操作：归约
26-Stream 的终止操作：收集
27-Optional 类的介绍
28-Optional 类的使用举例

day13_Java9&10&11 新特性

01-复习：动态代理
02-复习：Lambda 表达式
03-复习：函数式接口
04-复习：方法引用与构造器引用
05-复习：Stream API
06-复习：Optional 类的使用
07-jdk 版本更新的说明
08-新版本 jdk 的下载与 IDEA 开发环境的设置
09-java9 新特性：jdk 目录结构的改变
10-java9 新特性：模块化系统
11-java9 新特性：Java 的 REPL 工具：jshell
12-java9 新特性：接口中声明私有方法
13-java9 新特性：钻石操作符的语法升级
14-java9 新特性：try 结构的语法升级
15-java9 新特性：String 底层存储结构的变更
16-java9 新特性：集合工厂方法创建只读集合
17-java9 新特性：InputStream 中的 transferTo()方法
18-java9 新特性：StreamAPI 新增的 4 个方法
19-java9 新特性：Optional 的新方法 stream()
20-java9 新特性：升级的 Nashorn 引擎
21-java10 新特性的概述
22-java10 新特性：局部变量类型推断
23-java10 新特性：集合新增创建不可变集合的方法
24-java11 新特性的概述
25-java11 新特性：String 新增的方法
26-java11 新特性：Optional 新增的方法
27-java11 新特性：局部变量类型推断的升级
28-java11 新特性：HttpClient
29-java11 新特性：更简化的编译运行程序
30-java11 新特性：其它新特性
31-jdk 后续更新的展望