Java入门 - 01 Java基础相关

Java基础相关

目录

• Java基础相关
  • • 前言
    • 1. 变量类型
    • 2. Scanner
    • 3. 数组
    • 4. 基础Dos指令
    • 5. 其它知识点

前言

本文为B站Java教学视频BV1Kb411W75N的相关笔记，主要用于个人记录与分享。如有错误欢迎留言指出。

本章笔记涵盖视频内容P40 ~ P173

1. 变量类型

1. 赋值long型变量，必须以"l"或"L"结尾，一般整型变量使用int

   赋值float型变量，必须以"f"或"F"结尾，一般浮点数变量使用double

   可以将"数字"理解为特殊的字面量，而这些后缀是针对数字的"强制类型转换"。整数的数字默认类型是int，浮点数的数字默认类型是double，如果需要使用long或float类型就需要这种特殊的"强制类型转换"。

   但是注意double和float型变量仍可以接收整数(见下方第三段例子)，能接收的原因可能是编译器自动进行了调整和转化。在操作的时候还是建议添加小数点区分整数和浮点数。

int number = 1000000000000000; //报错,超出int上限
long number = 1000000000000000; //报错,超出int上限(这里的int是字面量'1000...'的类型)
long number = 1000000000000000l; //正确

float number = 2.2;	//报错,2.2‘字面量’赋予的是double类型,不能用float接收
float number = 2.2f;//正确

double = 2;	//正确
float = 2f;	//正确
float = 2;	//正确

2. Java在boolean类型的使用上和C有些许不同：

boolean bb1 = true;
System.out.println(bb1);

​ 这样输出的值是"ture"而不是"1"，与C中1代表true，0代表false不同。这样带来的最大改变就是在Java中程序员无法再和C一样单纯的用1/0来作为判断条件，而是需要严格的使用boolean类型

while(1){	//无法作为判断条件
    //...
}

while(true){//可以作为判断条件
    //...
}

3. 当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型

总共可以归结为以下情况：

