韩顺平循序渐进学Java零基础学习笔记

Posted Spring-_-Bear

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了韩顺平循序渐进学Java零基础学习笔记相关的知识,希望对你有一定的参考价值。

第01章 内容介绍

  1. 内容介绍

  2. 学习前的话

  3. 就业方向

  4. 开发场景

  5. 应用领域

  6. 内容梳理

第02章 Java概述

  1. 程序举例

  2. Java故事

  3. Java特性

  4. Sublime

  5. Jdk介绍

  • JVM 是一个虚拟的计算机,具有指令集并使用不同存储区域。负责执行指令,管理数据、内存、寄存器,包含在 JDK 中
  • JDK = JRE + Java 开发工具(java、javac、javap、javadoc ······)
  • JRE = JVM + Java 核心类库
  1. 我的电脑

  2. Jdk安装

  3. 环境变量配置

  4. Win7安装Jdk

  5. Mac安装Jdk

  6. 快速入门

  7. 运行机制

  8. 开发细节

  9. 学习方法

  10. 转义字符

  11. 易犯错误

  12. 注释介绍

  13. 多行注释

  14. 文档注释

  15. 代码规范

  16. DOS原理

  17. 路径详解

  18. DOS指令1

  19. DOS指令2

  20. DOS指令3

  21. 本章作业1

  22. 本章作业2

  23. 内容梳理

第03章 变量

  1. 变量原理

  2. 变量概念

  3. 变量入门

  4. 变量细节

  5. 加号使用

  6. 数据类型

  7. 整型使用

类型字节数范围
byte1-128 - 127
short2-32768 - 32767
int4-231 - 231-1
long8-263 - 263-1
  1. 整型细节

  2. 浮点数使用

类型字节数范围
float4-3.403E38 - 3.403E38
double8-1.798E308 - 1.798E308
  • 浮点数组成:符号位 + 指数位 + 尾数位
  • Java 浮点类型默认为 double 类型,定义 float 类型时需要在末尾加上 F 或 f
  1. 浮点数细节1

  2. 浮点数细节2

  3. Java文档

  4. 字符型使用

类型字节数范围
char2ISO 单一字符集
  1. 字符型细节

  2. 字符型本质

  3. 常用编码

类型字符占用字节数汉字占用字节数
ASCII1
Unicode22
UTF - 813
GBK12
  1. 布尔类型
类型字节数范围
boolean1true or false
  1. 自动类型转换基础
  • char -> int -> long -> float -> double
  • byte -> short -> int -> long -> float -> double
  1. 自动类型转换基础细节1
  • (byte,short) 和 char 之间不会自动类型转换
  • byte、char、short 在进行运算时,当作 int 处理
  1. 自动类型转换基础细节2

  2. 强制类型转换基础

  3. 强制类型转换细节

  • char 类型可以保存 int 类型的常量值,但不能保存 int 型的变量值,需要强转
  1. 类型转换练习

  2. String和基本类型转换

  3. String转基本类型细节

  4. 本章作业1

  5. 本章作业2

  6. 本章小结

第04章 运算符

  1. 算术运算符介绍

  2. 算术运算符使用

int i = 1;
i = i++;
// output:1
System.out.println(i);

int i = 1;
i = ++i;
// output:2
System.out.println(i);
  1. 算术运算符练习1

  2. 算术运算符练习2

  3. 算术运算符练习3

  4. 算术运算符练习4

  5. 关系运算符介绍

  6. 关系运算符使用

  7. 逻辑运算符介绍

  8. 短路与逻辑与

  • && 与 &
  1. 短路或逻辑或
  • || 与 |
  1. 逻辑非逻辑异或
  • ! 与 ^
  1. 逻辑运算符练习
  2. 赋值运算符介绍
  3. 赋值运算符细节
  4. 三元运算符介绍
Object object = true ? new Integer(1) : new Double(2.0);
// 三元运算符需要看作一个整体,故输出 1.0;if - else 分支结构则输出 1
System.out.println(object);
  1. 三元运算符细节
  2. 三元运算符练习
  3. 运算符优先级
