【私人向】Java复习笔记

此笔记学习于慕课网：Java入门第一季-第三季，想学的可以点击链接进行学习，笔记仅为私人收藏

建议学习时间：2-3天（极速版）

数据类型

• 基本数据类型存的是数据本身

• 引用类型变量（class、interface、数组）存的是数据的空间地址

自动类型转换

• 目标类型能与源类型兼容
• 目标类型大于源类型

强制类型转换

• 丢失数据（不 四舍五入）

常量

• 语法：final 常量名 = 值;
• 一般大写

注释

/**
 * 这是文档注释
 * @author laorenyang
 * @version v1.0
 */


/*
 * 这是多行注释
 * aaa
 * bbb
 */
 
 //这是单行注释

怎么生成API文档

• 我们可以通过javadoc命令从文档注释中提取内容，生成程序的API帮助文档
• 使用javadoc标记

运算符

• 比较运算符：比较后的值是布尔值
• 逻辑运算符
• 条件运算符 ?: String str = (8>5) ? "8>5" : "8 <= 5"

Scanner类 java.util

数组

• 声明数组

int[] scores;
int  height[];

• （不规则数组）

int[][] num=new int[3][];
num[0] = new int[3];
num[1] = new int[2];
num[2] = new int[1];

• 分配空间

scores = new int[5];

int[] scores = new int[5]

int[] scores = {1, 2};
int[] scores = new int[]{1, 2};

• 长度

数组名.length

Arrays类 java.util 操作数组

• Arrays.sort();
• Arrays.toString();

foreach ：for的简版

for(int num:nums) {
    System.out.println(num);
}

方法（method）

• 使用类中的方法
• 方法的重载 一个类中有多个方法名相同的方法
• 判断方法重载的依据：

1. 必须是在同一个类中
2. 方法名相同
3. 方法参数的个数、顺序或类型不同
4. 与方法的修饰符或返回值没有关系

随机数 Math.random()

0-1浮点数

类

• 模板 抽象信息 描述
• 类 对象的类型，一个模子
• 一个类可以对应多个对象

对象

具体的信息

• 对象的属性：对象有什么 特征
• 对象的方法：对象执行的操作

类

定义类

• 类的组成：属性和方法

1. 定义一个类
2. 属性（有什么）
3. 方法（干什么）

对象

1. 创建一个对象 ： 对一个类进行实例化 new Telphone() （new + 构造方法()）
2. 使用对象： 引用对象的属性：对象名.属性；引用对象的方法：对象名.方法名()

属性（实例变量）

• float型变量赋值时需加f，否则默认浮点数是double型

成员变量和局部变量

成员变量

• 在类中定义
• 被本类的方法，及其他跟本类相关的类中的方法使用

局部变量

在方法中定义

区别

• 初始值不同：成员变量有默认的初始值，局部变量没有
• 两类变量同名时，局部变量具有更高的优先级（就近原则）

构造方法

无返回类型 （不写）

• 构造方法的重载
• 构造方法不但可以给对象的属性赋值，还可以保证给对象的属性赋一个合理的值

static 静态

静态变量

• 该类所有对象所共享，属于整个类（所以在系统第一次使用该类时，就会为其分配内存空间直至该类被卸载，才进行资源回收）
• 可用类名来进行访问（或者对象名，推荐前者）
• 修饰变量、方法、代码块

静态方法

• 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员
• 可以通过在方法里面 创建类的对象，然后通过对象来访问非静态变量，形式：hello.name
• 在普通方法中两者皆可直接调用
• 同理，静态方法中不能直接调用非静态方法，可以通过对象来访问非静态方法，形式：hello.show()

静态内部类

1. 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
2. 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
3. 创建静态内部类的对象时，不需要外部类的对象，可以直接创建内部类 对象名= new 内部类();

静态初始化块

• 静态初始化块只在类加载时执行一次，且只能给静态变量赋值

初始化执行顺序

• 静态初始化块 -> 初始化块 -> 构造方法

面向对象

三大特性

• 封装 继承 多态

封装

• 修改属性的可见性：设为private
• 创建getter/setter方法：用于属性的读写
• 在getter/setter方法中加入属性控制语句：对属性值的合法性进行判断

包

• 全小写
• protected 子类也可以用

this关键字

• 代表当前对象
• 当前对象的属性、方法
• 封装对象属性时可用

内部类