1. 所有的byte型,short型和char型在运算时（包括同类型之间运算）都将被提升到int类型（注：使用++/+=/*=等运算符时不会被自动提升）
2. 如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。
   否则，如果其中一个操作数是float类型，另一个将会转换为float类型。
   否则，如果其中一个操作数是long类型，另一个会转换为long类型。
   否则，两个操作数都转换为int类型。

   char a = 'a';
   char b = 'b';
   a = a + b; //不正确,(a+b)自动提升为int类型
   a = a + 1; //不正确,(a+1)自动提升为int类型
   a++; //正确,++运算符不改变类型
   
   long a = 10000000000l;
   float b = 2.0f;
           
   a = b + a; //错误,(a+b)自动提升为float类型
   b = a + b; //正确

4. String类型可以和8种基本数据类型变量做运算，且运算只能是连接运算（+），运算的结果仍然是String类型；按照从左到右的运算顺序，若运算的双方中有一方为String类型，则计算结果为String类型；若无，则变量之间自动转换

char c = 'a';
int num = 10;
String str = "hello";
System.out.println(c + num + str);	//107hello
System.out.println(c + str + num);	//ahello10
System.out.println(c + (num + str));//a10hello
System.out.println((c + num) + str);//107hello
System.out.println(str + num + c);	//hello10a

//String允许如下写法：String s1 = "";	√
//char则不允许如下写法：char c1 = '';   ×

2. Scanner

• Java中的Scanner相当于C中的scanf，但是存在许多不同

• Scanner使用步骤：

  1. 导包:import java.util.Scanner;
  2. Scanner实例化:Scanner scan = new Scanner(System.in);
  3. 选择合适的相关方法:String name = scan.next();

//导包，相当于C中的头文件
import java.util.Scanner;	

class ScannerTest{
    
    public static void main(String[] args){
        
        //Scanner的实例化
        Scanner scan = new Scanner(System.in);
        
        //调用Scanner类的相关方法(next()/nextXxx())，来获取指定类型的变量
        String name = scan.next();
        System.out.println(name);
        
        int age = scan.nextInt();
        System.out.println(age);
        
        double weight = scan.nextDouble();
        System.out.println(weight);
        
        boolean judge = scan.nextBoolean();
        System.out.println(judge);
        
        //对于char型的获取，Scanner没有提供相关的方法，只能获取一个字符串
        String gender = scan.next();
        //但是使用charAt()可以获取字符串上指定索引位置上的字符
        char genderChar = gender.charAt(0);//获取索引为0位置上的字符
    }
}

//需要根据相应的方法，输入指定类型的值，如果输入的数据类型与要求的类型不匹配时，会报异常InputMisMatchException()导致程序终止

3. 数组

• 数组属于引用数据类型的变量。数组的元素既可以是基本数据类型，也可以是引用数据类型。

1. 一维数组的声明和初始化

   int[] ids; //声明
   //静态初始化:数组的初始化和数组元素的赋值操作同时进行
   ids = new int[]{1001,1002,1003,1004};
   //动态初始化:数组的初始化和数组元素的赋值操作分开进行(这里声明也一起做了)
   String[] names = new String[5];
   

2. 获取数组的长度

   //java中的数组自带测量自身长度的属性
   System.out.printfln(names.length);
   System.out.printfln(ids.length);
   

3. 数组元素的默认初始化值：

   • 与C不同，java的数组从创建的时候就已经有了初始值，根据数组元素不同初始化值也不同

     数组内数据类型	初始值
     整型	int
     浮点型	float
     char型	0（此处是ASCII表中的0，相当于C中的空字符\0）
     boolean型	false
     引用数据类型	null

4. 二维数组的声明和初始化

   //静态初始化
   int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
   //动态初始化
   String[][] arr2 = new String[3][2];
   String[][] arr3 = new String[3][];
   

5. 获取数组长度

   System.out.println(arr1.length);	//输出3
   System.out.println(arr1[1].length); //输出2
   //arr1的长度是指其包含了多少个数组
   //arr1[1]的长度是指索引值为1的数组包含了多少个元素
   

6. 数组元素的默认初始化值：

   /*
   对于int[][] arr = new int[4][3]
   	外层元素的初始化值为：地址值
   	内层元素的初始化值为：与一维数组初始化相同
   对于int[][] arr = new int[4][]
   	外层元素的初始化值为：null
   	内层元素的初始化值为：不能调用，否则报错
   */
   

7. Arrays工具类的调用

   //1.boolean equals(int[] a,int[] b):判断两个数组是否相等
   int[] arr1 = new int[]{1,2,3,4};
   int[] arr2 = new int[]{1,3,2,4};
   boolean isEquals = Arrays.equals(arr1,arr2);
   System.out.println(isEquals);
   
   //2.String toString(int[] a):输出数组信息
   System.out.println(Arrays.toString(arr1));
   
   //3.void fill(int[] a,int val):将指定值填充到数组中
   Arrays.fill(arr1,10);
   System.out.println(Arrays.toString(arr1));
   
   //4.void sort(int[] a):使用快速排序算法对数组排序
   Arrays.sort(arr2);
   System.out.println(Arrays.toString(arr2));
   
   //5.int binarySearch(int [] a,int key):使用二分查找查找指定值,返回下标
   int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
   int index = Arrays.binarySearch(arr3,210);
   if(index >= 0){
       System.out.println(index);
   }else{
       System.out.println("未找到");
   }
   

8. 数组中的常见异常

   //1.数组下标越界异常：ArrayIndexOutOfBoundsException
   
   //2.空指针异常：NullPointerException
   //情况一：
   int[] arr1 = new int[]{1,2,3};
   arr1 = null;
   System.out.println(arr1[0]);
   
   //情况二：
   int[][] arr2 = new int[4][];
   System.out.println(arr2[0][0]);
   
   //情况三：
   String[] arr3 = new String[]{"AA","BB","CC"};
   arr3[0] = null;
   System.out.println(arr3[0].toString());
   

