JAVA基础
JAVA运行机制
1、.java文件先被编译器编译成.class文件
2、然后.class文件被虚拟机编译成机器码
3、然后在操作系统上运行
注释
//单行注释
快捷键 ctrl + /
多行注释
/*
多行注释
多行注释
*/
快捷键 ctrl + shift + /
文档注释
/**
* @author crestashi
* @version 1.0
*/
Scanner
public static void main(String[] args) {
// 实例化Scanner对象
Scanner scanner = new Scanner(System.in);
// 判断是否有输入
if (scanner.hasNextLine()){
String str = scanner.nextLine();
System.out.println(str);
}
// 关闭Scanner，避免浪费资源
scanner.close();
}
增强for
public static void main(String[] args) {
// 增强for
String[] strings = new String[]{"张三","李四","王五"};
for (String str:strings) {
System.out.println(str);
}
// 增强for就是foreach
}
方法重载
1、方法名相同，参数类型不同
2、参数个数不同
可变参数
public class Demo {
// 可变参数
public static void main(String[] args) {
Demo demo = new Demo();
double max = demo.getMax(23, 12, 23, 34, 56);
System.out.println(max);
}
public double getMax(double i,int... x){
if (x.length == 0){
return i;
}
double result = i;
for (int j = 0; j <x.length; j++) {
if (result < x[j]) {
result = x[j];
}
}
return result;
}
}
递归
public class Demo {
// 使用递归方法求阶乘
public static void main(String[] args) {
Demo demo = new Demo();
int f = demo.f(5);
System.out.println(f);
}
public int f(int x){
if (x==1){
return 1;
}else {
return x*f(x-1);
}
}
}
数组
- 数组是相同类型数据的有效集合
- 数组一但被创建，长度就不可改变
- 数组中存放的元素必须相同
- 可以存放基本数据类型，也能存放引用类型
- 操作数组的类java.util.Arrays
冒泡排序
public class Demo {
// 冒泡排序
public static void main(String[] args) {
Demo demo = new Demo();
int[] sort = demo.sort(new int[]{12, 23, 2, 45, 13, 45});
for (int num : sort) {
System.out.println(num);
}
}
public int[] sort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
for (int j = i + 1; j < array.length; j++) {
if (array[i] > array[j]) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
return array;
}
}
稀疏数组
public class Demo {
// 稀疏数组
// 0代表空 1代表白棋 2代表黑棋
public static void main(String[] args) {
// 棋盘
System.out.println("初始棋盘");
int[][] array1 = new int[11][12];
array1[1][2] = 1;
array1[2][3] = 2;
for (int[] hang : array1) {
for (int num : hang) {
System.out.print(num + "\t");
}
System.out.println();
}
System.out.println("==========================");
// 将数组压缩为稀疏数组进行存储
// 获取有效数字个数
int sum = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[0].length; j++) {
if (array1[i][j] != 0) {
sum++;
}
}
}
System.out.println("有效值的个数是：" + sum);
// 申明稀疏数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = array1.length;
array2[0][1] = array1[0].length;
array2[0][2] = sum;
// 遍历棋盘有效值放进稀疏数组
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[0].length; j++) {
if (array1[i][j] != 0) {
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
// 遍历稀疏数组
System.out.println("稀疏数组");
for (int[] hang : array2) {
for (int num : hang) {
System.out.print(num + "\t");
}
System.out.println();
}
// 将稀疏数组还原为棋盘
int[][] array3 = new int[array2[0][0]][array2[0][1]];
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
System.out.println("======================");
// 遍历还原后的数组
System.out.println("还原的棋盘");
for (int[] hang : array3) {
for (int num : hang) {
System.out.print(num + "\t");
}
System.out.println();
}
}
}
static
被static修饰的属性或方法，被称为静态属性和静态方法，静态属性和静态方法可直接通过类名.访问
异常处理机制
- 处理方式1 try catch finally
- 处理方式2 throws throw
try catch finally 是真正的处理异常，然后程序正常执行
throws throw是抛出异常
