1.Java是一门高级、面向对象、跨平台编程语言。

2.JDK安装，环境配置。

3.Java运行步骤:a.java —>编译器—>a.class—>解释器—>运行a程序

4.两个常见的问题
Java源文件命名方式问题：一个class的名称为Simple，Java源文件名称可以不是Simple.java么？
答案是可以的，但是前提是该类不是public修饰符。

问题：一个Java源文件中可以写多个类么？
答案是可以的，一个类生成一个class文件

5.JDK，JRE和JVM的区别
JVM(JAVA虚拟机)，实际不存在，作用：加载代码，验证代码，执行代码，提供运行环境
JRE(JVM的实现)，实际存在，JRE = JVM + Jar包 (Java运行环境)
JDK(JAVA程序开发包)，实际存在，JDK = JRE + 开发工具包(java,javac.javadoc等)

6.JVM体系结构

7.Java变量
三种变量：实例变量、局部变量、静态变量
局部变量在方法主体内声明，只能作用于该方法中，不能用static关键字定义
实例变量在方法主体外声明，不能用static关键词定义，不在实例中共享
静态变量在方法主体外声明，内存仅分配一次，在所有实例中共享

8.数据类型
基本数据类型：boolean、byte、char、short、int、long、float、double
boolean 只存储 true、false byte 取值-128—127 float声明数值后加f
引用数据类型：Class、Interfaces、Arrays

9.Java关键词

10.Java注释
单行注释 //
多行注释
/*
这
是
多行注释
/
文档注释用于创建文档API。要创建文档API，您需要使用javadoc工具。
/*
这
是
文档注释
*/

11.Java if/else语句
条件判断

if(表达式1) {
    	语句块1;
	} else if(表达式2) {
   	 语句块2;
	...
	} else if(表达式n) {
   	 语句块n;
	} else {
    	语句块n+1;
	}

12.Java switch语句
条件判断

switch(表达式){
    case 值1:
    	语句1;
    	break;
    case 值2：
    	语句2；
    	break;
    ......
    default:
    	语句n;
    	break;
}

13.Java for while do-while
程序循环执行

Java for-each					
for(类型 变量:数值){
    循环体
}

public class Demo {

    public static void main(String[] args) {
        //带标签的for循环
        aa: //标签名
        for(int i=1;i<=3;i++){
            bb:
            for(int j=1;j<=3;j++){
                if(i==2&&j==2){
                    break aa; //跳出到指定标签
                }
                System.out.println(i+" "+j);
            }
        }
    }
}

while(条件表达式) {
    	语句块;

}

do {
语句块；
}while(条件表达式)

14.Java break语句，break 用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到 break，系统将完全结束该循环，开始执行循环之后的代码。

15.Java continue语句，continue 是忽略循环语句的当次循环。注意：continue 语句只能用在 while 语句、for 语句或者 foreach 语句的循环体之中，在这之外的任何地方使用它都会引起语法错误。

16.Java面向对象编程
1.对象：对象拥有属性和方法 例如：狗是对象，因为它具有颜色，名称，品种等状态，以及诸如摇尾巴，吠叫，进食等行为。
2.类：类是对象集合，不占用空间，例如动物类。
3.继承：对象获取父对象的属性和方法，提供代码可重用性，实现运行时多态。
4.多态：一项任务不同方法去执行，例如绘画，三角形、正方形、六边形等。
5.抽象：隐藏实现的内部细节并显示功能，使用抽象类和接口来实现。
6.封装：将代码和数据绑定到一个单元，Java类就是封装示例，JavaBean是完全封装
7.耦合：一个类包含另一个类的详细信息，属于强耦合
8.内聚：内聚力弱的方法会将任务分为几个部分。java.io软件包是具有高度凝聚力的软件包，因为它具有与I/O相关的类和接口。
9.关联：一对一，一对多，多对一，多对多
10.聚合：
11.组合