• 内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
• 内部类的主要作用如下：

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，[不允许同一个包中的其他类访问该类？？？（那怎么可以用public修饰）]
2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据
3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

成员内部类

• 使用外部类对象创建内部类对象 Inner i = o.new Inner();
• 成员内部类的 .class 文件总是这样：外部类名$内部类名.class
• 外部类是不能直接使用内部类的成员和方法滴
• 可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。
• 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。这个外部类的对象的成员变量 Outer.this.name （静态内部类不用写this）

静态内部类

• static修饰

方法内部类

• 内部类定义在外部类的方法中
• 由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。
• 调用方法内部类的办法是：在所在的外部类方法里调用，在其他类调用该内部类方法时调用所在外部类方法即可

继承

• 类与类的一种关系 is a 的关系
• 一个类只有一个父类
• 子类不能继承父类中private属性的东西

方法的重写

• 返回值类型、方法名、参数类型及个数要一致

继承的初始化顺序

• 初始化父类再初始化子类（构造方法）
• 先执行初始化对象中属性，再执行构造方法的初始化

final

• 最终的
• 修饰类、方法、属性和变量
• 修饰类，该类不允许被继承
• 修饰方法，该方法不允许被覆盖（重写）
• 修饰属性，该属性不会默认进行初始化，属性值被赋一次后不能变化，只能在一开始或者构造函数里进行人工的初始化。
• 修饰变量，变量的值只能赋一次值，即声明的时候赋值，常量

属性与变量的区别？

super

• 在对象的内部使用，可以代表父类对象

• 调用父类的属性：super.age

• 调用父类的方法：super.eat()

• 子类的构造的过程当中必须调用其父类的构造方法，会有隐式的写有

• 如果子类的构造方法没有显示调用父类的构造方法，则系统默认调用父类无参的构造方法

• 如果显示的调用构造方法，必须在子类的构造方法的第一行

• 如果子类构造方法中既没有显式的调用父类的构造方法，而父类又没有无参的构造方法，则编译出错!

Object类

• 所有类的父类

toString()方法

• 返回对象的哈希code码（对象地址字符串）
• 可重写

equals()方法

• 比较的是对象的引用是够指向同一块内存地址 Dog dog = new Dog()
• 一般我们想比较的是两个对象的值是否一致，可重写
• == 判断数据值是否相同，若判断引用值是否相同则也是比较地址值
• 类对象obj.getClass()与类的对象obj，前者关注例如姓名年龄，后者关注阿宝20岁

多态

• 对象具有多种形态
• 继承是多态的实现基础

引用多态

• 引用的指向：可以是本类，也可以是子类
• 父类的引用可以指向本类或子类的对象

方法多态

• 调用的方法：可以是本类，也可以是本类重写父类的方法或者是继承的方法

引用类型转换

• 小类型到大类型的转换（自动类型）
• 大类型到小类型的转换（强制类型）

强制类型转换

• instanceof运算符：避免类型转换的安全性问题

抽象类

• 用abstract修饰

• 限制规定子类实现某些方法，但不关注里面的内容

• abstract定义抽象类 或 抽象方法

• 包含抽象方法的类必须是抽象类

• 抽象类中可以有或者没有抽象方法

• 抽象类不能直接创建，可以定义引用变量？？

• 抽象方法没有{}，直接以;结束

接口

• 特殊的类，由全局常量（public static final）和公共的抽象方法（public avstract）所组成
• 定义了类所需要遵守的规范
• 定义接口：使用interface关键字（不是class）
• 接口的修饰符推荐是public
• 接口可继承多个父接口

使用接口

• implements

• 一个类可以实现多个接口

• 继承父类要在实现接口之前，即：extends 父类 implements 接口1，接口2...

• 接口名 I打头

• 接口的引用可以使用实现接口功能的类

• 可以与匿名内部类配合使用

使用匿名内部类来实现接口

• 没有名字的内部类

Interface i = new Interface(){
    public void method(){
        System.out.println("匿名内部类实现接口的方式")；
    }
}；

UML简介

• Unified Modeling Language 统一建模语言
• 模型化软件开发的图形语言

常用UML图

用例图

• 描述系统中出现的角色需要什么功能 角色与系统的功能联系起来

序列图（the seque diagram)

角色和计算机内存中对象的关系，及顺序怎样

类图（The Class Diagram）

业务逻辑和结构性的信息
类和类的关系，及里面的属性

• • 私有 + 共有

• 数据模型分析

