程序的基本结构

1
2
3
4
5
6
public class hello{
    public static void main(string[] args)
    {
        System.out.println("Hello,world!");
    }
}

java是面向对象的语言，程序的基本单位是class，class是关键字

类名必须以英文字母开头，后接字母、下划线和数字组合

public是访问修饰符，表示公有，而static修饰符表示静态方法，方法名是main，参数是string数组

数据类型

基本数据类型

1.整数类型:byte、short、int、long

2.浮点数类型:float、double

3.字符串类型:char

4.布尔类型:boolean

这里注意一下float与double类型的区别

1
2
3
float f1 = 3.14f;
float f2 = 3.14e38f;
float f3 = 1.0(不带f结尾表示double，不能复值给float);

boolean只有true和false两个值

引用数据类型

除了上面几个都是引用数据类型

常见的是String字符串

常量

加上final修饰符

var关键字

类似于auto，省略变量类型可用var

整数运算

1.四则运算(补码溢出)

2.移位

3.自增自减

符号优先级

  • ()
  • !,~,++,–
  • *,/,%
  • +,-
  • <<,>>,>>>（无符号的右移）
  • &
  • |
  • +=,-=

字符和字符串

转义字符

\“ ,\‘ ,\, \n, \r, \t（水平制表）

数组（本质上是个对象）

一般以”类型[]”表示数组，必须初始化创建一个数组

例如

1
int[] ns = new int[5];

表示创建5个int元素的数组

1
int[] ns = new int[]{1,2,3,4}

也可简写为

1
int[] ns = {1,2,3,4}

特点

  • java数组有默认值，例如整形都是0，浮点型0.0，布尔型是false

  • 数组一旦创建大小不可变

可以通过数组变量.length获取数组大小

对于基本数据类型的数组，修改值就是直接修改对应的值，而引用数据类型的数组，修改值是将，指向a元素的指针指向b元素，a元素仍在内存中

输入与输出

1
2
3
4
5
6
7
8
9
public class Main{
    public static void main(String[] args)
    {
        System.out.print("man");
        System.out.print("man");

    }
}

一般的使出System.out.print是输出但是不换行，而println方法是输出并换行

格式化输出(计算机的输出不一定适合人类阅读，所以要进行格式化输出)

输出

1
2
3
4
5
6
7
8
9
public class Main{
    public static void main(String[] args)
    {
        double d = 3.14159;
         System.out.printf("%2.2f",d);

    }
}

占位符有%d,%x,%f,%e,%s

1
%[argument_index$][flags][width][.precision]conversion

[argument_index$]例如1$表示使用第一个参数

输入

1
2
3
4
5
6
7
8
import java.util.Scanner;
public  class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        System.out.println(name);
    }
}

一般使用Scanner类，以System.in(字节流)作为参数scanner.nextLine()读取用户输入的下一行字符串，读取下一个整数用scanner.nextInt()

if条件判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.Scanner;
public  class Main{
    public static void main(String[] args) {
       int a;
       Scanner scanner = new Scanner(System.in);
       a = scanner.nextInt();
       if(a>=90)
       {
           System.out.println("算你强");
       }
       else if(a>=80)
       {
           System.out.println("算你过关");
       }
       else{
           System.out.println("杂鱼喵");
       }
    }
}

判断引用类型相等

判断值类型变量变量可以用==,但是引用数据类型==表示引用是否相等，所以一下内容相同但是false

1
2
3
4
5
6
String s1 = "hello";
String s2 = "HELLO".toLowerCase();
if(s1==s2)
{

}

判断引用数据类型的内容是否相等要用equals()方法

1
if (s1.equals(s2))

如果s1是null会报错NullPointerException

避免可以s1!=null&&s1.equals(s2)

经典的switch - case函数(多重选择)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Main {
    public static void main(String[] args) {
        int a = 1;
        switch(a)
        {
            case 1:
                System.out.println("一破卧龙出山");
                break;
            default:
                System.out.println("天下莫敌");
        }
    }

}

注意case与具有穿透性，所以要加上break

switch还可以匹配字符串，比较的是内容相等(这与c++不同)

循环

while(条件){}

do{}while(条件)

for(初始条件;循环检测条件;循环后执行)

break能够结束循环，continue提前结束本次循环直接进入下次循环

数组操作

遍历数组

一种是直接for循环遍历

ns.length表示数组的大小

二是for-each(增强for循环)，和c++基于范围的for循环很相似

1
2
3
4
5
6
7
8
9

public class Main {
    public  static  void main() {
        int[] arry = {1, 2, 3, 4, 5};
        for (int n : arry) {
            System.out.println(n);
        }
    }
}

最简单的Arrays.toString()快速打印内容

1
2
3
4
5
6
7
8
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 1, 2, 3, 5, 8 };
        System.out.println(Arrays.toString(ns));
    }
}

如果直接打印ns数组System.out.println(ns);得到的是ns数组在jvm的引用数组

因此直接打印数组全部用Arrays.toString()

数组排序

冒泡排序

经典冒泡，将最大的数据放在最后面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
       int[] ns = {80,65,100,799, 2632, 8};
       System.out.println(Arrays.toString(ns));
       for(int i = 0;i<ns.length-1; i++)
       {
           for(int j = 0;j<ns.length-i-1;j++)
           {
               if(ns[j]>ns[j+1])
               {
                   int temp = ns[j];
                   ns[j] = ns[j+1];
                   ns[j+1] = temp;
               }
           }
       }

       System.out.println(Arrays.toString(ns));
    }
}

但是标准库已经内置排序了

1
Arrays.sort(ns);