1 Java入门

1.1 常用DOS命令

　　DOS:Microsoft Disk Operating System

1.2 环境变量的配置

Windows 10版本：

1）右键"计算机"->"属性"->"高级系统设置"->"环境变量"->"新建(系统变量中)"。

2）变量名输入JAVA_HOME，变量值输入JDK的安装目录C:\Program Files\Java\jdk1.8.0_191，"确定"。

3）选中path环境变量，"编辑"。在变量值的最前面，键入%JAVA_HOME%\bin;分号必须要写，选中该行，上移到最上方，点击确定。

4）重新打开黑窗口，任意目录下输入java -version。

1.3 标识符

命名规则： 硬性要求

标识符可以包含 英文字母26个(区分大小写) 、 0-9数字 、 $（美元符号） 和 _（下划线） 。

标识符不能以数字开头。

标识符不能是关键字。

1.4 数据类型

Java的数据类型分为两大类：

• 基本数据类型：包括 整数 、 浮点数 、 字符 、 布尔 。
• 引用数据类型：包括 类 、 数组 、 接口 。

Java中的默认类型：整数类型是 int 、浮点类型是 double 。

1.5 switch

　　首先计算出表达式（switch的括号中的）的值，和case依次比较，一旦有对应的值，就会执行相应的语句，遇到break就会结束。最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

 1  public static void main(String[] args) {
 2      int weekday = 6;
 3      switch(weekday) {
 4          case 1:
 5              System.out.println("星期一");
 6              break;
 7          case 2:
 8              System.out.println("星期二");
 9              break;
10          case 3:
11              System.out.println("星期三");
12              break;
13          case 4:
14              System.out.println("星期四");
15              break;
16          case 5:
17              System.out.println("星期五");
18              break;
19          case 6:
20              System.out.println("星期六");
21              break;
22          case 7:
23              System.out.println("星期日");
24              break;
25          default:
26              System.out.println("你输入的数字有误");
27              break;
28      }
29  }

　　switch语句中，表达式的数据类型，可以是byte，short，int，char，enum（枚举），JDK7后可以接收字符串。

　　case的穿透性：在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。

2 Java面向对象

2.1 面向对象的特性

• 封装：把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。
• 继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。
• 多态：多态性是指允许不同子类型的对象对同一消息作出不同的响应。分为编译时的多态性和运行时的多态性。其中方法重载是编译时的多态，方法重写实现的是运行时的多态性。

  运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：1. 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；2. 对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

• 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。

3 常用类

3.1 Scanner、Random

（1）Scanner

public Scanner(InputStream source) : 构造一个新的 Scanner ，它生成的值是从指定的输入流扫描的。

public int nextInt() ：将输入信息的下一个标记扫描为一个 int 值。

 Scanner sc = new Scanner(System.in);
 int i = sc.nextInt();

（2）Random

public Random()：创建一个新的随机数生成器。 ? public int nextInt(int n)：返回一个伪随机数，范围在 0 （包括）和 指定值 n （不包括）之间的int 值。

 Random r = new Random();
 int number = r.nextInt(10);

3.2 Arrays、Math

（1）Arrays

此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来 非常简单。

public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。

public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。

（2）Math

public static double abs(double a) ：返回 double 值的绝对值。

public static double ceil(double a) ：返回大于等于参数的最小的整数。

public static double floor(double a)：返回小于等于参数最大的整数。

public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)

3.3 String、StringBuilder

（1）String

• 构造方法：

public String(char[] value) ：通过当前参数中的字符数组来构造新的String。

public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。

• 功能方法：

  public int length () ：返回此字符串的长度。 public String concat (String str) ：将指定的字符串连接到该字符串的末尾。 public char charAt (int index) ：返回指定索引处的 char值。 public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。 public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。 public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。

• 转换功能的方法：

  public char[] toCharArray () ：将此字符串转换为新的字符数组。 public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。 public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。

  public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

（2）StringBuilder

• public StringBuilder()：构造一个空的StringBuilder容器。
• public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。

• public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
• public String toString()：将当前StringBuilder对象转换为String对象。

3.4 Object

（1） Object常见方法？

• toString、hashCode、equals、getClass
• clone、wait、notify、notifyAll、finalize

（2）为什么wait()与notify()设计在Object类中？

• 这些方法存在于同步synchronized中；
• 使用这些方法必须标识同步所属的锁；
• 锁可以是任意对象，所以任意对象调用方法一定定义在Object类中。

https://blog.csdn.net/maoziyang1996/article/details/87073397

3.5 Date

（1）Date： public long getTime() 把日期对象转换成对应的时间毫秒值。

（2）DateFormat：用于字符串和Date对象的相互转换。

public SimpleDateFormat(String pattern)

public String format(Date date)：将Date对象格式化为字符串。