17.Java命名规范
该名称不得包含任何空格。
名称不能以特殊字符开头，例如＆（＆）， （ 美 元 ） ， （ 下 划 线 ） 。 类 应 该 以 大 写 字 母 开 头 。 类 应 该 是 一 个 名 词 ， 例 如 颜 色 ， 按 钮 ， 系 统 ， 线 等 。 建 议 使 用 完 整 的 单 词 ， 而 不 是 使 用 缩 写 词 。 接 口 应 该 以 大 写 字 母 开 头 。 接 口 应 该 是 一 个 形 容 词 ， 例 如 R u n n a b l e ， R e m o t e ， A c t i o n L i s t e n e r 。 建 议 使 用 完 整 的 单 词 ， 而 不 是 使 用 缩 写 词 。 方 法 应 该 以 小 写 字 母 开 头 。 方 法 应 该 是 一 个 动 词 ， 例 如 m a i n ( ) ， p r i n t ( ) ， p r i n t l n ( ) 。 如 果 名 称 包 含 多 个 单 词 ， 请 以 小 写 字 母 开 头 ， 然 后 以 大 写 字 母 开 头 ， 例 如 a c t i o n P e r f o r m e d ( ) 。 变 量 应 以 小 写 字 母 开 头 ， 例 如 i d ， n a m e 。 变 量 不 能 以 特 殊 字 符 开 头 ， 例 如 ＆ （ ＆ ） ， （美元），_（下划线）。 类应该以大写字母开头。 类应该是一个名词，例如颜色，按钮，系统，线等。 建议使用完整的单词，而不是使用缩写词。 接口应该以大写字母开头。 接口应该是一个形容词，例如Runnable，Remote，ActionListener。 建议使用完整的单词，而不是使用缩写词。 方法应该以小写字母开头。 方法应该是一个动词，例如main()，print()，println()。 如果名称包含多个单词，请以小写字母开头，然后以大写字母开头，例如actionPerformed()。 变量应以小写字母开头，例如id，name。 变量不能以特殊字符开头，例如＆（＆）， （美元），（​下划线）。类应该以大写字母开头。类应该是一个名词，例如颜色，按钮，系统，线等。建议使用完整的单词，而不是使用缩写词。接口应该以大写字母开头。接口应该是一个形容词，例如Runnable，Remote，ActionListener。建议使用完整的单词，而不是使用缩写词。方法应该以小写字母开头。方法应该是一个动词，例如main()，print()，println()。如果名称包含多个单词，请以小写字母开头，然后以大写字母开头，例如actionPerformed()。变量应以小写字母开头，例如id，name。变量不能以特殊字符开头，例如＆（＆），（美元），（下划线）。
如果名称包含多个单词，请以小写字母开头，后跟一个大写字母，例如firstName，lastName。
避免使用单字符变量，例如x，y，z。
包应该是小写字母，例如java，lang。
如果名称包含多个单词，则应使用点号（.）分隔，例如java.util，java.lang。
常量应该使用大写字母，例如RED，YELLOW。
如果名称包含多个单词，则应使用下划线（）分隔，例如MAX_PRIORITY。
它可以包含数字，但第一个字母不能是数字。

18.Java对象和类
Java对象拥有属性和方法
在类内部，方法外部创建的变量称为实例变量。实例变量在编译时不占用内存。创建对象或实例时，它将在运行时分配内存。这就是为什么它被称为实例变量的原因。
Java中有3种初始化对象的方法。
通过引用进行初始化
通过方法进行初始化
通过构造函数初始化
Java创建对象。分别有：
通过new 关键字
通过newInstance() 方法
通过clone() 方法
通过反序列化
通过工厂方法

19.Java构造方法
构造方法类似方法中的代码块，创建对象时构造值，构造方法是一种特殊的方法，用于初始化对象，每次使用new() 关键字创建对象时，都会至少调用一个构造方法。有两种类型，无参构造和有参构造。
1.构造方法名和类名一致
2.不能返回声明类型
3.不能是抽象、静态、最终、同步
4.我们可以在Java定义private，protected，public或default修饰的构造方法。
Java中的构造方法重载是一种具有不同参数列表的构造方法的技术。它们的排列方式使每个构造方法执行不同的任务。编译器通过列表中的参数数量及其类型来区分它们。