运算顺序操作符
. () ; ,
R -> L++ – ~ !
L -> R* / %
L -> R+ -
L -> R<< >> >>>
L -> R< > <= >= instanceof
L -> R== !=
L -> R&
L -> R^
L -> R|
L -> R&&
L -> R||
L -> R? :
R -> L= *= /= %=
R -> L+= -= <<= >>=
R -> L>>>= &= ^= |=
  1. 标识符规则

  2. 标识符练习

  3. 标识符规范

  4. 关键字保留字

  • strictfp:strict float point (精确浮点) - strictfp关键字可应用于类、接口、方法。 使用 strictfp 关键字声明一个方法时,该方法中所有的 float 和 double 表达式都严格遵守 FP-strict 的限制,符合 IEEE-754 规范
  • volatile 是 jvm 提供的轻量级同步机制。作用是: 1. 保证可见性 2. 禁止指令重排 3. 不保证原子性
  1. 键盘输入

  2. 四种进制介绍

  3. 2进制转10进制

  4. 8进制转10进制

  5. 16进制转10进制

  6. 10进制转2进制

  7. 10进制转8进制

  8. 10进制转16进制

  9. 2进制转8进制

  10. 2进制转16进制

  11. 8进制转2进制

  12. 16进制转2进制

  13. 位运算思考题

  14. 原码、反码和补码

  15. 位运算详解1

  16. 位运算详解2

  • 算术右移:>> :低位丢弃,符号位不变,高位补符号位
  • 算术左移:<< :符号位不变,低位补0
  • 无符号右移:>> :低位丢弃,高位补 0
  1. 本章作业

  2. 内容梳理

第05章 程序控制结构

  1. 顺序控制

  2. 单分支使用

  3. 单分支流程图

  4. 双分支使用

  5. 双分支流程图

  6. 双分支练习题

  7. 多分支使用

  8. 多分支练习1

  9. 多分支练习2

  10. 嵌套分支

  11. 嵌套分支课后练习

  12. switch基本语法

  13. switch流程图

  14. switch快速入门

  15. switch细节

  • switch 的 case 后跟常量或常量表达式,switch 中的表达式只能是以下类型中的一种:byte、short、char、int、enum、String
  1. switch课堂练习1

  2. switch课堂练习2

  3. switch和if选择

  4. for基本语法

  5. for执行流程

  6. for细节

  7. for编程思想1

  8. for编程思想2

  9. while基本语法

  10. while执行流程

  11. while课堂练习

  12. do-while语法

  13. do-while执行流程

  14. do-while练习1

  15. do-while练习2

  16. 多重循环执行流程

  17. 多重循环练习1

  18. 多重循环练习2

  19. 空心金字塔

  20. break需求

  21. break执行流程

  22. break快速入门

  23. break细节

  24. break课堂练习1

  25. break课堂练习2

  26. continue执行流程

  27. continue快速入门

  28. continue细节

  29. return使用说明

  30. 本章作业1

  31. 本章作业2

  32. 本章作业3

  33. 本章作业4

  34. 本章作业5

  35. 本章作业6

  36. 内容梳理

  37. 听懂和会做

第06章 数组、排序和查找

  1. 数组必要性

  2. 数组快速入门

  • 数组是引用类型,创建数组时使用了 new 关键字
  1. 数组使用1

  2. 数组使用2

  3. 数组使用3

  • 数组静态初始化
int[] array = 2,54,3,23;
  1. 数组注意事项
  • 创建数组后,若没有赋值,则有默认值
int[] a = new int[3];
// output: [0, 0, 0]
System.out.println(Arrays.toString(a));
  1. 数组练习1

  2. 数组练习2

  3. 数组赋值机制1

  • 基本数据类型赋值,赋值的是具体的数据
  • 引用类型赋值,传递的是数组的地址
  1. 数组赋值机制2

  2. 数组拷贝

  3. 数组翻转1

  4. 数组翻转2

  5. 数组扩容1

  6. 数组扩容2

  7. 数组缩减

  8. 排序介绍

  • 内部排序:将需要处理的所有数据都加载到内部存储器中进行排序(交换式排序法、选择式排序法和插入式排序法)
  • 外部排序:数据量过大,无法全部加载到内存中,需要借助外部存储进行排序(合并排序法和直接合并排序法)
  1. 冒泡排序思路

  2. 冒泡排序实现

  3. 查找

  4. 二维数组入门

  5. 二维数组内存布局

  6. 二维数组使用1

  7. 二维数组使用2

  • Java 中二维数组每行的元素个数可以不一致