public Date parse(String source)：将字符串解析为Date对象。

 // Date转换成字符串
 Date date = new Date();
 DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
 String str = df.format(date);   // 2008年1月23日
 ?
 // 字符串转换成Date
 DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
 String str = "2018年12月11日";
 Date date = df.parse(str);      // Tue Dec 11 00:00:00 CST 2018

（3）Calendar：抽象类，通过静态方法返回子类对象

 1  // get()
 2  Calendar cal = Calendar.getInstance();
 3  int year = cal.get(Calendar.YEAR);
 4  int month = cal.get(Calendar.MONTH) + 1;
 5  int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
 6  ?
 7  // set()
 8  cal.set(Calendar.YEAR, 2020);
 9  ?
10  // add()
11  cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
12  cal.add(Calendar.YEAR, -3); // 减3年
13  ?
14  Date date = cal.getTime();  // Tue Jan 16 16:03:09 CST 2018

3.6 System

• public static long currentTimeMillis()：返回以毫秒为单位的当前时间。
• public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

4 Collection

通用方法：

• public boolean add(E e)： 把给定的对象添加到当前集合中 。
• public void clear() :清空集合中所有的元素。
• public boolean remove(E e): 把给定的对象在当前集合中删除。
• public boolean contains(E e): 判断当前集合中是否包含给定的对象。
• public boolean isEmpty(): 判断当前集合是否为空。
• public int size(): 返回集合中元素的个数。
• public Object[] toArray(): 把集合中的元素，存储到数组中。