20.Java static
static关键字可以修饰：
变量（也称为类变量）
方法（也称为类方法）
代码块
静态变量可用于引用所有对象的公共属性（每个对象不是唯一的），例如，员工的公司名称，学生的大学名称等。
静态变量在类加载时仅在类区域中分配一次内存。
如果让任何方法加上static关键字，则称为static静态方法。
静态方法属于类，而不是类的对象。
可以使用类名称直接调用静态方法，而无需创建类的实例。
静态方法可以直接访问静态数据成员并可以更改其值。
静态方法有两个主要限制：
静态方法不能使用非静态数据成员或直接调用非静态方法。
this和super关键字不能在静态上下文中使用。

21.Java this

22.Java继承
对象获取父对象的所有属性和方法，利于代码重用性和运行多态

class 子类 extends 父类{
字段和方法
}

在类的基础上，Java中可以有三种继承类型：单继承，多继承和分层继承。
在Java编程中，只有接口支持多重继承和混合继承。

23.Java聚合
如果类具有实体引用，则称为聚合。聚集表示HAS-A关系。
例如：Employee对象包含许多信息，例如id，name，emaid等。它还包含一个名为address的对象，该对象包含地址信息，例如省份，城市，地区，邮政编码等

class Employee{  
  	int id;  
  	String name;  
  	Address address;//Address是一个对象
	...  
}  

24.Java方法重载
一个类名称相同参数不同的多个方法
1.改变参数个数
2.改变参数类型
注意：在Java中，仅通过更改方法的返回类型无法进行方法重载。

25.Java方法重写
子类声明于父类相同的方法为方法重写

class Vehicle{
    //父类定义run方法
    void run(){
        System.out.println("车辆在跑...");
    }
}
//创建子类
class Bike2 extends Vehicle{
    //子类也定义了run方法，这样就对父类的run方法形成了方法覆盖
    void run(){
        System.out.println("自行车在跑...");
    }

    public static void main(String args[]){
        Bike2 obj = new Bike2();//创建子类对象
        obj.run();//调用方法
    }
}

1 可以覆盖静态方法吗？
不可以，静态方法不能被覆盖。可以通过运行时多态来证明。
2 为什么不能覆盖静态方法？

这是因为静态方法与类绑定，而实例方法与对象绑定。静态属于类区域，实例属于堆区域。
3 可以覆盖main方法吗？
不可以，因为main方法是静态方法。

26.Java super关键字
Java super是引用变量，用于引用父类对象，每当创建子类实例时会隐式创建父类实例，使用super进行父类实例的引用。
super可用于引用父类实例变量。
super可用于调用直接父类的方法。
super() 可用于调用直接父类构造方法。

27.Java final关键字
final关键字用于限制用户
变量定义为final，变量就不能修改了，称为常量
方法定义为final，方法不能覆盖，但可以继承
类定义为final，类不能继承
构造方法可以是final吗？
不可以，因为构造方法是不可能被继承的。

28.Java多态
不同的方式执行单个操作，通过方法重载和重写实现多态
如果Parent类的引用变量指向Child类的对象，则称为向上转换。
方法可以被覆盖，但是字段无法被覆盖，因此字段无法实现运行时多态。

29.静态绑定和动态绑定

30.Java instanceof

31.Java抽象类
用abstract关键字声明的类在Java中被称为抽象类。抽象类中可以包含抽象方法和非抽象方法。
实现抽象有两种方法
1.抽象类
2.接口
抽象类必须使用abstract关键字声明。
抽象类可以包含抽象和非抽象方法。
抽象类无法实例化。
抽象类也可以包含构造函数和静态方法。
抽象类可以包含final方法，这些final方法将限制子类无法更改方法的内容。

32.Java接口
实现抽象的机制，用于实现抽象和多重继承，只能有抽象方法，不能有方法实现，接口不能实例化
接口用于实现抽象。
通过接口，我们可以支持多重继承的功能。
接口可用于降低系统耦合。
使用interface关键词声明接口，所有方法中没有方法体，实现接口类必须实现接口的所有方法。

interface <interface_name>{  
    // 声明常量字段  
    // 声明抽象方法  
} 

接口的所有字段是public，static和final，而方法是public和abstract的。

类不支持多重继承，因为类方法可能存在歧义，接口支持多重继承，因为方法是由类来实现。
没有任何成员（字段或者方法）的接口称为标记接口