int[][] array = new int[3][];
array[0] = new int[3];
array[1] = new int[2];
array[2] = new int[6];
  1. 二维数组使用3

  2. 二维数组练习1

  3. 杨辉三角

  4. 二维数组细节

  5. 二维数组练习2

  6. 本章作业1

  7. 本章作业2

  8. 本章作业3

  9. 本章作业4

  10. 本章作业5

  11. 内容梳理

  12. 专业和编程

第07章 面向对象编程(基础部分)

  1. 类与对象引出

  2. 类与对象概述

  3. 面向对象快速入门

  4. 对象内存布局

  5. 属性概念

  6. 属性注意细节

  7. 创建对象访问属性

  8. 对象分配机制

  9. 对象创建过程

  • 栈:一般存放基本数据类型(局部变量)
  • 堆:存放对象(数组)
  • 方法区:常量池(字符串)、类加载信息
  1. 对象机制练习

  2. 方法快速入门1

  3. 方法快速入门2

  4. 方法调用机制

  5. 方法的妙用

  6. 方法的定义

  7. 方法的使用细节1

  8. 方法的使用细节2

  • 方法中不能嵌套定义方法
  1. 方法的使用细节3

  2. 方法练习题1

  3. 方法传参机制1

  4. 方法传参机制2

  5. 方法传参机制3

  6. 克隆对象

  7. 递归解决什么问题

  8. 递归执行机制1

  9. 递归执行机制2

  10. 递归执行机制3

  11. 递归执行机制4

  12. 递归斐波那契

  13. 猴子吃桃

  14. 老鼠出迷宫1

  15. 老鼠出迷宫2

  16. 老鼠出迷宫3

  17. 老鼠出迷宫4

  18. 汉诺塔

  19. 八皇后

  20. 重载介绍

  21. 重载快速入门

  22. 重载使用细节

  • 方法重载方法签名必须不同,返回值不是方法签名的一部分
  1. 重载课堂练习1

  2. 重载课堂练习2

  3. 重载课堂练习3

  4. 可变参数使用

  5. 可变参数细节

  • 可变参数的实参可以是 0 个或是多个,其本质就是数组
  • 形参列表中可以同时有普通形参和可变参数,但必须保证可变参数是形参列表的最后一个参数
  • 一个方法的形参列表只能出现一个可变参数
  1. 可变参数练习

  2. 作用域基本使用

  • 类的属性有默认值,局部变量没有默认值
  1. 作用域使用细节1

  2. 作用域使用细节2

  3. 构造器基本介绍

  4. 构造器快速入门

  5. 构造器使用细节1

  • 构造器完成对象的初始化,并不是创建对象;调用构造器时堆中已经分配了对象的空间,构造器只是负责对对象进行初始化
  1. 构造器使用细节2

  2. 构造器课堂练习

  3. 对象创建流程详解

  • 加载类信息,生成 .class 对象
  • 在堆中为对象分配空间
  • 完成对象的默认初始化
  • 构造器完成对象的初始化
  1. 引出this

  2. this入门

  • JVM 会给每个对象分配 this,代表当前对象;哪个对象调用,this 指向它
  1. this本质

  2. this小结

  3. this使用细节

  • this 不能在类定义的外部使用,只能在类定义的方法中使用
  1. this课堂练习

  2. 本章作业1

  3. 本章作业2

  4. 本章作业3

  5. 本章作业4

  6. 本章作业5

  7. 本章作业6

  8. 本章作业7

  9. 本章作业8

  10. 本章作业9

  11. 本章作业10

  12. 本章作业11

  13. 内容梳理

