java知识点

声明：如有错误，还请诸位指出，谢谢~

————————————————————————————————————————

预习：Java语言基础

1. Scanner s = new Scanner(System.in);
   //System.in表示标准输入，通常指从键盘输入数据；
   //System.out表示标准输出，通常指把数据输出到控制台或者屏幕；
   //System.err表示标准错误输出，通常指把数据输出到控制台或者屏幕。

2. System.out.println();//末尾换行
   System.out.print();//末尾不换行
   System.out.printf();//格式化输出

3. 【正确】The JVM will translate byte code into native code at class loading.
   （JVM将在类加载时将字节代码转换为本机代码）

4. 【正确】 Each instruction is one byte only.(每条指令只包含一个字节。) 字节码指令详解
   【正确】Byte code machine is a stack machine rather than a register machine.
   （字节码机是堆栈机，而不是寄存器。）
   （JVM是基于栈的虚拟机）
   【正确】Languages other than Java can be compiled into byte code.

5. 【正确】The compiler generates native code for JIT JVM.
   (编译器为JIT JVM生成本机代码。)

6. 【正确】The garbage collection will check for and free memory no longer needed.
   （垃圾回收将检查并释放不再需要的内存。）

7. Java语言的特点：面向对象、可移植、解释型

8. 【正确】.java文件编译后，每一个class对应一个.class文件
   【正确】Java源代码编译后产生的.class是字节码文件
   【正确】.class文件在JVM上运行

9. 在windows平台上安装配置JDK时，正确的是：
   设置path的作用是指定命令搜索路径；
   设置CLASSPATH的作用是指定类搜索路径；
   javac的功能是编译出 .class文件；
   假设JDK的安装位置是：c:\java，那么应在path中加入下面的数据项：c:\java\bin

10. 一个计算机上安装JDK后，计算机包含：JRE、JVM、javac.exe。

11. 【正确】int is always 32-bit on different platforms（一个Int在不同的平台上总是32位的）

12. float a = 2.0f//定义float型时，末尾一定要加f。

13. double a=2.0//定义double类型时，不用加东西。

14. Java语言采用Unicode编码标准，每个Unicode码占16个比特。它为每个字符制订了一个唯一的数值，因此在任何的语言，平台，程序都可以放心的使用。

15. 下面那个数据类型不属于原子数据类型？A.boolean B.char C.String D.byte
    （这里的源自数据类型指的是基本数据类型，String不是基本数据类型，所以C错误）

16. int类型数据的范围是 -2147483648 ~ 2147483647

17. MAX=Integer.MAX_VALUE//可以求int类型的最大值

18. Java的各种数据类型占用固定长度，与具体的软硬件平台环境无关。

19. Java语言中，变量名可以用汉字表示。

20. 字节码文件是与平台无关的二进制码，执行时由解释器解释成本地机器码。

21. 一个Java源文件中可以有多个类，但只能有一个类是public的。

22. 如果Java源文件中包含了多个类，那么用编译器javac编译完源文件后将生成多个扩展名为.class的文件。

23. boolean型数据的值只有true和false。

—————————————————————————————————————

实验一：Java语言基础

1. Java的switch语句中的变量类型只能为byte、short、int、char或者String类，不能是boolean。

2. break Loop1;//表示一次跳出Loop1：下面的循环体。不论有几层循环，都可以直接一次性跳出。

3. 将字符串s转换为double类型的值d的语句（三种方法都可以）：
   d = Double.parseDouble(s);
d = (new Double(s)).doubleValue();
d = Double.valueOf(s).doubleValue();

4. Java中，如果基本数据没有初始化，它会自动初始化。
   基本数据类型：
   boolean—— false
   char —— []（即null）
   byte —— 0
   short —— 0
   int —— 0
   long —— 0
   float —— 0.0f
   double —— 0.0
   引用数据类型：初始化为null，例如String类

5. 重载：方法名相同，但是参数的类型和个数不同

6. public static void main(String[] args){}，若在此方法（函数）里面写其他方法（函数），必须写static，public可写可不写。
   （写public指：所修饰的成员可以在任何类中都能被访问到。）

7. in.hasNextInt(); //注意：in.hasNextInt()只进行判断，不读取
   in.hasNextDouble();//判断是否是实型

8. System.exit(0);//结束整个程序

9. String[] s = str.split(",");//字符串以","进行分割，返回字符串数组

10. str1==str2;//判断字符串的地址是否一样；
    str1.equals(str2);//判断字符串的内容是否一样

11. enum Grade { A,B,C,D,E; }//定义一个枚举类型，通过Grade.A进行访问。
    System.out.println(Grade.classs);//class是一个类的属性，用来说明该类的一个对象，直接调用就可以了。