4.1 迭代器

 public static void main(String[] args) {     Collection<String> coll = new ArrayList<String>();     coll.add("串串星人");     coll.add("吐槽星人");     coll.add("汪星人"); ?     Iterator<String> it = coll.iterator();     while(it.hasNext()){ //判断是否有迭代元素         String s = it.next();//获取迭代出的元素         System.out.println(s);     } }

4.2 List

4.3 Set

（1）HashSet

（2）LinkedHashSet：它是链表和哈希表组合的一个数据存储结构。

4.4 Collections

（1）常用方法

• public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
• public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
• public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。(升序)
• public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。

（2）Comparator

 ArrayList<String> list = new ArrayList<String>();
 list.add("cba");
 list.add("aba");
 list.add("sba");
 list.add("nba");
 //排序方法  按照第一个单词的降序
 Collections.sort(list, new Comparator<String>() {
     @Override
     public int compare(String o1, String o2) {
         return o2.charAt(0) - o1.charAt(0);
     }
 });

（3）Comparable和Comparator两个接口的区别

Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

5 Map

当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，需要重写键的hashCode和equals()方法。

• HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。
• LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；
• Hashtable：线程安全的集合，Hashtable的子类Properties依然活跃在历史舞台。（Properties集合是一个唯一和IO流相结合的集合）。

常用方法：

• public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
• public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
• public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
• boolean containsKey(Object key) 判断集合中是否包含指定的键。
• public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
• public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

 HashMap<String, String> map = new HashMap<String,String>();
 map.put("胡歌", "霍建华");
 map.put("郭德纲", "于谦");
 map.put("薛之谦", "大张伟");
 ?
 Set<String> keys = map.keySet();
 for (String key : keys) {
     String value = map.get(key);
     System.out.println(key+"的CP是："+value);
 }
 HashMap<String, String> map = new HashMap<String,String>();
 map.put("胡歌", "霍建华");
 map.put("郭德纲", "于谦");
 map.put("薛之谦", "大张伟");
 ?
 Set<Entry<String,String>> entrySet = map.entrySet();
 for (Entry<String, String> entry : entrySet) {
     String key = entry.getKey();
     String value = entry.getValue();
     System.out.println(key+"的CP是:"+value);
 }

6 异常

7 λ表达式

8 File

9 反射

1.1 Class对象

 // 方式一（源代码阶段）：将字节码文件加载进内存，返回Class对象。多用于配置文件，将类名定义在配置文件中。读取文件，加载类。 Class.forName("全类名"); ? // 方式二（Class类对象阶段）：通过类名的属性class获取。多用于参数的传递。 类名.class; ? // 方式三（Runtime运行时阶段）：getClass()方法在Object类中定义着。多用于对象的获取字节码的方式 对象.getClass();

1. 获取成员变量们
   • Field[] getFields() ：获取所有public修饰的成员变量
   • Field getField(String name) 获取指定名称的 public修饰的成员变量
   • Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
   • Field getDeclaredField(String name)
2. 获取构造方法们
   • Constructor<?>[] getConstructors()
   • Constructor<T> getConstructor(类<?>... parameterTypes)
   • Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
   • Constructor<?>[] getDeclaredConstructors()
3. 获取成员方法们：
   • Method[] getMethods()：获取所有public修饰的成员方法
   • Method getMethod(String name, 类<?>... parameterTypes)
   • Method[] getDeclaredMethods() ：获取所有的成员方法，不考虑修饰符
   • Method getDeclaredMethod(String name, 类<?>... parameterTypes)
4. 获取全类名：String getName()

1.2 Field成员变量

1. 设置值：void set(Object obj, Object value)：将指定对象参数上的此Field对象表示的字段设置为指定的新值。
2. 获取值：get(Object obj) ：在指定的对象上，返回该所表示的字段的值Field。
3. 忽略访问权限修饰符的安全检查：setAccessible(true):暴力反射

 public static void main(String[] args) throws Exception {
     //0. 获取Person的Class对象
     Class personClass = Person.class;
 ?
     //1. Field[] getFields()获取所有public修饰的成员变量
     Field[] fields = personClass.getFields();
 ?
     //2. Field getField(String name)
     Field a = personClass.getField("a");
     // 获取成员变量a 的值
     Person p = new Person();
     Object value = a.get(p);
     // 设置a的值
     a.set(p,"张三");
 ?
     //3. Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
     Field[] declaredFields = personClass.getDeclaredFields();
 ?
     //4. Field getDeclaredField(String name)
     Field d = personClass.getDeclaredField("d");
     d.setAccessible(true);//暴力反射
     Object value2 = d.get(p);
     System.out.println(value2);
 }

1.3 Constructor构造方法

 public static void main(String[] args) throws Exception {
     //0.获取Person的Class对象
     Class personClass = Person.class;
 ?
     //1 创建有参数的Constructor对象
     Constructor constructor = personClass.getConstructor(String.class, int.class);
     System.out.println(constructor);
     // 创建对象
     Object person = constructor.newInstance("张三", 23);
     System.out.println(person);
 ?
     // 创建无参数的Constructor对象
     Constructor constructor1 = personClass.getConstructor();
     System.out.println(constructor1);
     // 创建对象
     Object person1 = constructor1.newInstance();
     System.out.println(person1);
 ?
     // 创建对象（无参的简化方式）
     Object o = personClass.newInstance();
     System.out.println(o);
 }

1.4 Method方法对象

• 执行方法：Object invoke(Object obj, Object... args)
• 获取方法名称：String getName():获取方法名
• 忽略访问权限修饰符的安全检查：setAccessible(true):暴力反射

 public static void main(String[] args) throws Exception {
     //0.获取Person的Class对象
     Class personClass = Person.class;
 ?
     //1 获取指定名称的不带参数的方法
     Method eat_method = personClass.getMethod("eat");
     Person p = new Person();
     //执行方法
     eat_method.invoke(p);
 ?
     //2 获取指定名称的带参数的方法
     Method eat_method2 = personClass.getMethod("eat", String.class);
     //执行方法
     eat_method2.invoke(p,"饭");
 ?
     //获取所有public修饰的方法（包含本类的方法和父类Object的方法）
     Method[] methods = personClass.getMethods();
     for (Method method : methods) {
         System.out.println(method);
         String name = method.getName();
         System.out.println(name);
         //method.setAccessible(true);
     }
 ?
     //3 获取类名
     String className = personClass.getName();
     System.out.println(className);//cn.itcast.domain.Person
 }

1.5 案例

pro.properties

 className=cn.itcast.domain.Student
 methodName=eat

 /**
  * 框架类
  */
 public class ReflectTest {
     public static void main(String[] args) throws Exception {
         //1.加载配置文件
         //1.1创建Properties对象
         Properties pro = new Properties();
         //1.2加载配置文件，转换为一个集合
         //1.2.1获取class目录下的配置文件
         ClassLoader classLoader = ReflectTest.class.getClassLoader();
         InputStream is = classLoader.getResourceAsStream("pro.properties");
         pro.load(is);
 ?
         String className = pro.getProperty("className");
         String methodName = pro.getProperty("methodName");
 ?
         //2.加载该类进内存
         Class cls = Class.forName(className);
         //3.创建对象
         Object obj = cls.newInstance();
         //4.获取方法对象
         Method method = cls.getMethod(methodName);
         //5.执行方法
         method.invoke(obj);
     }
 }

10 注解

2.1 自定义注解

（1）注解中的属性：实际上是接口中的抽象方法。

• 属性的返回值类型有下列取值
  • 基本数据类型
  • String
  • 枚举
  • 注解
  • 以上类型的数组
• 定义了属性，在使用注解时需要给属性赋值。
  1. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
  2. 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。
  3. 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略

（2）元注解：用于描述注解的注解

• @Target(ElementType.TYPE)：可以作用于类上

  @Target(ElementType.METHOD)：可以作用于方法上

  @Target(ElementType.FIELD)：可以作用于成员变量上

• @Retention(RetentionPolicy.RUNTIME)：该注解会保留到class字节码文件中，并被JVM读取到

  @Retention(RetentionPolicy.CLASS)

  @Retention(RetentionPolicy.SOURCE)：只会保留到源代码.java文件中，不存在于class字节码文件中。

• @Documented：描述注解是否被抽取到api文档中
• @Inherited：描述注解是否被子类继承。加了该注解，子类会自动继承父类有@Inherited的注解。

2.2 解析注解

在程序使用(解析)注解：获取注解中定义的属性值

操作步骤：

1. 获取注解定义的位置的对象 （Class，Method，Field）
2. 获取指定的注解（其实就是在内存中生成了一个该注解接口的子类实现对象）：getAnnotation(Class)
3. 调用注解中的抽象方法获取配置的属性值

（1）自定义注解

 @Target({ElementType.TYPE})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Pro {
     String className();
     String methodName();
 }

（2）定义两个类

package cn.itcast.annotation;

public class Demo1 {
    public void show(){
        System.out.println("demo1...show...");
    }
}
-------------------------------------------------------------------------------------

package cn.itcast.annotation;

public class Demo2 {
    public void show(){
        System.out.println("demo2...show...");
    }
}

（3）测试：调用注解中的抽象方法获取配置的属性值

@Pro(className = "cn.itcast.annotation.Demo1",methodName = "show")
public class ReflectTest {
    public static void main(String[] args) throws Exception {

        //1.解析注解
        //1.1获取该类的字节码文件对象
        Class<ReflectTest> reflectTestClass = ReflectTest.class;
        //2.获取上边的注解对象
        Pro an = reflectTestClass.getAnnotation(Pro.class);
        //3.调用注解对象中定义的抽象方法，获取返回值
        String className = an.className();
        String methodName = an.methodName();
        System.out.println(className);
        System.out.println(methodName);

        //3.加载该类进内存
        Class cls = Class.forName(className);
        //4.创建对象
        Object obj = cls.newInstance();
        //5.获取方法对象
        Method method = cls.getMethod(methodName);
        //6.执行方法
        method.invoke(obj);
    }
}

解析：获取上边的注解对象an，实际上是在内存中生成了一个该注解接口的子类实现对象ProImpl。

public class ProImpl implements Pro{
    public String className(){
        return "cn.itcast.annotation.Demo1";
    }
    public String methodName(){
        return "show";
    }
}

2.3 案例：简单的测试框架

1. 以后大多数时候，我们会使用注解，而不是自定义注解
2. 注解给谁用？
   • 编译器
   • 给解析程序用
3. 注解不是程序的一部分，可以理解为注解就是一个标签

（1）@Check注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Check {
}

（2）加了@Check的类

 1 /**
 2  * 小明定义的计算器类
 3  */
 4 public class Calculator {
 5
 6     //加法
 7     @Check
 8     public void add(){
 9         // String str = null;
10         // str.toString();
11         System.out.println("1 + 0 =" + (1 + 0));
12     }
13     //减法
14     @Check
15     public void sub(){
16         System.out.println("1 - 0 =" + (1 - 0));
17     }
18     //乘法
19     @Check
20     public void mul(){
21         System.out.println("1 * 0 =" + (1 * 0));
22     }
23     //除法
24     @Check
25     public void div(){
26         System.out.println("1 / 0 =" + (1 / 0));
27     }
28
29     public void show(){
30         System.out.println("永无bug...");
31     }
32 }

（3）测试

/**
 * 简单的测试框架
 * 当主方法执行后，会自动自行被检测的所有方法(加了Check注解的方法)，判断方法是否有异常，记录到文件中
 */
public class TestCheck {
    public static void main(String[] args) throws IOException {
        //1.创建计算器对象
        Calculator c = new Calculator();
        //2.获取字节码文件对象
        Class cls = c.getClass();
        //3.获取所有方法
        Method[] methods = cls.getMethods();

        int number = 0;//出现异常的次数
        BufferedWriter bw = new BufferedWriter(new FileWriter("bug.txt"));

        for (Method method : methods) {
            //4.判断方法上是否有Check注解
            if(method.isAnnotationPresent(Check.class)){
                //5.有，执行
                try {
                    method.invoke(c);
                } catch (Exception e) {
                    //6.捕获异常
                    //记录到文件中
                    number ++;

                    bw.write(method.getName()+ " 方法出异常了");
                    bw.newLine();
                    bw.write("异常的名称:" + e.getCause().getClass().getSimpleName());
                    bw.newLine();
                    bw.write("异常的原因:"+e.getCause().getMessage());
                    bw.newLine();
                    bw.write("--------------------------");
                    bw.newLine();
                }
            }
        }
        bw.write("本次测试一共出现 "+number+" 次异常");
        bw.flush();
        bw.close();
    }
}

附 ASCII表

http://ascii.911cha.com/

原文地址：https://www.cnblogs.com/khazix/p/12024373.html