33.抽象类和接口的区别

简单来说，抽象类实现部分抽象（0~100％），而接口实现完全抽象（100％）。

34.Java访问修饰符

如果将任何类构造方法设置为私有，则不能从类外部创建该类的实例。

35.Java封装
通过将类的所有数据成员设为私有来在Java中创建一个完全封装的类，然后我们可以使用setter和getter方法来设置和获取其中的数据
通过封装仅提供setter或getter方法，可以将类设置为只读或只写。
封装为你提供了对数据的控制。假设你要设置的id值需要大于100，您可以在setter方法中编写逻辑。当然你也可以编写不将小于0的数值存储在setter方法中的逻辑。
封装是一种在Java中实现数据隐藏的好方法，因为其他类将无法通过私有数据成员访问数据。
封装类易于测试。
标准的IDE开发工具一般都提供了生成getter和setter手段。因此，使用Java创建封装类非常方便快捷。

36.Java数组
数组是具有连续存储位置的相似类型元素的集合。
一维数组
二维数组
在Java中使用了Collection集合，Collection可以自动扩容。
数组声明：arrayRefVar=new datatype[size];
int a[]={33,3,4,5};//声明、实例化、初始化

class Testarray1{
    public static void main(String args[]){
        int arr[]={33,3,4,5};
        //使用for-each循环 
        for(int i:arr)
            System.out.println(i);
    }
}

class Testarray2{
    //创建一个接收Java数组参数的方法 
    static void min(int arr[]){
        int min=arr[0];
        for(int i=1;i<arr.length;i++)
            if(min>arr[i])
                min=arr[i];
        System.out.println(min);
    }

    public static void main(String args[]){
        int a[]={33,3,4,5};//定义和实例化数组
        min(a);//传递数组参数
    }
}

二维数组：int[][] arr=new int[3][3];//有3行3列
//从一个数组拷贝数据到另一个数组的例子

class TestArrayCopyDemo {
    public static void main(String[] args) {
        //定义一个数组
        char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e', 'i', 'n', 'a', 't', 'e', 'd' };
        //定义另一个数组 
        char[] copyTo = new char[7];
        //从第一个数组拷贝到第二个数组
        System.arraycopy(copyFrom, 2, copyTo, 0, 7);
        //打印数组元素
        System.out.println(String.valueOf(copyTo));
    }
}

37.Java Object类
默认情况下，Object类是Java中所有类的父类。换句话说，它是Java的顶级类。
如果要引用其类型未知的任何对象，则Object类很有用。请注意，父类引用变量可以引用子类对象，称为向上转换。

38.Java对象克隆
对象克隆是创建一个对象的副本的方式。Object类的clone() 方法用于克隆对象。
java.lang.Cloneable接口必须由我们要建立其对象克隆的类实现。如果我们不实现Cloneable接口，则clone() 方法将抛出CloneNotSupportedException异常。

39.Java Math类

40.Java包装类
自动装箱和自动拆箱功能实现了将原始类型转换为对象类型，并将对象类型自动转换为原始类型。

41.Java递归
Java中的递归是一个过程，其中方法连续不断地调用自身。Java中调用自身的方法称为递归方法。

42.Java值传递和引用传递
如果值传递的是原始类型，则原始值是不会更改的。
在值传递的过程，如果传递的是对象类型，如果被调用的方法进行数据更改，则原始值会被更改。