12. eclipse在编写代码的时候，就进行了编译。
    运行的时候，才产生的错误是运行时错误。

—————————————————————————————————————

实验二：面向对象基础——类和对象

1. 关于封装与信息隐蔽:
   A.在类外不能直接访问私有数据成员，但能通过调用公有成员函数引用、修改私有数据成员。
   B.如果想修改或扩充类的功能，只需修改本类中有关的数据成员和与它有关的成员函数的实现，而关于该类的对象创建，成员函数调用等类外的代码部分可以不必修改。
   C.如果在编译时发现类中的数据读写有错，不必检查整个程序，只需检查本类中访问这些数据的少数成员函数即可。
   D.在设计类时，一般将数据成员声明为私有的，用set()、get()方法存取数据。

2. 关于final关键字：
   A.使用final声明的类不能有子类
   B.使用final声明的方法不能被子类所覆盖
   C.使用final声明的变量即为常量
   D.使用final声明的类能被实例化

3. 一个*.java文件中最多含有一个public类。

4. 在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同，这种面相对象程序特性称为（重载 ）。

5. 下面（ static）修饰符修饰的变量是所有同一个类生成的对象共享的。

6. 一个对象是（ 类 ）的实例。

7. 现有声明Circle x = new Circle()，这句是最确切的：x包含了一个Circle对象的引用。

8. 设计类时：
   定义私有属性：变量加了private，后面只能通过set和get函数设置和访问；
   static a=0;//定义一个全局变量
   无参构造方法：public 类名(){};//里面最好定义一个无参数的构造方法（防止后面出错）；
   含参构造方法：public 类名(){int a};//定义一个所有参数都初始化的构造方法;用到关键字this;
   set()方法：用来存私有属性的值，不能加static
   get()方法：用来取私有属性的值，不能加static
   toString()方法：返回字符串
   类的静态初始化块:static{语句;}
   类的初始化块：{语句;}

9. 执行先后顺序：类的静态初始化块–>构造方法–>类的初始化块

—————————————————————————————————————

实验三：面向对象基础——字符串

1. str.length();//求字符串的长度，后面有括号
   arr.length;//求数组长度，后面没有括号
2. split()分割后，原字符串不变
3. 要求字符串str里面不能含有非数字字符
   num=Integer.parseInt(str);
num=Integer.valueOf(str);
4. str=str.trim();//删除头尾空白符的字符串。ps：不能删除中间的字符串
5. char[] s=str.toCharArray();//字符串变成单个字符数组
6. String类的字符串不能通过下标访问单个字符，即不能String s="Hello";char c=s[0];//会编译错误
7. 可以通过str.charAt(index)访问字符串的某个字符，但是不能通过它改写字符。即只能访问不能改写。
8. StringBuilder类的字符串反转reverse()方法：
   StringBuffer bu=new StringBuffer(str);
str=bu.reverse().toString();
9. 英文字母大写转小写用加法：c +='a'-'A';
   英文字母小写转大写用减法：c -='a'-'A';
10. String newstr = str.toLowerCase();//使用toLowerCase()方法实现小写转换
    String newstr2 = str.toUpperCase();//使用toUpperCase()方法实现大写转换
11. /*从字符串中提取数字 */

public static String getNumeric(String str) {
    str=str.trim();
    String str2="";
    if(str != null && !"".equals(str)){
        for(int i=0;i<str.length();i  ){
            if(str.charAt(i)>=48 && str.charAt(i)<=57){
                str2 =str.charAt(i);
            }
        }
    }
    return str2;
}

12. StringBuffer sb=new StringBuffer("");
sb.append(i);//在字符串的后面追加元素i;
    sb.insert(6,"-");//在下标为6的位置插入字符’-’
    str= sb.toString();//转化为字符串str

13. 字符串只比较内容是否一样用：str.equals(str1);
    字符串忽略大小写比较：public boolean equalsIgnoreCase(String anotherString);

14. in.nextLine();//可以过滤回车

15. str1=str.substring(6,14);//字符串截取：原始数组str并没有变

16. Arrays.sort(b);//数组排序，默认由小到大

17. str1.contains(str2)//字符串str1是否包含字符串str2，返回true或false

18. StringBuffer默认初始化的容量确实是16个字符。原因猜测：作者在平常使用过程中很少使用到16个字符以上的内容。8太小，易造成频繁扩容；32太大，扩容损耗大；权衡之后就去了16吧。StringBuffer在容量不够时会进行扩容操作。容量扩大为capacity*2+2在可以预估长度时，给个较大值，防止扩容导致频繁数组拷贝，产生内存垃圾
    【作者：郭里奥-------链接：https://www.zhihu.com/question/283546127/answer/432716437】