• 业务模型分析

• 显示和流程分析

异常与异常处理

• 图

处理异常

• try-catch
• try-catch-finally

try {
       //代码
    }catch(InputMismatchException e){
      //处理
        
    }catch(ArithmeticException e){
     //处理
        
    }
}finally{
    //最终将要执行的一些代码，在catch块return之后执行
}

多重catch块注意事项

• 顺序问题：从小到大， 子类到父类
• 就近匹配

异常抛出及自定义异常

• throw 将产生的异常抛出（方法体内，动作）
• throws 方法名和参数之后，声明要抛出何种类型的异常（声明）

自定义异常

class 自定义异常类 extends 异常类型{
    
}

异常链

例：一个异常包装另一个抛出的异常后再抛出

经验总结

• 在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
• 处理潜在的异常
• 尽量去处理异常，而不是仅仅打印异常（printStackTrace()）
• 尽量添加finally语句块去释放占用的资源，尤其是有网络连接，和连接数据库的情况下

字符串

• 一旦一个字符串在内存中创建，则这个字符串将不可改变。如果需要一个可以改变的字符串，我们可以使用StringBuffer或者StringBuilder（后面章节中会讲到）

• 每次 new 一个字符串就是产生一个新的对象，即便两个字符串的内容相同，使用 ”==” 比较时也为 ”false”

String s1 = new String("imooc");
String s2 = new String("imooc");

• imooc为常量字符串，多次出现时会被编译器优化，只创建一个对象

String s1 = "imooc";
String s2 = "imooc";

• s1是变量，s4在运行时才知道具体值，所以s3和s4是不同的对象

public class HelloWorld {
    public static void main(String[] args) {
		String s1 = "imooc";
		String s2 = "imooc";
        
        //定义字符串s3，保存“I love”和s1拼接后的内容
	    String s3 = "I love" + s1;	 
		
        // 比较字符串s1和s2
		// imooc为常量字符串，多次出现时会被编译器优化，只创建一个对象
		System.out.println("s1和s2内存地址相同吗？" + (s1 == s2));
        
        //比较字符串s1和s3
		System.out.println("s1和s3内存地址相同吗？" + (s1 == s3));

		String s4 = "I love" + s1;
         //比较字符串s4和s3
		// s1是变量，s4在运行时才知道具体值，所以s3和s4是不同的对象
		System.out.println("s3和s4内存地址相同吗？" + (s4 == s3));
	}
}

String类 - 常用方法

• length()
• indexof("") indexof('')
• substring(3, 7)
• split(" ")
• 使用 substring(beginIndex , endIndex) 进行字符串截取时，包括 beginIndex 位置的字符，不包括 endIndex 位置的字符

StringBuffer 与 StringBuilder（值可变的字符串存储）

• StringBuffer 是线程安全的，而 StringBuilder 则没有实现线程安全功能，所以性能略高。因此一般情况下，如果需要创建一个内容可变的字符串对象，应优先考虑使用 StringBuilder 类。
• append
• insert
• toString

常用类

包装类

• 让基本类型也具备对象的特性
• 包装类主要提供了两大类方法：

1. 将本类型和其他基本类型进行转换的方法
2. 将字符串和本类型及包装类互相转换的方法

转换

1. 装箱与拆箱

• parseInteger intValue

2. 字符串与其他

• String.valueOf、toString、parseXXX、XXX.valueOf()、+ ""

时间

表示时间 Date 和 SimpleDateFormat 类

Date

• java.util 包中的 Date 类：获取当前时间
• 使用 Date 类的默认无参构造方法创建出的对象就代表当前时间

SimpleDateFormat

• java.text 包中的 SimpleDateFormat类 :对日期时间进行格式化，如可以将日期转换为指定格式的文本，也可将文本转换为日期。
• 相当于在Date对象外包装一层格式
• 代码中的 “yyyy-MM-dd HH:mm:ss” 为预定义字符串， yyyy 表示四位年， MM 表示两位月份， dd 表示两位日期， HH 表示小时(使用24小时制)， mm 表示分钟， ss 表示秒

1. 使用 format() 方法将日期转换为指定格式的文本
2. 使用 parse() 方法将文本转换为日期： Date date = sdf.parse(day);

• df.format()成字符串 df.parse()成Date

注意事项

• 调用 SimpleDateFormat 对象的 parse() 方法时可能会出现转换异常，即 ParseException ，因此需要进行异常处理
• 使用 Date 类时需要导入 java.util 包，使用 SimpleDateFormat 时需要导入 java.text 包