43.Java javadoc工具
我们可以借助javadoc工具在Java中创建API文档 。如果需要生成API文档，我们在编写Java文件时，必须使用文档注释/**…* /来注释类，方法，构造方法，属性等信息。

44.Java对象和类的区别

45.Java方法重载和方法重写的区别

46.Java内部类
在类或接口内部声明的类，即嵌套类，进行逻辑分组，更具维护性和可读性，内部类可以访问外部类的所有属性和方法

47.Java成员内部类

48.Java静态嵌套类
静态嵌套类可以访问外部类（包括私有）的静态成员。
静态嵌套类无法访问非静态（实例）成员或方法。

49.Java局部内部类
在方法内部创建的类称为局部内部类。如果要调用局部内部类的方法，则必须在方法内部实例化这个类。

50.Java断言
断言（assert）是Java中的一条语句。它可以用来测试您对该程序的假设。

51.Java foreach循环(增强for循环)

class Demo{
    public static void main(String args[]){
        //声明数组
        int arr[]={12,13,14,44};
        //使用for-each循环遍历数组
        for(int i:arr){
            System.out.println(i);
        }
    }
}

52.Java可变参数
可变参数使用省略号(…)，即数据类型后的三个点

class Demo{

    static void display(String... values){
        System.out.println("display方法被执行");
    }

    public static void main(String args[]){

        display();//0个参数
        display("my","name","is","yiidian");//4个参数
    }
}

方法中只能有一个变量参数。
Java可变参数必须是最后一个参数。

53.Java自动装箱和自动拆箱
将原始数据类型自动转换为其等价的包装类型的操作称为自动装箱，而相反的操作称为自动拆箱。

54.Java枚举
一种数据类型，包含一组固定常量，可以用于一周中的几天（周日，周一，周二，周三，周四，周五和周六），方向（东、南、西、北），季节（春季，夏季，秋季，冬季）
所有常量都应使用大写字母。因此，我们用大写字母表示枚举常量。

class Demo{
    //在类内部定义枚举
    public enum Season { WINTER, SPRING, SUMMER, FALL }
    //main方法
    public static void main(String[] args) {
        //使用枚举
        for (Season s : Season.values())
            System.out.println(s);
    }
    	System.out.println("WINTER的value值是: "+Season.valueOf("WINTER"));
        	System.out.println("WINTER的索引是: "+Season.valueOf("WINTER").ordinal());
        	System.out.println("SUMMER的索引是: "+Season.valueOf("SUMMER").ordinal());
}

values() 方法返回一个包含枚举的所有值的数组
valueOf()方法返回给定常量枚举的值
ordinal() 方法返回枚举值的索引

55.Java注解
Java 语言中的类、方法、变量、参数和包等都可以被标注。
普通注解：
@Override：可确保子类方法覆盖父类方法。如果没有覆盖成功，则会发生编译错误。
@SuppressWarnings：用于禁止编译器发出的警告。
@Deprecated：表示此方法已弃用，因此编译器将显示警告。该注解会告诉用户它可能在将来的版本中删除。因此，最好不要使用此类方法。
元数据：
@Target：用于注解使用的位置。
@Retention：用于指定注解级别（作用范围）
@Inherited：将注解标记继承到子类
@Documented：包含在文档注释中

Java自定义注解就是开发者自己设计（定义）的注解。使用@interface来声明注解。
@interface MyAnnotation {}
标记注释：没有方法的注解称为标记注解。
单值注释：具有一个方法的注解称为单值注解
多值注释：具有多个方法的注解称为多值注解
RetentionPolicy作用范围RetentionPolicy.SOURCE指的是在编译过程中丢弃的源代码。在编译的class中将不可用。RetentionPolicy.CLASS引用.class文件，该文件可用于Java编译器，但不适用于JVM。注解包含在.class文件中。RetentionPolicy.RUNTIME是指可用于Java编译器和JVM的运行时。

56.Java泛型
类型明确推迟到对象创建或方法调用时再去明确的特殊类型
List strings = new ArrayList();
strings.add(“yiidian”);
String aString = strings.get(0);
可以看到，通过菱形语法（’<>’）可以将List内元素的类型限定为String类型。需要注意的是<>内的类型只能是引用类型，当然对于基本类型，可以使用对应的包装类型。
1.泛型只能存储一种类型的对象，它不允许存储其他对象，这样类型更加安全。
2.在泛型之前，我们需要强制类型转换，使用了泛型后，我们无需强制类型转换了。
3.在编译时进行检查，因此在运行时不会出现问题。好的编程策略表明，在编译时处理问题比运行时要好得多

57.Java匿名内部类
在Java中，没有名称的类称为匿名内部类。如果您必须重写类或接口的方法，则就可以使用它。Java匿名内部类可以通过两种方式创建：
类（可以是抽象的或具体类）。
接口

58.Java Number类
Java Number类提供了将数值转换为byte，double，float，int，long和short类型的方法。

59.Java String类
在Java中，String字符串是一个表示char值序列的对象。