4. 基础Dos指令

• dir : 列出当前目录下的文件和文件夹
• md : 创建目录
• rd : 删除目录
  • 只能用于删除空的目录，如果目录内有文件则不能删除
• cd : 进入指定目录
  • 进入某一盘的时候直接输入盘符即可，不用cd，例如进入D盘 直接d: 而非 cd d:
  • 要跨越多层目录进入指定目录可以使用输入路径的方法，例如cd new\new_a\b
• cd.. : 退回到上一级目录
• cd\ : 退回到根目录
• del : 删除文件
  • 要删除目录下某一类型的文件，使用del *.[文件后缀名]的格式，例如del *.txt删除当前目录下所有txt文件
  • 对着目录(文件夹)使用del会将文件夹内部所有文件删除(但不会删除文件夹本身)
• exit : 退出dos命令行
• 键盘↑ ↓ 键,查看历史操作指令

5. 其它知识点

1. 获取随机数的代码为Math.random(),返回值为double类型，返回值范围为[0.0,1.0)

//公式：[a,b]:(int)(Math.random()*(b-a+1)+a)
int value = (int)(Math.ranodm()*90+10);

2. 判断字符串内容的代码为val.equals("xxx")

String isHuman = scan.next();
if(isHuman.equals("是"))
	System.out.println("Yes");

//一定不要写成下列形式！
if(isHuman == "是")	//这样比较的是两者的地址，永远不会相等！

3. 计算程序运行时间的方法：

   • System.currentTimeMillis();返回当前时间距离1970.1.1 00:00:00的毫秒数
   • 在开头结尾分别创建start和end变量然后相减就可以得出时间，一般使用long类型储存

long start = System.currentTimeMillis();

//......

long end = System.currentTimeMillis();

System.out.println(end - start);

//若执行所需时间过短则会显示0

4. 在Java中用break跳出循环或continue结束当次循环的时候，可以通过标签指定此break跳出的是哪一层循环。这一功能有些类似C的goto，虽然方便，但不建议在跳出多层循环以外的地方频繁使用，否则容易造成混乱。

label:
for(int i = 1;i <= 4;i++){
	for(int j = 1;j <= 10;j++){
		if(j%4==0){
			continue label;
		}
		System.out.print(j);
	}
	System.out.println();
}
  
//最终的输出结果为123123123,因为continue结束的是当前的外层循环

5. 取模运算（%）获得的结果的符号与被模数的符号相同（负数取模也得负数）。但是取模获得负数有悖数学常识，如果要获得正数的结果可以使用Math.floorMod()

6. &与&&，|与||作用是一样的，区别是&&和||具有短路特性。所谓短路特性就是当&&判断式第一项判断失败或||判断式第一项判断成功后，第二项不会再执行。这一特性在某些特殊的题目中可以用来替代递归和循环进行计算。

boolean a = false;
boolean b = true;

if(a && b){	//此时无论b是什么都不会被执行/判定
	//...
}

7. 命名规范：

   • 包名：多单词组成时所有字母都小写：xxxyyyzzz
   • 变量名，方法名：多单词组成时第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz（小驼峰命名法）
   • 类名，接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz（大驼峰命名法）
   • 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

8. Java程序编写-编译-运行的过程

   • 编写：将编写的代码保存在.java结尾的源文件中
   • 编译：使用javac.exe命令编译java源文件 格式：javac 源文件名.java
   • 运行：使用java.exe命令解释运行字节码文件 格式：java 类名 此处不用加文件类型

9. 在一个java源文件中可以声明多个class，但是只能最多有一个类被声明为public，且声明为public的类的类名必须与源文件名相同
   编译的过程：编译以后，会生成一个或多个字节码文件。字节码文件的文件名与java源文件中的类名相同。

public class HelloWorld {
	public static void main(String[] args){
	System.out.print("Hello World!");
	System.out.println(); //换行
	System.out.println("Hello World!");
	}
}

class Person{
}

class Animal{
}
//程序编译后会生成3个class文件