JavaSE基础知识点整理

Java大数据运动猿

已于 2023-02-26 12:10:51 修改

阅读量1.3k

点赞数 1

分类专栏： JavaSE 文章标签： java

于 2022-07-10 20:02:34 首次发布

本文链接：https://blog.csdn.net/m0_51697147/article/details/125709580

版权

JavaSE 专栏收录该内容

12 篇文章 3 订阅

订阅专栏

1.final常量（常量命名全为大写）：

如：final double PI = 3.14；

2.标识符命名规范：

驼峰原则（大小大写）：类名、成员变量、方法名

3.数据类型：基本数据类型（值类型）、引用数据类型

基本数据类型：int（4）、byte（1）、long（8）、short（2）、float（4）、double（8）、char（2）、boolean（无字节）

4. 引用数据类型（4个字节）：class类、 interface接口、array数组

5.java语言整型常量的四种表示形式：

十进制、八进制（以0开头）、十六进制（以0x或0X开头）、二进制（以 0b或0B开头）

5.1.浮点型：

（1）浮点型不精确，尽量不要把浮点型的变量用于比较。

（原因：浮点数存在舍入误差，数字不能精确表示。）如果要精确表示，可以用java的BigDecimal类型。

（2）浮点常量默认类型时double，要改成float可以在数值后面加F或f。

如：float pi = 3.14；（错）原因：3.14为double型

float pi = 3.14F；把3.14double型转为float型。

ASCLL码中三个特殊节点：A:65 a：97 ‘0’：48
String字符串不是基本数据类型，是类。
Boolean类型：True 和 False
二元运算符的运算原则：

5.2.整数运算：

如果两个操作数有一个为long，则结果也为long；

没有long时，不论操作数是short还是byte，结果都为int型。

5.3浮点运算：

如果两个操作数有一个为double，则结果为double

只有两个操作数都是float，则结果才是float

取模运算：结果的符号与左边操作数的符号一样。

如：-7%3=-1； 7%-3=1；

注明：两个整数相除，直接保留结果的整数部分，不保留小数部分（原因：没有四舍五入的规则。）

如：10/3=3;

6.位运算符（进行二进制位的运算）：

<<:左移运算符，左移1位相当于乘2

>>：右移运算符，右移1位相当于除2取商

如：5<<1 == 5*2 4<<3 == 4*2*2*2

5>>1 ==5/2 20>>3 ==20/2/2/2

7.优先级：逻辑与>逻辑或即&&优先级大于||

8.条件句：if单分支结构、if-else双分支结构、if-else if-else多分支结构；

9.continue outer；（带标签的continue，帮助我们从内部循环跳到外部循环）