第08章 面向对象编程(中级部分)

  1. IDEA介绍

  2. IDEA下载安装

  3. IDEA使用1

  4. IDEA使用2

  5. IDEA使用3

  6. IDEA快捷键1

  • 自动补全 alt + /
  1. IDEA快捷键2

  2. IDEA快捷键3

  • 查看类结构:ctrl + H
  1. IDEA模板

  2. 包基本结束

  3. 包原理

  4. 包快速入门

  5. 包命名

  6. 常用的包

  7. 包的使用细节

  8. 访问修饰符规则

  • 修饰符只能用来修饰类或类的成员
  1. 访问修饰符细节

  2. 封装介绍

  3. 封装步骤

  4. 封装快速入门

  5. 封装与构造器

  6. 封装课堂练习

  7. 为什么需要继承

  8. 继承原理图

  9. 继承快速入门

  10. 继承使用细节1

  • 子类继承了父类所有的方法和属性,但父类的私有属性不能在子类中直接访问
  1. 继承使用细节2
  • 当创建子类的对象时,无论使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器,如果父类没有提供无参构造器,则必须在子类中使用 super 去显式调用父类的构造器完成父类的初始化工作,否则编译不会通过
  1. 继承使用细节3
  • super() 和 this() 都只能放在构造器的第一行,因此这两个方法不能同时存在一个构造器中
  1. 继承使用细节4
  • Object 类的所有方法

  1. 继承使用细节5

  2. 继承本质详解

  1. 继承课堂练习1

  2. 继承课堂练习2

  3. 继承课堂练习3

  4. super基本语法

  • super 代表父类的引用,用于访问父类的属性、方法、构造器
  • 使用 super 不能访问父类的 private 成员
  1. super使用细节1

  2. super使用细节2

  3. super使用细节3

区别点thissuper
方法访问本类属性,没有则依次查找父类直接依次查找父类属性
属性访问本类方法,没有则依次查找父类直接依次查找父类方法
构造器行首调用本类其它构造器行首调用父类指定构造器
特殊表示当前对象表示子类中访问父类的对象
  1. 方法重写介绍

  2. 方法重写细节

  • 子类重写父类的方法时,返回类型可以是父类返回类型的子类
  • 子类不能缩小父类方法的访问权限
  1. 重写课堂练习1

  2. 重写课堂练习2

  3. 养宠物引出多态

  4. 方法的多态

  • 重载与重写也体现了多态
  1. 对象的多态

  2. 多态快速入门

  3. 向上转型

  4. 向下转型

  5. 属性重写问题

  6. 多态课堂练习1

  7. 多态课堂练习2

  8. 动态绑定机制

  • 当调用对象方法的时候,该方法会和该对象的内存地址 / 运行类型动态绑定
  • 当调用对象属性时,不存在动态绑定,在哪儿声明在哪使用
  1. 多态数组1

  2. 多态数组2

  3. 多态参数

  4. 运算符

