Java开发大全第一章（1-5）
Java开发大全目录链接
第一章 JavaSE
一、 语言基础
1. 基础语法
1） 操作符
-
算数运算符 -> “ +，-，*，/，（，）……. “
-
赋值 -> “ = ”
x = a + b * c / d - e; -
自动递增/递减。-> “++/–”
a++; -
关系运算符 -> “ > , < ,>= , <= , == , != ”
-
逻辑运算符 ->. “ && , || , ! ”
if（a > b && e < f && h <= j && p >= q ） if(a != b || c == d) -
三元操作符 boolean-expression ? value1 : value2 ==（if(true) value1 else value2）
a > b ? max = a : max = b; if(a > b) max = a; else max = b; -
字符操作符 ->. “ + ， += ”
-
类型转换操作符 （TYPE）
-
Java没有*
sizeof*
2） 控制执行流程
2.面向对象
1） 类的概念
类（Class）是面向对象程序设计（OOP，Object-Oriented Programming）实现信息封装的基础。类是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。
创建一个类：
class Student{
//成员变量
private String name;
private String number;
private int age;
//成员方法
public Student(){} //无参构造器
public Student(String name,String number,int age){ //全部参数构造器
this.name = name;
this.number = number;
this.age = age;
}
//包外访问private变量的Getter/Setter
public int getAge(){
return this.age;
}
public void setAge(int age){
this.age = age;
}
}
2）面向对象程序设计语言的特点
封装
隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。
继承
继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。
我们发现当某个类的属性方法和一个类很接近时，如果重新仍旧重新写那个类的代码，会导致代码臃肿；所以可以继承自那个类，重写部分方法或修改属性，加入另外独特的方法和属性。
关键字：extends
public class Dog extends Animal{
@Override
void eat(){ //重写吃东西，继承自父类
……
}
void watch(){ //看家本领，独特！
……
}
}
}
多态
- 多态就是对同一个对象，在不同时刻表现出来的不同形态
前提条件：
- 要有继承/实现关系
- 要有方法重写
- 要有父类引用指向子类对象
多态的成员特点：
-
成员变量：编译看左边、运行看左边
-
成员方法：编译看左边、运行看右边
example：
父类Animal，子类Cat
Animal Tom = new Cat();
3. 接口
1）接口的定义
Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。
2） 接口的作用
- 利于代码的规范：这样做的目的一方面是为了给开发人员一个清晰的指示，告诉他们哪些业务需要实现；同时也能防止由于开发人员随意命名而导致的命名不清晰和代码混乱，影响开发效率。
- 有利于对代码进行维护：可以一开始定义一个接口，把功能菜单放在接口里，然后定义类时实现这个接口，以后要换的话只不过是引用另一个类而已，这样就达到维护、拓展的方便性。
- 增强安全、严密性：接口是实现软件松耦合的重要手段，它描叙了系统对外的所有服务，而不涉及任何具体的实现细节。
3） 接口相关关键字
- 定义接口使用Interface
- 实现接口使用implements
4） 接口内部包含
- 常量（ 必须public static final xxxxx 格式定义）
- 抽象方法（必须public abstract xxxxxx格式定义，实现类必须重写它）
- 普通默认方法
- 静态方法
- 私有方法
example：
//创建接口
package com.sugar.interfaceTest;
/*
* Interface contains:
* 常量
* abstract method
* default method
* static method
* private method
* Tips:
* Abstract method in interface, modifier must be public abstract,and they can be omitted
*/
public interface InterfaceTest {
public static final int greedsWords = 1; //Constant: public static final is needed.
public abstract void greeds();//Abstract method
public default void greedsTwo(){
/*The default method. When upgrading an interface,
if an abstract method is used,
other implementation classes must override the method.
Therefore, the implementation classes put into use need not be modified if the default method is used */
System.out.println("default echo: Hello！");
}
}
----------------------------------------------------------------------------------------------------------------
//创建实现类
package com.sugar.interfaceTest;
public class InterfaceTestImpl implements InterfaceTest {
@Override
public void greeds() {
System.out.println("Hello！");
}
/* 调用这些方法 */
public static void main(String[] args) {
// InterfaceTest interfaceOne =new InterfaceTest(); ----> Wrong
InterfaceTestImpl interfaceOne = new InterfaceTestImpl(); // ---->yes
interfaceOne.greeds();
interfaceOne.greedsTwo();
System.out.println("There " + InterfaceTest.greedsWords + " words in greeds");
}
}
----------------------------------------------------------------------------------------------------------------
//Running结果
Hello！
default echo: Hello！
There 1 words in greeds
4. 容器
1） 容器关系图
2）Collection接口
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
List接口
List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，也就是说它是有顺序的，类似于数组。和Set不同，List允许有相同的元素。JDK所提供的List容器类有ArrayList、LinkedList等。
// ArrayList测试
import java.util.*;
public class Test{
public static void main(String[] args){
Collection<String> arrayList = new ArrayList<String>();
arrayList.add("China");
arrayList.add(new String("中国"));
System.out.println("size = " + arrayList.size());
System.out.println(arrayList);
}
}
----------------------------------------------------------------------------------------------------------------
Running结果：
size = 2；
[China,中国]
----------------------------------------------------------------------------------------------------------------
// LinkedList测试
import java.util.*;
public class Test{
public static void main(String[] args){
List<String> linkedList = new LinkedList<String>();
for(int i=0;i<=5;i++){
linkedList.add("a"+i);
}
System.out.println(linkedList);
linkedList.add(3,"a100");
System.out.println(linkedList);
linkedList.set(6,"a200");
System.out.println(linkedList);
System.out.println((String)linkedList.get(2)+" ");
linkedList.remove(1);
System.out.println(linkedList);
}
----------------------------------------------------------------------------------------------------------------
Runing结果：
[a0,a1,a2,a3,a4,a5]
[a0,a1,a2,a100,a3,a4,a5]
a2
[a0,a2,a100,a3,a4,a200]
Set接口
Set是一种不包含重复的元素的Collection,即任意的两个元素e1和e2都有e1.equals(e2) = false，Set最多有一个null元素。
Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。 Set容器类主要有HashSet和TreeSet等。
// 测试HashSet
import java.util.*;
public class TestC{
public static void main(String[] args){
Set <String> hashSet = new HashSet<String>();
hashSet.add("Hello");
hashSet.add("Hello");
System.out.println(hashSet);
}
}
----------------------------------------------------------------------------------------------------------------
Running结果：
[Hello]
3）Map接口
值得注意的是Map没有继承Collection接口，Map接口是提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value.即是一一映射，Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。 Map接口的实现类主要是包括HashMap和TreeMap等。
- HashMap
import java.util.*;
public class TestD{
public static void main(String[] args){
Map <String,String> hashMap = new HashMap <String,String>();
hashMap.put("one",new String("1"));
hashMap.put("two",new String("2"));
System.out.println(hashMap);
}
}
----------------------------------------------------------------------------------------------------------------
Running结果：
<two=2，one=1>
4） 总结
Java容器实际上只有三种:Map , List, Set;但每种接口都有不同的实现版本.
- List的选择: ArrayList和LinkedList都实现了List接口.因此无论选择哪一个,基本操作都一样.但ArrayList是由数组提供底层支持.而LinkedList是由双向链表实现的.所以,如果要经常向List里插入或删除数据,LinkedList会比较好.否则应该用速度更快的ArrayList。
- Set的选择：HashSet总是比TreeSet 性能要好.而后者存在的理由就是它可以维持元素的排序状态.所以,如果需要一个排好序的Set时,才应该用TreeSet。
- Map的选择：HashMap总是比TreeMap 性能要好.而后者存在的理由就是它可以维持元素的排序状态.所以,如果需要一个排好序的Map时,才应该用TreeMap。
5. 异常
1）异常的概念
异常指不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程。Java通过API中Throwable类的众多子类描述各种不同的异常。因而，Java异常都是对象，是Throwable子类的实例，描述了出现在一段编码中的 错误条件。当条件生成时，错误将引发异常。
在 Java 中，所有的异常都有一个共同的祖先 Throwable（可抛出）。Throwable 指定代码中可用异常传播机制通过 Java 应用程序传输的任何问题的共性。Throwable： 有两个重要的子类：Exception（异常）和 Error（错误），二者都是 Java 异常 处理的重要子类，各自都包含大量子类。
-
Error（错误）: 是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。
-
Exception（异常):是程序本身可以处理的异常。Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如，若试图使用空值对象引用、除数为零或数组越界，则分别引发运行时异常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。
通常，Java的异常(包括Exception和Error)分为可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）。
-
可查的异常（编译器要求必须处置的异常）：
- 正确的程序在运行中，很容易出现的、情理可容的异常状况。可查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。
- 除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。
-
不可查异常(编译器不要求强制处置的异常)：
- 包括运行时异常（RuntimeException与其子类）和错误（Error）。Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异
-
运行时异常：
-
都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生
-
运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。
-
非运行时异常 （编译异常）：
- 是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。
2） 处理异常机制
在 Java 应用程序中，异常处理机制为：抛出异常，捕捉异常。
-
抛出异常：当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。
-
捕获异常：在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适 的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。
-
一个方法所能捕捉的异常，一定是Java代码在某处所抛出的异常。简单地说，异常总是先被抛出，后被捕捉的。
-
捕获异常：try、catch 和 finally
-
try-catch语句
在Java中，异常通过try-catch语句捕获。其一般语法形式为:
-
try {
// 可能会发生异常的程序代码
} catch (Type1 id1){
// 捕获并处置try抛出的异常类型Type1
}
catch (Type2 id2){
//捕获并处置try抛出的异常类型Type2
}
tips：一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。
- try－catch-finally语句
try {
// 可能会发生异常的程序代码
} catch (Type1 id1) {
// 捕获并处理try抛出的异常类型Type1
} catch (Type2 id2) {
// 捕获并处理try抛出的异常类型Type2
} finally {
// 无论是否发生异常，都将执行的语句块
//常用来关闭资源等收尾必须做的工作
}
tips：try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
catch 块：用于处理try捕获到的异常。
finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally 语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：
1 在finally语句块中发生了异常。
2 在前面的代码中用了System.exit()退出程序。
3 程序所在的线程死亡。
4 关闭CPU。
3） try-catch-finally 规则：
- 必须在 try 之后添加 catch 或 finally 块。try 块后可同时接 catch 和 finally 块，但至少有一个块。
- 必须遵循块顺序：若代码同时使用 catch 和 finally 块，则必须将 catch 块放在 try 块之后。
- catch 块与相应的异常类的类型相关。
- 一个 try 块可能有多个 catch 块。若如此，则执行第一个匹配块。即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配，如果异常对象为某个异常类型或其子类的实例，就执行这个catch代码块，不会再执行其他的 catch代码块
- 可嵌套 try-catch-finally 结构。
- 在 try-catch-finally 结构中，可重新抛出异常。
- 除了下列情况，总将执行 finally 做为结束：JVM 过早终止（调用 System.exit(int)）；在 finally 块中抛出一个未处理的异常；计算机断电、失火、或遭遇病毒攻击。
4） try、catch、finally语句块的执行顺序
- 当try没有捕获到异常时：try语句块中的语句逐一被执行，程序将跳过catch语句块，执行finally语句块和其后的语句；
- 当try捕获到异常，catch语句块里没有处理此异常的情况：当try语句块里的某条语句出现异常时，而没有处理此异常的catch语句块时，此异常将会抛给JVM处理，finally语句块里的语句还是会被执行，但finally语句块后的语句不会被执行；
- 当try捕获到异常，catch语句块里有处理此异常的情况：在try语句块中是按照顺序来执行的，当执行到某一条语句出现异常时，程序将跳到catch语句块，并与catch语句块逐一匹配，找到与之对应的处理程序，其他的catch语句块将不会被执行，而try语句块中，出现异常之后的语句也不会被执行，catch语句块执行完后，执行finally语句块里的语句，最后执行finally语句块后的语句；
5） 抛出异常
任何Java代码都可以抛出异常，如：自己编写的代码、来自Java开发环境包中代码，或者Java运行时系统。无论是谁，都可以通过Java的throw语句抛出异常。从方法中抛出的任何异常都必须使用throws子句。
-
throws抛出异常
- 如果是不可查异常（unchecked exception），即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。
- 必须声明方法可抛出的任何可查异常（checked exception）。即如果一个方法可能出现受可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误。
- 仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出。
- 调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类.
void method1() throws IOException{} //合法 //编译错误，必须捕获或声明抛出IOException void method2(){ method1(); } //合法，声明抛出IOException void method3()throws IOException { method1(); } //合法，声明抛出Exception，IOException是Exception的子类 void method4()throws Exception { method1(); } //合法，捕获IOException void method5(){ try{ method1(); }catch(IOException e){…} } //编译错误，必须捕获或声明抛出Exception void method6(){ try{ method1(); }catch(IOException e){throw new Exception();} } //合法，声明抛出Exception void method7()throws Exception{ try{ method1(); }catch(IOException e){throw new Exception();} }- 判断一个方法可能会出现异常的依据如下：
- 方法中有throw语句。例如，以上method7()方法的catch代码块有throw语句。
- 调用了其他方法，其他方法用throws子句声明抛出某种异常。例如，method3()方法调用了method1()方法，method1()方法声明抛出IOException，因此，在method3()方法中可能会出现IOException。
-
throw抛出异常
throw总是出现在函数体中，用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。例如抛出一个IOException类的异常对象：
throw new IOException;
要注意的是，throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象。下面的操作是错误的：这是因为String 不是Throwable 类的子类。
throw new String("exception");
如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。如果所有方法都层层上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException，则该方法的调用者可选择处理该异常。
package Test;
import java.lang.Exception;
public class TestException {
static int quotient(int x, int y) throws MyException { // 定义方法抛出异常
if (y < 0) { // 判断参数是否小于0
throw new MyException("除数不能是负数"); // 异常信息
}
return x/y; // 返回值
}
public static void main(String args[]) { // 主方法
int a = 3;
int b = 0;
try { // try语句包含可能发生异常的语句
int result = quotient(a, b); // 调用方法quotient()
} catch (MyException e) { // 处理自定义异常
System.out.println(e.getMessage()); // 输出异常信息
} catch (ArithmeticException e) { // 处理ArithmeticException异常
System.out.println("除数不能为0"); // 输出提示信息
} catch (Exception e) { // 处理其他异常
System.out.println("程序发生了其他的异常"); // 输出提示信息
}
}
}
class MyException extends Exception { // 创建自定义异常类
String message; // 定义String类型变量
public MyException(String ErrorMessagr) { // 父类方法
message = ErrorMessagr;
}
public String getMessage() { // 覆盖getMessage()方法
return message;
}
}
6) 异常链
7） Throwable类中的常用方法
注意：catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型，e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:
-
getCause()：返回抛出异常的原因。如果 cause 不存在或未知，则返回 null。
-
getMeage()：返回异常的消息信息。
-
printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值，
8） 常见异常
-
runtimeException子类
-
java.lang.ArrayIndexOutOfBoundsException 数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
-
java.lang.ArithmeticException 算术条件异常。譬如：整数除零等。
-
java.lang.NullPointerException 空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
-
java.lang.ClassNotFoundException 找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
-
java.lang.NegativeArraySizeException 数组长度为负异常
-
java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常
-
java.lang.SecurityException 安全性异常
-
java.lang.IllegalArgumentException 非法参数异常
-
IOException
-
IOException：操作输入流和输出流时可能出现的异常。
-
EOFException 文件已结束异常
-
FileNotFoundException 文件未找到异常
-
其他
- ClassCastException 类型转换异常类
- ArrayStoreException 数组中包含不兼容的值抛出的异常
- SQLException 操作数据库异常类
- NoSuchFieldException 字段未找到异常
- NoSuchMethodException 方法未找到抛出的异常
- NumberFormatException 字符串转换为数字抛出的异常
- StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常
- IllegalAccessException 不允许访问某类异常
- InstantiationException 当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常
9） 自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。在程序中使用自定义异常类，大体可分为以下几个步骤：
-
创建自定义异常类：一般会选择继承Exception和RuntimeException，如果不要求调用者一定要处理抛出的异常，就继承RuntimeException。
-
抛出自定义异常：在方法中通过throw关键字抛出异常对象。
-
捕获自定义异常：如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
-
在出现异常方法的调用者中捕获并处理异常
class MyException extends Exception { // 创建自定义异常类 String message; // 定义String类型变量 public MyException(String ErrorMessagr) { // 父类方法 message = ErrorMessagr; } public String getMessage() { // 覆盖getMessage()方法 return message; } }
@Author
@Date $2020/ 07 / 15 / 16 : 03 : 35 $
参考文献来自于
CSDN
百度百科
本文地址：https://blog.csdn.net/Sugar2247945677/article/details/107363110
上一篇： SEO干货：深度揭秘百度权重的本质
推荐阅读
-
Java开发大全第一章（1-5）
-
Java开发人员必备的linux学习大全（用户管理，基本操作，mysql、jdk等开发软件的安装，图文详解）
-
荐 【JAVA企业级开发】实际生产中SpringCloud-Finchley.SR2的Eureka的application.properties配置大全（Server，Client，Ins
-
java语言开发String字符串操作大全
-
Java开发大全第一章（1-5）
-
【Java程序员必知必会的90个细节，Java开发工程师面试问题大全
-
最新总结的Java高级开发工程师面试考纲大全（收藏）
-
《疯狂Java讲义》读书笔记 第一章Java语言概述与开发环境
-
荐 【JAVA企业级开发】实际生产中SpringCloud-Finchley.SR2的Eureka的application.properties配置大全（Server，Client，Ins
-
最新总结的Java高级开发工程师面试考纲大全（收藏）