JavaSE基础知识点整理

古城微笑少年丶 2023-09-28 05:38 16阅读 0赞

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型。

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

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

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

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

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

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

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

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

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

15.java中的内存机制：

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

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

16.static静态：

1.  static方法只能调用静态（即static）成员变量和方法，不能调用非静态 成员变量和方法；
2.  \*\*\*静态初始化块，用于类的初始化操作，初始化静态属性（即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）：

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

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

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

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

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.内部类：

1.  内部类的两个要点：

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

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

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

30.成员变量访问要点：

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

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

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

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

**32.静态内部类：**

**Static class ClassName\{**

**//类体**

**\}**

**使用要点：**

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

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

33.数组：

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

1.  Array.toString(数组名)、
2.  Array.fill(开始下标，结束下标，数据替代值)、
3.  Array.binarySearch（数组名，要查找的数据值）
4.  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.  （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包名导入：

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

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

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

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

**39.Integer包装类**

####  ####

#### **40.String类** ####

**String类**

**StringBuffer类**

StringBuffer 类是可变的。

#### **Math类** ####

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

#### **Object类** ####

##  ##

## **未掌握的知识点** ##

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

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

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

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

/**
     * 未掌握知识点：在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()方法获取元素
     */