19. 【正确】构造代码块和静态代码块位置相同，区别在于静态代码块用static关键字修饰。

在这里插入代码片

—————————————————————————————————————

实验四：面向对象高级—继承和多态

1. 对于类的成员而言，其能否被其他类所访问，取决于该成员的修饰词；而对于一个类而言，其能否被其他类所访问，也取决于该类的修饰词。在Java中，类成员访问权限修饰词有四类：private，无（包访问权限），protected 和 public，而其中只有包访问权限和public才能修饰一个类（内部类除外）。
   public ：被public修饰的类成员能被所有的类直接访问；
   private：被public修饰的类成员只能在定义它的类中被访问，其他类都访问不到。特别地，我们一般建议将成员变量设为private的，并为外界提供 getter/setter 去对成员变量进行访问，这种做法充分体现了Java的封装思想；
   protected：被protected修饰的成员对于本包和其子类可见。
   包访问权限：包访问权限就是Java中的默认的权限，具有包访问权限的类成员只能被同一包中的类访问。
2. super.toSring();//调用父类的toString( )方法
3. public static String getType(Object obj){return obj.getClass().getSimpleName();}//此方法可以返回对象的类名
4. 上转型后的变量不能调用子类特有的方法，只能调用子类、父类共有的方法。
5. 判断一个类是否是其子类：
   System.out.println(man instanceof Person);//man是否是Person的子类(true||false)
   System.out.println(Person.class.isAssignableFrom(Man.class));//Person是否是Man的父类(true||false)

————————————————————————————————

实验五：抽象类和接口

1. Math.sqrt(number);//给number开平方；
2. 在类中实现接口中方法的时候，不要写abstract，会出错；
3. eclipse快速生成相应方法：鼠标右键（或者Alt+Shift+S）–> Source -->
   Override/Implement Methods：快速生成要重写的方法框架
   Generate Getters and Setters：快速生成set和get方法
   Generate toString()：快速生成toString方法
   Generate Constructors using Fields：快速生成含参构造方法
   Generate Constructors from Superclass：快速生成无参构造方法
4. Shape[] shapes=new Shape[n];//注意：抽象类可以声明一个给定长度n的数组
5. 抽象类的特点：
   ①abstract修饰类名；
   ②抽象类中不可以出现finial，会报错的。
   ③抽象类不能被实例化，只能派生子类；
   ④抽象类可以有构造方法；
   ⑤抽象方法必须存在于抽象类中；
   ⑥不能用abstract修饰构造方法、静态方法、私有方法（private）；
   ⑦如果其子类不是抽象类，那么必须重写抽象类中的全部抽象方法
   ⑧抽象类中的抽象方法只能声明，不能有方法体；但是抽象类中的一般方法可以有方法体。
   public abstract void print1();//因为被abstract修饰，只能声明，不能有方法体。
public void print2() {//没有abstract修饰，所以可以有方法体。
System.out.print("合理");
}
6. 理解抽象类的关键点：
   ①抽象类是对同一类事物的抽象，抽象出子类共有的行为，该行为标准用抽象方法表示。即抽象类封装了子类必须有的行为。
   ②抽象类声明的对象可以成为其子类的对象的上转型对象，调用子类重写的方法，既体现子类根据抽象类里的行为给出具体的行为。
   Animal one = new Dog();//可以向上转型
one.cry();//调用子类Dog的对象方法
7. 接口的特点：
   ①接口中定义常量必须是public static finial，这是系统默认的规定，所以常量也可以没有任何修饰符。
   例如：
   interface A{
int a=0 ;
//常量a，这样写是合法的，因为系统默认public static finial，所以可以没有任何修饰符
}
   ②接口中只有方法声明，而无方法实现，接口中声明的方法是public abstract，也是系统默认的规定。
   ③接口内部只能定义public的抽象方法和静态的公有常量，因此所有方法必须在子类中实现。
8. 接口与类的不同在于：
   ①接口没有变量的声明，但可以定义常量；
   ②接口只有方法的声明，没有方法的实现；
   ③子接口继承父接口中所有的常量和方法；接口中没有自身的构造方法；
   ④ 一个接口可以有多个父接口，用逗号分开，而类只能有一个父类（单继承）；
9. 抽象类不用全部实现接口中的所有方法,其余的方法实现可以交给该抽象类的子类去实现即可。

在这里插入代码片

—————————————————————————————————————

实验六：异常处理、泛型和集合框架

1. 

2. Set接⼝主要两个实现类为HashSet、TreeSet：
   HashSet：元素唯一、无序
   TreeSet：元素唯一、有序（自然排序、自定义排序）

在这里插入代码片

—————————————————————————————————————

实验七：多线程