作用
==判断基本类型时判断值是否相等;判断引用类型时判断是否引用到同一个对象
equals()只能判断引用类型是否引用到同一个对象,子类往往重写
  1. 查看Jdk源码

  2. 子类重写equals

  3. equals课堂练习1

  4. equals课堂练习2

  5. equals课堂练习3

  6. hashCode

   /**
    * Returns a hash code value for the object. This method is
    * supported for the benefit of hash tables such as those provided by
    * @link java.util.HashMap.
    * <p>
    * The general contract of @code hashCode is:
    * <ul>
    * <li>Whenever it is invoked on the same object more than once during
    *     an execution of a Java application, the @code hashCode method
    *     must consistently return the same integer, provided no information
    *     used in @code equals comparisons on the object is modified.
    *     This integer need not remain consistent from one execution of an
    *     application to another execution of the same application.
    * <li>If two objects are equal according to the @code equals(Object)
    *     method, then calling the @code hashCode method on each of
    *     the two objects must produce the same integer result.
    * <li>It is <em>not</em> required that if two objects are unequal
    *     according to the @link java.lang.Object#equals(java.lang.Object)
    *     method, then calling the @code hashCode method on each of the
    *     two objects must produce distinct integer results.  However, the
    *     programmer should be aware that producing distinct integer results
    *     for unequal objects may improve the performance of hash tables.
    * </ul>
    * <p>
    * As much as is reasonably practical, the hashCode method defined by
    * class @code Object does return distinct integers for distinct
    * objects. (This is typically implemented by converting the internal
    * address of the object into an integer, but this implementation
    * technique is not required by the
    * Java&trade; programming language.)
    *
    * @return  a hash code value for this object.
    * @see     java.lang.Object#equals(java.lang.Object)
    * @see     java.lang.System#identityHashCode
    */
   public native int hashCode();
  1. toString
   /**
    * Returns a string representation of the object. In general, the
    * @code toString method returns a string that
    * "textually represents" this object. The result should
    * be a concise but informative representation that is easy for a
    * person to read.
    * It is recommended that all subclasses override this method.
    * <p>
    * The @code toString method for class @code Object
    * returns a string consisting of the name of the class of which the
    * object is an instance, the at-sign character `@code @', and
    * the unsigned hexadecimal representation of the hash code of the
    * object. In other words, this method returns a string equal to the
    * value of:
    * <blockquote>
    * <pre>
    * getClass().getName() + '@' + Integer.toHexString(hashCode())
    * </pre></blockquote>
    *
    * @return  a string representation of the object.
    */
   public String toString() 
       return getClass().getName() + "@" + Integer.toHexString(hashCode());
   
  1. finalize
   /**
    * Called by the garbage collector on an object when garbage collection
    * determines that there are no more references to the object.
    * A subclass overrides the @code finalize method to dispose of
    * system resources or to perform other cleanup.
    * <p>
    * The general contract of @code finalize is that it is invoked
    * if and when the Java&trade; virtual
    * machine has determined that there is no longer any
    * means by which this object can be accessed by any thread that has
    * not yet died, except as a result of an action taken by the
    * finalization of some other object or class which is ready to be
    * finalized. The @code finalize method may take any action, including
    * making this object available again to other threads; the usual purpose
    * of @code finalize, however, is to perform cleanup actions before
    * the object is irrevocably discarded. For example, the finalize method
    * for an object that represents an input/output connection might perform
    * explicit I/O transactions to break the connection before the object is
    * permanently discarded.
    * <p>
    * The @code finalize method of class @code Object performs no
    * special action; it simply returns normally. Subclasses of
    * @code Object may override this definition.
    * <p>
    * The Java programming language does not guarantee which thread will
    * invoke the @code finalize method for any given object. It is
    * guaranteed, however, that the thread that invokes finalize will not
    * be holding any user-visible synchronization locks when finalize is
    * invoked. If an uncaught exception is thrown by the finalize method,
    * the exception is ignored and finalization of that object terminates.
    * <p>
    * After the @code finalize method has been invoked for an object, no
    * further action is taken until the Java virtual machine has again
    * determined that there is no longer any means by which this object can
    * be accessed by any thread that has not yet died, including possible
    * actions by other objects or classes which are ready to be finalized,
    * at which point the object may be discarded.
    * <p>
    * The @code finalize method is never invoked more than once by a Java
    * virtual machine for any given object.
    * <p>
    * Any exception thrown by the @code finalize method causes
    * the finalization of this object to be halted, but is otherwise
    * ignored.
    *
    * @throws Throwable the @code Exception raised by this method
    * @see java.lang.ref.WeakReference
    * @see java.lang.ref.PhantomReference
    * @jls 12.6 Finalization of Class Instances
    */
   protected void finalize() throws Throwable  
  1. 断点调试介绍

  2. 断点调试案例1

  3. 断点调试案例2

  4. 断点调试案例3

  5. 断点调试案例4

  6. 断点调试案例5

  7. 断点调试案例6

  8. 零钱通介绍

  9. 零钱通菜单

  10. 零钱通明细

  11. 零钱通收益

  12. 零钱通消费

  13. 零钱通退出确认

  14. 零钱通金额校验

  15. 零钱通OPP版

  16. 本章作业1

  17. 本章作业2

  18. 本章作业3

  19. 本章作业4

  20. 本章作业5

  21. 本章作业6

  22. 本章作业7

  23. 本章作业8

  24. 本章作业9

  25. 本章作业10

  26. 本章作业11

  27. 本章作业12

  28. 本章作业13

  29. 本章作业14

  30. 本章作业15

  31. 本章作业16

  32. 本章作业17

  33. 内容梳理

  34. 不要让堕性毁了你

第09章 房屋出租系统

  1. 房屋出租需求

  2. 房屋出租设计

  3. 房屋出租工具类

  4. 房屋出租House类

  5. 房屋出租主菜单

  6. 房屋出租列表

  7. 房屋出租添加

  8. 房屋出租删除

  9. 房屋出租退出

  10. 房屋出租查找

  11. 房屋出租修改

  12. 第一阶段结束语