如：outer：for(int i;i <150;i++){

for(int j =2;j<1;j++){

if(i%j ==0){

continue outer;//符合某个条件则跳转到outer那里}}}

10.while（）{}循环，while条件中只能用Boolean类型，不能用int类型

C语言中while（1）可以通过，因为将int类型转为Boolean类型

Java中while（1）不能通过，只能放boolean类型；

11.方法的调用：

普通方法：对象.方法名

静态方法：类名.方法名

12.方法重载：（与返回值类型无关）

1.名称相同 2.形参数量不同 3.形参类型不同 4.形参顺序不同（2、34满足一点即可）

12.java是面向对象编程，C语言是面向过程编程；

面向过程是执行者思维；面向对象是设计者思维

13.成员变量的默认值：（两大类型：值类型（1、2、3、4）、引用类型（5）））

1.整数：0 2.浮点型：0.0 3.字符型：‘\u0000’

4.布尔型：False 5.所有引用类型：null

14..栈、堆：

栈：1.栈描述的是方法执行的内存模型，每个方法被调用都会创建一个栈帧（存储局部变量、操作数、方法出口等）

JVM为每个线程创建一个栈，用于存放该线程执行方法的信息（实际参数、局部变量等）
栈属于线程私有，不能实现线程间的共享！
栈的存储特性是“先进后出，后进先出”
栈是有系统自动分配，速度快，栈是一个连续的内存空间！

堆：1.堆用于存储创建好的对象和数组（数组也是对象）

JVM只有一个堆，被所有线程共享
堆是一个不连续的内存空间，分配灵活，速度慢！

this的使用（super同理）：1.调用无参的构造方法，this（）必须位于第一行

调用带参的构造方法，this（参数，参数）也必须在第一行

注明：构造方法中不可以用构造方法名来调用构造方法，只能用this（）来调用。super则不同，系统会默认在子类重写父类的方法中的第一条语句中写super（）；

如：TestThis（）{System.out.println();}，在另一个构造方法中调用要在方法的第一行写this（）；调用带参的构造方法就是this（参数，参数）

15.java中的内存机制：

1.栈（存放地址）：局部变量、对象

2.堆（存放地址）：成员变量、方法

16.static静态：

static方法只能调用静态（即static）成员变量和方法，不能调用非静态成员变量和方法；
***静态初始化块，用于类的初始化操作，初始化静态属性（即static初始化块中，可以为静态成员变量赋初值，但不能定义静态成员变量，也可以调用静态方法，当子类继承父类时，编译会直接运行static代码块。）。***

class TestStatic{

    static int i;

    static double b;

    static{

        i = 10;

        b=20;

        System.out.println("i+b的结果为："+(i+b));

    }

}



public class HelloWrold extends TestStatic {

    public static void main (String[] args){



    }

（类中定义了static静态初始化块后，static会被直接执行，不用main方法中调用，一定会执行。上面代码块结果为：i+b的结果为：30.0）

17.instanceof运算符：instanceof是二元运算符，左边是对象，右边是类，当左边的对象是右边类或子类所创建的对象时，返回true；否则返回False；

即：对象是子类或者父类或者父类的父类创建的对象，都返回true。

System.out.println(s instanceof Student);（如果s是类Student创建的对象或者是Student的子类创建的对象时，返回true）

18.继承：子类继承父类，可以继承父类的所有的成员变量和方法（除了构造方法），但不见得可以直接访问（如：父类的私有成员变量和方法不能访问）

19.方法重写：子类重写父类的方法（即将父类的方法给覆盖了），调用方法时会先调用子类的方法，用super关键字才能调用父类的方法。

注意：子类不继承父类的构造方法，所以子类不能重写父类的构造方法；

子类继承了父类，子类的构造方法中，不论是带参还是不带参的，构造方 法中的第一条语句系统都会默认写一句super（），来调用父类的无参构造方法；

20.final修饰：变量不能重新赋值，方法不能被重写，类不能被继承；

21.IDEA的一些快捷键：

1.类的结构视图（目录）：alt+7

2.看类的源码（Object等系统类）：control+鼠标左键

3.自动生成构造方法：get、set方法、equals等：alt+insert

4.查看错误：alt+enter

5.重写方法：control+o

22.equals的用法：equals默认是比较两个东西的的地址的，可以重写equals进行别的比较，操作：单机右键+generate+equals（） and hashcode（）

如：对一些形参的比较，可以重写equals方法对ID或name或pw等进行比较是否相同。

 public static void main(String[] args) {

        TestObject t1 = new TestObject(ID：1001,name："zhangsan",pw："123");

        TestObject t2 = new TestObject(ID：1001,name："zhangsan",pw："123");

        System.out.println(t1.toString());

        System.out.println(t2.toString());

        System.out.println(t1.equals(t2));

    }

}

23.关于protected的两个细节（章节：java快速入门83）：

若父类和子类在同一个包中，子类可访问父类的protected成员（用super），也可以访问父类对象的protected成员（即在子类中，可以用父类创建的对象来调用protected成员变量）；
若子类和父类不在同一个包中，子类可访问父类的protected成员（用super），不能访问父类对象的protected成员（即在子类中，不能用父类创建的对象来调用protected成员变量）。
类名定义的变量和方法：

类名定义的变量和方法与普通的变量和方法没什么区别，类名定义的变量，类型为自定义类型，这个变量可以调用类型所在类的属性（成员变量）方法。类名定义的方法和普通方法差不多，但最后要返回null，即return null；

24./**/多行注释的注意事项：

不要嵌套注释，即不要/*....../*.......*/*/,最好一个个注释，如：/*....*//*....*/
最好一个方法或者一个类一个类的注释，最好不要整个程序一起注释。

25.java中main方法中不能声明方法，因为main方法本身就是方法，方法中不能嵌套。

26.String字符串

package TestJavaSE;

//String字符串最常见的三种创建方式；

//String字符串为不可变类型，即private final修饰的

//因为S2和S3的字符串相同，所以S2和S3的地址也相同，所以17行返回true

//S4与S2和S3的字符串相同，但地址不同，因为S4的创建是用数组，所以S4！=S2和S3

//equals比较的是字符串是否相等，因为S2与S4的字符串相等，所以返回true

public class StringTest {

    public static void main(String[] args) {

        String S0 = null;

        String S1 = "";

        String S2 = "java";

        String S3 = "java";

        String S4 = new String("java");



        System.out.println(S1.length());

        System.out.println(S2.length());

        System.out.println(S3.length());

        System.out.println(S2.equals(S3));

        System.out.println(S2==S3);

        System.out.println(S2==S4);

        System.out.println(S2.equals(S4));

}

}

27.String类（常用方法）

public class StringTest1 {

    public static void main(String[] args) {

        String S1 = "core java";

        String S2 = "Core java";

        System.out.println(S1.charAt(3));//提取下标为3的字符；e

        System.out.println(S2.length());//字符串长度;9

        System.out.println(S1.equals(S2));//比较两个字符串是否相等；False

        System.out.println(S1.equalsIgnoreCase(S2));//比较两个字符串（忽略大小写）；true

        System.out.println(S1.indexOf("java"));//索引字符串S1中java的位置，有则返回索引下标，没有则返回-1；5

        System.out.println(S1.indexOf("apple"));//索引字符串S1中apple的位置，有则返回索引下标，没有则返回-1；-1



        //返回的是全新的字符串

        String s = S1.replace(' ','&');//将S1中的空格替换成&；s="core&java"

        System.out.println("replace is :"+s);



    }

}

package TestJavaSE;



public class StringTest2 {

    public static void main(String[] args) {

        String s = "";

        String S1 = "How are you?";

        System.out.println(S1.startsWith("How"));//是否以How开头；true

        System.out.println(S1.endsWith("you"));//是否以you结尾；false

        s = S1.substring(4);//提取子字符串，从下标为4的开始到字符串结束为止；are you?

        System.out.println(s);

        s = S1.substring(4,7);//提取子字符串，下标[4,7),不包括7

        System.out.println(s);//are

        s = S1.toLowerCase();//将S1字符串转为小写；

        System.out.println(s);//how are you?

        s = S1.toUpperCase();//将S1字符串转为大写；

        System.out.println(s);//HOW ARE YOU?

        String S2 = "  How old are you!!  ";

        s = S2.trim();//去除字符串首位的空格。注意：中间的空格不能去除

        System.out.println(s);//"How old are you!!"

        System.out.println(S2);//因为String是不可变字符串，所以S2不会变。

    }

}

28.内部类：

内部类的两个要点：

内部类提供了更好的封装，只能让外部类直接访问，不允许同一个包中的其他类直接访问。
内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员，但外部类不能访问内部类的内部属性。
注意：内部类只是一个编译时的概念，一旦编译成功，就会成为完全不同的两个类；如：Outer类中有个Inner内部类，编译成功会成为Outer.class和Outer&Inner.class两个类的字节码文件。

29.非静态内部类：（外部类里使用非静态内部类和平时使用其他类没什么不同）

非静态内部类对象必须寄存在一个外部类对象里，因此，如果有一个非静态内部类对象，那么一定存在对应的外部类对象，非静态内部类对象单独属于外部类的某个对象。
非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员。
非静态内部类不能有静态方法，静态属性和静态初始化块。

30.成员变量访问要点：

内部类属性：this.变量名
外部类属性：外部类名.this.变量名

31.非静态内部类的访问：

外部类中定义内部类：new Inner（）；
外部类以外的地方使用非静态内部类：

Outer.Inner a = new Outer().new Inner();

32.静态内部类：

Static class ClassName{

//类体

}

使用要点：

静态内部类可以访问外部类的静态成员，不能访问外部类的普通成员。
静态内部类看做外部类的一个静态成员。
创建对象：外部类.内部类对象 = new 外部类.内部类（）；

如：Outer.Inner a = new Outer.Inner();

33.数组：

数组也是对象；
数组是相同类型数据的有序集合；
(1)System.arraycopy（被复制数组的名字，从下标哪里开始被复制，复制数组的名字，从下标哪里开始粘贴，复制粘贴的长度）、

Array.toString(数组名)、
Array.fill(开始下标，结束下标，数据替代值)、
Array.binarySearch（数组名，要查找的数据值）
Arrays.sort(数组名)

package TestJavaSE;

import java.util.Arrays;



public class ArrayTest01

    public static void main(String[] args) {

        String[] s = {"阿里","尚学堂","京东","搜狐","网易"};

        String[] sBak = new String[6];

        //数组的复制copy；

        //System.arraycopy(被复制数组的名字，从下标哪里开始被复制，复制数组的名子，从哪里开始粘贴，复制粘贴的长度)

        System.arraycopy(s,0,sBak,0,s.length);

        for (int i = 0 ; i<sBak.length;i++){

            System.out.println(sBak[i]+"\t");

        }

        int[] a = {1,2,323,23,53,12,59};

        System.out.println(Arrays.toString(a));//Arrays.toString(数组名)；将数组内容转换为列表的形式；

        Arrays.sort(a);//将数组a的数据从小到大进行排序；

        System.out.println(Arrays.toString(a));



        //返回排序后新的索引位置，若未找到返回负数（不是负一）；

        System.out.println("该元素的索引："+Arrays.binarySearch(a,120));//Arrays.binarySearch(查找的数组名，查找的数据值)；



        int[] b = {10,20,30,40,50};

        Arrays.fill(b,2,4,100);//把下标为【2,4）的数据换成100；

        System.out.println(Arrays.toString(b));

    }

}

34.Object

（1）Object是所有类的父类，所以用Object作为声明类型，数组中可以有不同类型的数据；

（2）如果把一维数组的数组名赋值给二维数组的某一行的话，是把一维数组的内容赋值给二维数组那一行；

（3）两个一维数组a1，a2，a1=a2，是把a2的地址赋值给了a1,a

1的地址指向a2的，所以a1的值也变成了a2的值；

package TestJavaSE;

import java.util.Arrays;



//测试Object[][]二维数组存储表格数据；



//Object是所有类的父类，用Object作为声明类型，数组中的数据可以有不同类型的数据；

//把一维数组的数组名赋值给二维数组的某一行，是将一维数组的数据赋值给二维数组的某一行；

//两个一维数组a1、a2，a1=a2的话；是把a2的地址赋值给a1；a1和a2有相同的数据；

public class ArrayTest03 {

    public static void main(String[] args) {

        Object[] a1 = {1001,"高小琪",18,"讲师","2-14"};

        Object[] a2 = {1002,"高小七",19,"助教","2-15"};

        Object[] a3 = {1003,"高小琴",20,"主任","2-16"};

        Object[][] emps = new Object[3][];

        emps[0] = a1;

        emps[1] = a2;

        emps[2] = a3;

        System.out.println(Arrays.toString(emps[0]));

        System.out.println(Arrays.toString(emps[1]));

        System.out.println(Arrays.toString(emps[2]));



        System.out.println("===================");

        for(int i=0;i<emps.length;i++){

            for (int j=0;j<emps[i].length;j++){

                System.out.println(emps[i][j]+"\t");

            }

            System.out.println();

        }



        int[] a = {1,2,3,4};

        int[] b = {4,5,6};

        System.out.println(a);

        System.out.println(b);

        a = b;

        System.out.println(a);

        System.out.println(Arrays.toString(a));

    }

}

35.使用javabean和数组结合保存表格数据

package TestJavaSE;



//使用Javabean和数组结合起来保存表格数据；

//javabean是特殊的类，必须具有无参数的构造器，所有的属性都是private的，通过提供setter和getter方法来实现对成员属性的访问。

//用类名声明数组，调用构造方法，并重写toString()方法,要打印几个数据就选择几个数据重写；



public class ArrayTest04 {

    public static void main(String[] args) {

        emp[] empss = {

                new emp(1001, "高小琪", 18, "讲师"),

                new emp(1002, "高小七", 19, "助教"),

                new emp(1003, "高小琴", 20, "教授")

        };

        for(emp i:empss){

            System.out.println(i);

        }

    }

}

class emp{

    private int id;

    private String name;

    private int age;

    private String job;



    public emp(int id, String name, int age,String job) {

        this.id = id;

        this.name = name;

        this.age = age;

        this.job = job;

    }



    @Override

    public String toString() {

        return "emp{" +

                "id=" + id +

                ", name='" + name + '\'' +

                ", age=" + age +

                ", job='" + job + '\'' +

                '}';

    }



    public int getId() {

        return id;

    }



    public void setId(int id) {

        this.id = id;

    }



    public String getName() {

        return name;

    }



    public void setName(String name) {

        this.name = name;

    }



    public String getJob() {

        return job;

    }



    public void setJob(String job) {

        this.job = job;

    }

}

36.return：

return只能出现在函数里，如果出现在上面实例里的for循环里就会报错，return出现在函数里的作用就是即使下面还有内容也不再继续往下执行了，最常见的就是在函数里判断参数是否符合要求。

37.冒泡排序、二分法查找：

1.冒泡排序：

package TestJavaSE;

import java.util.Arrays;

//测试冒泡排序

public class BubbleSortTest {

    public static void main(String[] args) {

        int[] values = {3,1,4,6,22,0,33,2,745,5,56,8};

        System.out.println("values数组原始顺序："+Arrays.toString(values));

        bubbleSort(values);

    }

    public static void bubbleSort(int[] values){//把冒泡排序的方法设置成static静态的，不允许改变代码；

        int temp;



        for(int i=0;i<values.length;i++){

            //定义一个布尔类型的变量，标记数组是否已到达有序状态；

            boolean flag = true;

            //内循环，每一趟循环都从数列的前两个元素开始进行比较，比较到无序数组的最后；

            for (int j=0; j<values.length-1-i;j++){

                //如果前一个元素大于后一个元素，则交换两元素的值；

                if (values[j] > values[j+1]){

                    temp = values[j];

                    values[j] = values[j+1];

                    values[j+1] = temp;

                    //本趟发生了交换，表明该数组在本趟处于无序状态，需要继续比较；

                    flag = false;

                }

            }



            //根据标记量的值判断数组是否有序，如果有序，则退出，无序，则继续循环；

            if (flag){

                break;

            }

            System.out.println((i+1)+"趟排序:"+ Arrays.toString(values));

        }

    }

}

2.二分法查找：

package TestJavaSE;

import java.util.Arrays;

//二分法查找；（折半查找）

public class BinarySearchTest {

    public static void main(String[] args) {

        int[] arr = {30,20,50,10,80,9,7,12,100,40,8};

        int searchWord =40;//所要查找的数；

        Arrays.sort(arr);//二分法查找之前，一定要对数组元素先进行排序！！！



        System.out.println(Arrays.toString(arr));

        System.out.println(searchWord+"元素的索引："+binarySearch(arr,searchWord));

    }

    public static int binarySearch(int[] array,int value){

        int low = 0;//low--high是查找区间，low开始位置，high结束位置；

        int high = array.length - 1;

        while(low <= high){

            int middle = (low+high) / 2;

            if(value == array[middle]){

                return middle;

            }

            if (value < array[middle]){

                high = middle-1;

            }

            if (value > array[middle]){

                low = middle + 1;

            }

        }

        return -1;//如果array数组中没有要查找的value值，则返回-1；

    }

}

38.import包名导入：

java会默认导入java.lang包下所有类，因此这些类我们可以直接使用

如：Math类、Object类、String类、StringBuffer类、Integer包装类、 Class类

如果导入两个不同包中的同名的类，只能用包名+类名来显示调用相关类：

如：java.util.Date data = new java.util.Date();

39.Integer包装类

方法	返回值	功能描述
byteValue()	byte	以 byte 类型返回该 Integer 的值
intValue()	int	以 int 型返回此 Integer 对象
zebra stripes	are neat	以 int 型返回此 Integer 对象
toString()	String	返回一个表示该 Integer 值的 String 对象
valueOf(String str)	Integer	返回保存指定的 String 值的 Integer 对象
parseInt(String str)	int	返回包含在由 str 指定的字符串中的数字的等价数值

40.String类

String类

方法	返回值	功能描述
indexOf(int ch)	int	搜索字符 ch 第一次出现的位置
indexOf(String value)	int	搜索字符串 value 第一次出现的位置
lastIndexOf(int ch)	int	搜索字符ch最后一次出现的位置
lastIndexOf(String value)	int	搜索字符串 value 最后一次出现的位置
substring(int index)	String	提取从位置索引开始到结束的字符串
substring(int beginindex, int endindex)	String	提取beginindex和endindex之间的字符串部分
trim()	String	返回一个前后不含任何空格的调用字符串的副本，意思是把字符串前后的空格部分去除

StringBuffer类

StringBuffer 类是可变的。

方法	返回值	功能描述
insert(int offsetm,Object s)	StringBuffer	在 offetm 的位置插入字符串s
append(Object s)	StringBuffer	在字符串末尾追加字符串s
length()	int	确定 StringBuffer 对象的长度
setCharAt(int pos,char ch)	void	使用 ch 指定的新值设置 pos 指定的位置上的字符
toString()	String	转换为字符串形式
reverse()	StringBuffer	反转字符串
delete(int start, int end)	StringBuffer	删除调用对象中从 start 位置开始直到 end 指定的索引（end-1）位置的字符序列
replace(int start, int end, String s)	StringBuffer	使用一组字符替换另一组字符。将用替换字符串从 start 指定的位置开始替换，直到 end 指定的位置结束

Math类

方法	返回值	功能描述
sin(double numvalue)	double	计算角 numvalue 的正弦值
cos(double numvalue)	double	计算角 numvalue 的余弦值
acos(double numvalue)	double	计算 numvalue 的反余弦
asin(double numvalue)	double	计算 numvalue 的反正弦
atan(double numvalue)	double	计算 numvalue 的反正切
pow(double a, double b)	double	计算 a 的 b 次方
sqrt(double numvalue)	double	计算给定值的平方根
abs(int numvalue)	int	计算 int 类型值 numvalue 的绝对值，也接收 long、float 和 double 类型的参数
ceil(double numvalue)	double	返回大于等于 numvalue 的最小整数值
floor(double numvalue)	double	返回小于等于 numvalue 的最大整数值
max(int a, int b)	int	返回 int 型 a 和 b 中的较大值，也接收 long、float 和 double 类型的参数
min(int a, int b)	int	返回 a 和 b 中的较小值，也可接受 long、float 和 double 类型的参数
rint(double numvalue)	double	返回最接近 numvalue 的整数值
round(arg)	arg 为 double 时返回 long，为 float 时返回 int	返回最接近arg的整数值
random()	double	返回一个介于0与1之间的伪随机数

Object类

方法	返回值	功能描述
equals(Objectobj)	boolean	将当前对象实例与给定的对象进行比较，检查它们是否相等
finalize() throws Throwable	void	当垃圾回收器确定不存在对象的更多引用时，由对象的垃圾回收器调用此方法。通常被子类重写
getClass()	Class	返回当前对象的 Class 对象
toString()	String	返回此对象的字符串表示
wait() throws InterruptedException	void	使当前线程进入等待状态

未掌握的知识点

Window 10 截图快捷键：Win+Shift+S组合键

System.eixt(0);退出当前系统。
return 退出当前方法体，但不是退出系统。
当调用与被调用的方法在同一个类中，即调用本类的方法时，用this.方法名。千万不要实例化对象去调用。
调用collections工具类中的sort（1,2）方法，1中填入容器名，2中填入比较器对象；

如：collections.sort(this.list,new OrderByName());

类中定义了含参的构造方法，记得一定要放一个无参的构造方法。

/**
 * 未掌握知识点：在main方法中，因为main方法是static静态方法，
 * 而静态方法不能直接调用非静态方法，所以调用本类的非静态方法时不能用this调用
 * 而要实例化对象来调用
 */

7.

/**未掌握：1.正则表达式是一个String对象的字符序列，所以对象只能是String类型,而
 *         且matches（）也只能对String类型进行比较
 *       2.将Scanner对象定义在方法中，对象随着方法的死亡而死亡，定位全局变量的话，
 *       随着类的凋亡而凋亡，浪费空间，所以应在方法中创建Scanner对象。
 *       3.将String类型转为int类型，通过包装类中的parseInt（）方法：
 *       如：int num = Integer.parseInt（input）；
 */

8.

/**
 * 未掌握知识点：
 * 正则表达式中：[1-9][0-9]和[1-9]{1}[0-9]{1}一样的意思，都是输入两个数！
 * @return
 */

9.

/**
 * 未掌握知识：这里的电话用String类型，因为int类型的话，
 * 电话号的数值会溢出，而且座机号有-，int类型不支持，所以要用String类型
 * @return
 */

10.

/**
 * 未掌握知识点：list容器有索引，从0开始
 * list.get()方法获取元素
 */