处理时间 - Calendar 类

• java.util.Calendar 类 抽象类
• 可以通过调用 getInstance() 静态方法获取一个 Calendar 对象，此对象已由当前日期时间初始化，即默认代表当前时间，如 Calendar c = Calendar.getInstance();
• 通过调用get() 方法获取日期时间信息，参数为需要获得的字段的值， Calendar.Year 等为 Calendar 类中定义的静态常量。
• Calendar 类提供了getTime() 方法，用来获取 Date 对象，完成 Calendar 和 Date 的转换，还可通过 getTimeInMillis() 方法，获取此 Calendar 的时间值，以毫秒为单位。

使用 Math 类操作数据

• java.lang 包
• Math 类的所有方法都是静态方法
• round() random() floor() ceil()

集合框架

Collection

• 是List、Set和Queue接口的父接口

List接口及其实现类 - ArrayList

• 有序可重复 序列
• 数组序列：ArrayList 底层由数组实现
• 对象存入集合都变成Object类型，取出需要类型转换

增删改查

• add addAll get set remove removeAll
• Arrays.asList()

迭代器接口

• Iterator it = coursesToSelect.iterator();
• 依赖于某个集合存在

泛型

• 规定了某个集合只可以存放特点类型的对象，会在编译期间进行类型检查

   public List<Course> courses;

   public TestGneric(){
       this.courses = new ArrayList<Course>();
   }

• 泛型集合：泛型类型 泛型子类型
• 泛型集合中的限定类型不能使用基本数据类型

Set接口及其实现类——HashSet

• 元素无序且不重复（重复也会变为第一个），被称为集
• 没有set()方法，因为它是无序的，找不到索引
• 遍历Set中的元素只能用foreach或iterator方法，用不了get()方法
• 可以add(null)

Map和HashMap

• 映射关系，元素以键值对（key-value)的形式存储
• 键值对以Entry类型的对象实例形式存在
• key值不可重复，value值可以
• 支持泛型 Map<K, V>

增删

• put putAll
• remove

返回

• keySet() 返回key值的集合
• values() 返回value值的集合
• entrySet() 返回映射关系的集合

HashMap

• 基于哈希表实现
• 其中的Entry对象是无序排列的
• Key值和value值都可以为null，但是一个HashMap只能有一个key值为null的映射（key值不可重复）

Collection List Set

• contains（需要重写equals方法）

• containsAll

• set:hashCode + equals()

• 索引位置：indexOf lastIndexOf

Map

• containsKey() containsValue()

Collections 工具类

• sort() 排序

Comparable 与 Comparator

• Comparable 默认比较规则
• Comparator 临时比较规则

Comparable接口 可比较的

• 实现该接口的类：实例可比较大小，可进行自然排序（默认的比较规则）
• 需实现compare To()方法 + - ==

Comparator接口 比较工具接口

• 定义临时比较规则
• 其实现类需要实现compare()方法
• 可将其传递给Collection sort方法

Java集合框架

• Collection接口 | Collections工具箱
• Map接口 | Comparator接口
• Comparable接口

字符串的比较与整数的比较不同 如 1000 与 233

综合练习- 洗牌发牌小程序

功能描述

1. 创建一副扑克牌：

• 包括四种花色（黑桃、红桃、梅花、方片）
• 十三种点数：2-10，J、Q、K、A，不考虑大小王

2. 创建两名玩家

• 玩家至少要有ID、姓名、手牌等属性，手牌为扑克牌的集合

3. 洗牌

• 将之前创建的“一副扑克牌”打乱顺序

4. 发牌

• 将洗牌之后的扑克牌集合，从第一张开始，发给两名玩家，按照一人一张的方式，每人发两张

5. 游戏

• 比较两名玩家手中的扑克牌，规则为：取两人各自手中点数最大的牌进行比较，点数大的赢；若两人各自的点数最大的牌相等，

初步设想

1. 创建一个player类设置玩家信息，其中手牌套用ArrayList类，手牌间比大小的方法重写Comprable接口中的compare to()方法
2. 创建一个poker类设置单张扑克牌信息，其中含有属性：String类的花色和String类的数值
3. 一副扑克牌用Set定义（HashSet）
4. 打乱顺序：直接利用Set是无序的这个特点来做，每次取出的元素都是不定的