第10章 面向对象编程(高级部分)

  1. 类变量引出

  2. 类变量快速入门

  3. 类变量内存剖析

  • JDK 8 以前类变量放在方法区的静态域中,JDK 8 以后放在堆的对应类的 class 对象尾部
  1. 类变量定义访问
  • 类变量也即静态变量
  1. 类变量使用细节

  2. 类方法快速入门

  • 类方法也即静态方法
  1. 类方法最佳实践
  • 当方法中不设计到与任何对象相关的成员时,则可以将方法设计为静态方法以提高运行效率
  1. 类方法注意事项
  • 静态方法只能访问静态成员;非静态方法,可以访问静态和非静态成员
  1. 类成员课堂练习

  2. main语法说明

  3. main特别说明

  4. main动态传值

  5. 代码块快速入门

  • 代码块可以理解为只有方法体的方法,它没有方法名、返回值、参数,不能通过对象或类显式调用,只有在加载类或是创建对象时隐式调用
  • 代码块的修饰符只能是 static,方法体中的语句可以是任何正确逻辑语句
  • 类代码块的调用顺序优先于构造器
  1. 代码块使用细节1
  • 类加载时机:创建该类的对象时;创建子类的对象时父类也会加载;使用类的静态成员时
  • 如果只是调用类的静态成员,普通代码块并不会执行
  1. 代码块使用细节2
  • 普通代码块可以看作是构造器的一种补充机制,所以在调用类的静态成员但没有创建类的对象时,构造器并未被调用,因而类的普通代码块不会被执行
  1. 代码块使用细节3
  • 创建类的对象时,执行顺序
  1. 静态代码块与静态成员优先级一致,按定义先后顺序依次执行
  2. 普通代码块与普通成员优先级一致,按定义先后顺序依次执行
  3. 调用构造器
  • 理解:构造器的开头隐含了 super() 和 调用普通代码块
class Temp 
   public Temp() 
       super();
           
   

  1. 代码块使用细节4
  • 代码执行顺序
  1. 父类的静态代码块和静态属性按定义顺序依次执行
  2. 子类的静态代码块和静态属性按定义顺序依次执行
  3. 父类的普通代码块与普通属性按定义顺序依次执行
  4. 父类的构造器
  5. 子类的普通代码块与普通属性按定义顺序依次执行
  6. 子类的构造器
  • 静态代码块、静态方法只能调用静态成员;普通方法和普通代码块可以调用任何成员
  1. 代码块课堂练习

  2. 单例模式饿汉式

  • 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格以及解决问题的思考方式。设计模式好比经典的棋谱,不同的棋局采用不同的棋谱,免去再次思考和摸索的过程
  • 类的单例设计模式:采取一定的方法在整个软件系统中,某个类有且仅有一个对象实例,并且该类只提供一个取得该对象的方法
  • 单例模式的实现:构造器私有化;在类的内部创建对象;向外部提供一个静态的公共方法取得该对象
// 单例设计模式饿汉式
class GirlFriend 
   private GirlFriend() 
   
   private static final GirlFriend girlFriend = new GirlFriend();
   public static GirlFriend getGirlFriend() 
       return girlFriend;
   

  1. 单例模式懒汉式
// 单例设计模式懒汉式
class GirlFriend 
   private GirlFriend() 
   
   private static GirlFriend girlFriend;
   public static GirlFriend getGirlFriend() 
       if (girlFriend == null) 
           girlFriend = new GirlFriend();
       
       return girlFriend;
   

  • 饿汉式与懒汉式的区别:创建时机不同 - 饿汉式在类加载是就创建了对象而懒汉式在使用到对象时才创建
  • 饿汉式不存在线程安全问题,懒汉式存在线程安全问题
  • java.lang.Runtime 类就是经典的单例模式
public class Runtime 
   private static Runtime currentRuntime = new Runtime();

   /**
    * Returns the runtime object associated with the current Java application.
    * Most of the methods of class <code>Runtime</code> are instance
    * methods and must be invoked with respect to the current runtime object.
    *
    * @return  the <code>Runtime</code> object associated with the current
    *          Java application.
    */
   public static Runtime getRuntime() 
       return currentRuntime;
   

   /** Don't let anyone else instantiate this class */
   private Runtime() 

  1. final基本使用
  • final 的使用场景:不希望某个类被继承;不希望父类的方法被子类重写;不希望类的成员值被修改;不希望局部变量的值被修改
  1. final使用细节1
  • final 修饰的属性必须初始化,此后不能更改,初始化可在三个地方进行:定义时初始化;构造器中初始化;代码块中初始化
  • 如果 final 修饰的属性同时是 static 的,那么只能在两个地方初始化:定义时初始化;静态代码块中初始化
  • 如果非 final 类中含有 final 修饰的方法,则该方法可以被继承不能被重写
  1. final使用细节2
  • final 往往和 static 搭配使用,效率更高,因为底层编译器做了优化处理,不会导致类的加载
