Jdk-8:
认证第一场：
- Java基础
- Java数据类型
- 使用运算符和决策构造
- 创建和使用数组
- 使用循环构造器
- 使用方法和封装
- 使用继承
- 处理异常
- 使用Java API中选择的类
第一节：Java基础
- 变量
四种类型的变量：分别为实例变量（成员变量、非静态变量）、静态变量、局部变量和参数- 命名规则：
变量名区分大小写。变量的名称可以是任何合法标识符，一个由Unicode字母和数字组成的无限长度序列，以字母、美元符号“$”或下划线字符“_”开头。然而，习惯上，变量名总是以字母开头，而不是“$”或“_”。此外，根据惯例，美元符号字符从未使用过。您可能会发现在某些情况下，自动生成的名称将包含美元符号，但是您的变量名称应该始终避免使用它。下划线字符也有类似的约定;虽然从技术上讲，以“_”作为变量名的开头是合法的，但是不鼓励这样做。不允许使用空格。后续字符可以是字母、数字、美元符号或下划线字符。约定(和常识)也适用于此规则。当为变量选择名称时，使用完整的单词而不是模糊的缩写。这样做将使您的代码更容易阅读和理解。在许多情况下，它还会使您的代码自文档化;例如，名为cadence、speed和gear的字段要比缩写形式(如s、c和g)直观得多。还要记住，您选择的名称不能是关键字或保留字。如果您选择的名称只包含一个单词，请将该单词全部用小写字母拼写。如果由一个以上的单词组成，则将后面每个单词的第一个字母大写。名称gearRatio和currentGear是这种约定的主要例子。如果您的变量存储一个常量值，比如静态final int NUM_GEARS = 6，那么约定会稍微改变，将每个字母大写，然后用下划线分隔后面的单词。按照惯例，下划线字符永远不会在其他地方使用。
- main方法
- class类的基本构造：属性、构造器、方法
- 创建和使用包，以及导包和静态导入
- Java特性：
- 简单的
- 面向对象的
- 分布式
- 多线程
- 动态
- 体系结构中立的
- 可移植的
- 高性能
- 健壮的
- 安全
- 面向编程的概念
- 对象是什么？
对象是由相关状态和行为组成的软件包。软件对象通常用于建模在日常生活中发现的真实对象
- 类是什么？
类是创建对象的蓝图或原型。定义一个类，它对真实对象的状态和行为建模。它有意将重点放在基础上，展示了即使是一个简单的类也可以清楚地建模状态和行为。
- 继承是什么？
面向对象编程允许类从其他类继承常用的状态和行为。
- 接口是什么？
接口是类与外部世界之间的契约。当一个类实现一个接口时，它承诺提供该接口发布的行为。（注意功能函数式接口）
- 包是什么？
包是一个名称空间，用于以逻辑方式组织类和接口。将代码放入包中可以使大型软件项目更容易管理。
第2节:处理Java数据类型
- 变量和属性的使用
- 对象引用变量和基本变量的区别点这里
- 知道如何读写对象字段
- 多重继承：
- 声明成员变量：
type name;
- 创建对象
Point originOne = new Point(23, 94);
- 使用对象
Rectangle rectOne = new Rectangle(originOne, 100, 200);
所有类都至少有一个构造函数。如果类没有显式声明any, Java编译器将自动提供一个无参数构造函数，称为默认构造函数。这个默认构造函数调用类父类的无参数构造函数，如果类没有其他父类，则调用对象构造函数。如果父类没有构造函数(对象有)，编译器将拒绝该程序。
- 解释对象的生命周期(创建、“通过重新分配取消引用”和垃圾收集)。
这将调用将origin初始化为originOne的矩形构造函数之一。此外，构造函数将宽度设置为100，高度设置为200。现在同一个点对象有两个引用——一个对象可以有多个引用，如上图所示:代码如下图：
public class Rectangle {
public int width = 0;
public int height = 0;
public Point origin;
// four constructors
public Rectangle() {
origin = new Point(0, 0);
}
public Rectangle(Point p) {
origin = p;
}
public Rectangle(int w, int h) {
origin = new Point(0, 0);
width = w;
height = h;
}
public Rectangle(Point p, int w, int h) {
origin = p;
width = w;
height = h;
}
// a method for moving the rectangle
public void move(int x, int y) {
origin.x = x;
origin.y = y;
}
// a method for computing the area of the rectangle
public int getArea() {
return width * height;
}
}
第3节:使用运算符和决策构造
使用Java运算;使用括号覆盖运算符优先级。
当相同优先级的运算符出现在同一个表达式中时，必须使用规则来决定先求哪个值。除赋值运算符外，所有的二元运算符都是从左向右求值的;赋值运算符从右向左求值
算数运算操作：
一元运算符：
递增/递减运算符可以应用于操作数之前(前缀)或之后(后缀)。+ +代码的结果;+ +的结果;两者的结果都是递增1。唯一的区别是前缀版本(c++ result)计算为递增值，而后缀版本(result++)计算为原始值。如果只是执行简单的递增/递减，那么选择哪个版本并不重要。但是，如果您在较大的表达式中使用这个操作符，您所选择的操作符可能会产生显著的差异。
等式、关系运算符和条件运算符
条件操作符
类型比较操作符instanceof
class InstanceofDemo {
public static void main(String[] args) {
Parent obj1 = new Parent();
Parent obj2 = new Child();
System.out.println("obj1 instanceof Parent: "
+ (obj1 instanceof Parent));
System.out.println("obj1 instanceof Child: "
+ (obj1 instanceof Child));
System.out.println("obj1 instanceof MyInterface: "
+ (obj1 instanceof MyInterface));
System.out.println("obj2 instanceof Parent: "
+ (obj2 instanceof Parent));
System.out.println("obj2 instanceof Child: "
+ (obj2 instanceof Child));
System.out.println("obj2 instanceof MyInterface: "
+ (obj2 instanceof MyInterface));
}
}
class Parent {}
class Child extends Parent implements MyInterface {}
interface MyInterface {}
输出结果
obj1 instanceof Parent: true
obj1 instanceof Child: false
obj1 instanceof MyInterface: false
obj2 instanceof Parent: true
obj2 instanceof Child: true
obj2 instanceof MyInterface: true
switch支持byte，short，char，int基本数据类型，也支持枚举类型，String类，以及包装类，Character，Byte，Short，Integer
警告：String是java7+以后支持的。
第4节：数组（一维和多维，以及jdk8+的并行排序）
数组下标从0开始，
声明数组：
int[] anArray;
创建数组：
anArray = new int[10];
实例化数组：
anArray[0] = 100;
anArray[1] = 200;
anArray[2] = 300;
或者使用这种方式：
int[] anArray = {
100, 200, 300,
400, 500, 600,
700, 800, 900, 1000
};
多维数组声明：
String[][] names = {
{"Mr. ", "Mrs. ", "Ms. "},
{“Smith”, “Jones”}
};
警告：java.util.Arrays提供了几个便利的方法：排序，比较，填充，以及jdk8以后支持的并行排序。
第五节：循环
while和do-while
do-while和while之间的区别是do-while计算循环底部的表达式，而不是顶部的表达式。因此，do块中的语句总是至少执行一次，
class WhileDemo {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
class DoWhileDemo {
public static void main(String[] args){
int count = 1;
do {
System.out.println("Count is: " + count);
count++;
} while (count < 11);
}
}
for循环
for (initialization; termination;
increment) {
statement(s)
}
initialization：初始化表达式初始化循环;它在循环开始时执行一次。
termination：当终止表达式的计算结果为false时，循环终止。
increment：每次循环迭代后调用增量表达式;此表达式可以完全接受值的递增或递减
或者使用增强for循环：
class EnhancedForDemo {
public static void main(String[] args){
int[] numbers =
{1,2,3,4,5,6,7,8,9,10};
for (int item : numbers) {
System.out.println("Count is: " + item);
}
}
}
break和continue和return
break的两种策略：
未带标记：只终止for循环
class BreakDemo {
public static void main(String[] args) {
int[] arrayOfInts =
{ 32, 87, 3, 589,
12, 1076, 2000,
8, 622, 127 };
int searchfor = 12;
int i;
boolean foundIt = false;
for (i = 0; i < arrayOfInts.length; i++) {
if (arrayOfInts[i] == searchfor) {
foundIt = true;
break;
}
}
if (foundIt) {
System.out.println("Found " + searchfor + " at index " + i);
} else {
System.out.println(searchfor + " not in the array");
}
}
}
带标记：（终止标记的代码块）
class BreakWithLabelDemo {
public static void main(String[] args) {
int[][] arrayOfInts = {
{ 32, 87, 3, 589 },
{ 12, 1076, 2000, 8 },
{ 622, 127, 77, 955 }
};
int searchfor = 12;
int i;
int j = 0;
boolean foundIt = false;
search:
for (i = 0; i < arrayOfInts.length; i++) {
for (j = 0; j < arrayOfInts[i].length;
j++) {
if (arrayOfInts[i][j] == searchfor) {
foundIt = true;
break search;
}
}
}
if (foundIt) {
System.out.println("Found " + searchfor + " at " + i + ", " + j);
} else {
System.out.println(searchfor + " not in the array");
}
}
}
continue：跳过当前的执行，执行下一个
return：return语句退出当前方法，控制流返回方法调用的位置。return语句有两种形式:一种返回值，另一种不返回值。要返回值，只需将值(或计算值的表达式)放在return关键字之后
第6节：使用方法和封装
方法定义6个要求前提：
- 修饰符，如public、private和其他稍后将介绍的修饰符。
- 返回类型方法返回值的数据类型，如果方法不返回值，则为void。
- 字段名的规则也适用于方法名，但约定略有不同。
- 圆括号中的参数列表是以逗号分隔的输入参数列表，前面是它们的数据类型，后面是圆括号()。如果没有参数，则必须使用空括号。
- 异常列表。
- 方法主体位于方法代码的大括号之间，包括局部变量的声明。
方法签名：
定义:方法声明的两个组件包括方法签名—方法的名称和参数类型。
calculateAnswer(double, int, double, double)变量
- 实例变量（非静态）
- 类变量（静态）
- 本地变量
- 参数
嵌套类
嵌套类分为两类:静态类和非静态类。声明为静态的嵌套类称为静态嵌套类。非静态嵌套类称为内部类。
class OuterClass {
…
static class StaticNestedClass {
…
}
class InnerClass {
…
}
}
嵌套类是其封闭类的成员。非静态嵌套类(内部类)可以访问封闭类的其他成员，即使它们声明为私有。静态嵌套类不能访问封闭类的其他成员。作为外层类的成员，嵌套类可以声明为private、public、protected或package private。(请记住，外部类只能声明为public或package private。)
静态嵌套类与它的外部类(和其他类)的实例成员进行交互，就像任何其他顶级类一样。实际上，静态嵌套类在行为上是一个顶级类，它被嵌套在另一个顶级类中以方便打包。
静态嵌套类使用的语法：
OuterClass.StaticNestedClass nestedObject =
new OuterClass.StaticNestedClass();
内部类使用语法：
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
警告：
强烈反对序列化内部类，包括本地类和匿名类。当Java编译器编译某些构造时，例如内部类，它创建合成构造;这些类、方法、字段和其他构造在源代码中没有对应的构造。合成结构使Java编译器能够实现新的Java语言特性，而无需更改JVM。然而，在不同的Java编译器实现中，合成结构可能会有所不同，这意味着.class文件也可能在不同的实现中有所不同。
第7节 : 继承（派生）
派生自另一个类的类称为子类(也称为派生类、扩展类或子类)。派生子类的类称为超类(也称为基类或父类)。
除了没有超类的对象之外，每个类都有且只有一个直接超类(单继承)。在没有任何其他显式超类的情况下，每个类都是对象的隐式子类。
类可以从类派生的类派生出类，也可以从类派生出的类派生出类，以此类推，最终从最顶层的类Object派生出类。这样的类据说是继承链中所有类的后代，继承链一直延伸到Object。
使用继承转换为父类对象为了避免出错可以
使用instanceof操作符对特定对象的类型进行逻辑测试。这可以避免由于不正确的转换而导致的运行时错误
在子类中，可以重载从超类继承的方法。这样的重载方法既不隐藏也不覆盖超类实例方法——它们是子类特有的新方法。
子类的构造方法：
如果构造函数没有显式调用超类构造函数，Java编译器将自动向超类的无参数构造函数插入一个调用。如果超类没有无参数构造函数，则会得到编译时错误。Object确实有这样的构造函数，所以如果Object是惟一的超类，那么就没有问题。
第八节：处理异常
- 三种异常：
- 检查异常
- 错误
- 运行异常
第9节：选择合适的API（只提lamda表达式）
Lambda表达式的理想用例方法
1:创建方法,寻找一个特点相匹配的成员方法
2:创建更广义的搜索方法方法
3:指定搜索条件代码在本地类方法
4:指定搜索条件的代码在一个匿名类方法
5:指定搜索条件代码与Lambda表达式的方法
6:使用标准的功能接口与Lambda表达式的方式
7:在整个应用程序方法
8中使用Lambda表达式:更广泛地使用泛型方法方法
9:在GUI应用程序语法中使用接受Lambda表达式作为参数的聚合操作，Lambda表达式访问封闭范围的局部变量、目标类型、目标类型和方法参数序列化