class GirlFriend 
   public static final int AGE = 2;
   // 当使用到 GirlFriend.AGE 时,此静态代码块不会执行即此类未加载
   static 
       System.out.println("I am your only girlfriend");
   

  • 八大包装类都是 final 类型的
  1. final课堂练习

  2. 抽象类引出

  • 当父类的某些方法需要被声明,但又不确定如何实现时,可以将其声明为抽象方法,那么这个类就是抽象类
  • 有抽象方法的类一定是抽象类,抽象类不一定有抽象方法
  • 抽象方法没有方法体即
  1. 抽象类细节1
  • abstract 只可以修饰类和方法
  1. 抽象类细节2
  • 抽象类的本质也是类,可以有任何普通类有的属性
  • 如果一个类继承自抽象类,则必须实现父类的所有抽象方法,除非它也是一个抽象类
  • 抽象方法不能使用 private、final、static 来修饰,因为这些修饰符与重写相违背
  1. 抽象类课堂练习

  2. 抽象模板模式

  3. 接口快速入门

  4. 接口基本介绍

  • JDK 7 及之前的版本,所有的方法都没有方法体及抽象方法
  • JDK 8 及之后的版本,接口类中可以有静态方法、默认方法即接口中的方法可以有具体实现
interface Study
   default public void english() 
       System.out.println("Study english");
   
   public static void math() 
       System.out.println("Study math");
   

  1. 接口应用场景

  2. 接口使用细节1

  • 抽象类实现接口可以不用实现方法;接口继承接口时可以不用实现方法
  1. 接口使用细节2
  • 接口中的属性能且仅能是 public static final 修饰符
  1. 接口课堂练习

  2. 接口VS继承

  • 继承的价值:解决代码的复用性与可维护性
  • 接口的价值:设计规范方法,一定程度上实现代码解耦即接口规范性 + 多态
  1. 接口多态特性

  2. 接口多态传递

  3. 接口课堂练习

  4. 四种内部类

  • 匿名内部类、局部内部类、成员内部类、静态内部类
  1. 局部内部类1
  • 局部内部类定义在外部类的局部位置,比如方法或代码块中,并且有类名,有以下几个特点
  1. 可以直接访问外部类的所有成员,包含私有的
  2. 不可以添加访问修饰符,可以添加 final
  3. 局部内部类可以理解为方法的局部变量
class Outer 
   private String name = "Spring-_-Bear";
   public void m1() 
       class Inner 
           private void test() 
               // 直接调用外部类的私有成员
               System.out.println(name);
           
       
       // 调用局部内部类的方法
       new Inner().test();
   

  1. 局部内部类2
  • 如果外部类和局部内部类的成员重名时,默认遵循就近原则。如果想访问外部类的成员,可以使用 外部类名.this.成员 的方式去访问
class Outer 
   private String name = "Spring-_-Bear";
   public void m1() 
       class Inner 
           private String name = "springbear";
           private void test() 
               // 调用局部内部类的成员
               System.out.println(name);
               // 调用外部类的成员
               System.out.println(Outer.this.name);
           
       
       // 调用局部内部类的方法
       new Inner().test();
   

  1. 匿名内部类本质
  • 匿名内部类是定义在外部类的局部位置,比如方法中,并且没有类名,同时还是一个对象
/**
* 基于接口的匿名内部类
* 
* @author Spring-_-Bear
* @date 2021-12-12 08:50
*/
public class C02 
   public static void main(String[] args) 
       // 方式1
       I03 i03 = new I03() 
           @Override
           public void cry() 
               System.out.println("呜呜呜~~~");
           
       ;
       i03.cry();
       // 匿名内部类的类名:I03
       System.out.println(i03.getClass());
   
   
   // 方式2
   new I03() 
           @Override
           public void cry(韩顺平循序渐进学Java零基础 第01-08章

韩顺平循序渐进学Java零基础 第01-08章

韩顺平循序渐进学Java零基础 第24章 零基础学MySQL

韩顺平循序渐进学Java零基础 第12章 异常

韩顺平循序渐进学Java零基础 第27章 正则表达式

零基础 快速学Java韩顺平 笔记整理(持续更新)