程序的基本结构

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));
}
}

但是标准库已经内置排序了Arrays.sort(ns);

多维数组

1
int [][] arry = {{1,2,3},{4,5,6}}

打印一个int的二维数组

1
2
3
4
5
6
7
for(int [] arr:arry)
{
for(int a:arr)
{
System.out.println(a);
}
}

命令行参数

1
2
3
4
5
6
7
8
9
10
public class Main{
public static void main(String[] args)
{
for(String arry:args)
{
if("-version".equals(arry))
System.out.println(arry);
}
}
}
1
javac Main.java

编译文件

1
java Main -version

运行文件

面向对象

1.方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Person{
private String name;
private int age;
public String getname()
{
return this.name;
}
public void setName(String name)
{
this.name = name;
}

}
public class Main {
public void main(){
Person a = new Person();
a.setName("ame");
System.out.println(a.getname());
}
}

字段设为私有的防止外部修改,这时就要将方法设为公有提供外部的接口

这里类中使用字段要this.field

private方法主要是类内调用

this变量

方法内部始终有this变量指向当前实例

若没有局部变量与字段冲突,可省略this

1
2
3
4
5
6
7
class Person {
private String name;

public String getName() {
return name; // 相当于this.name
}
}

但是如果有局部变量与字段冲突,局部变量的优先级更高,则必须加上this

1
2
3
4
5
6
7
8
class Person {
private String name;

public String setName(String name) {
this.name = name; // 相当于this.name
}

}

可变参数(本质就是一个数组)

1
2
3
4
5
6
class Person{
public void setname(String... names)
{
this.names = names;
}
}

2.构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Person{
private String name;
private int age;
public String getname()
{
return this.name;
}
public void setName(String name)
{
this.name = name;
}
public Person(String name, int age)
{
this.name = name;
this.age = age;
}

}
public class Main {
public void main(){
Person a = new Person("ame",5);
System.out.println(a.getname());
}
}

对字段进行初始化

1
2
3
4
5
public Person(String name, int age)
{
this.name = name;
this.age = age;
}

构造函数与类的名字相同

自定应构造函数的话编译器就不会创建默认构造函数,要使用只能在类定义中自己创建

若没有初始化字段,则引用类型的字段为null,数值类型的字段是默认值,int默认值为0,boolean默认值为false,当然也可以直接初始化

若即对字段初始化有执行了构造函数,则字段先初始化再执行构造函数

3.方法重载

根据参数的个数、顺序和类型判断使用哪个方法,不看别的

举个例子,String类提供了多个重载方法indexOf(),可以查找子串:

  • int indexOf(int ch):根据字符的Unicode码查找;
  • int indexOf(String str):根据字符串查找;
  • int indexOf(int ch, int fromIndex):根据字符查找,但指定起始位置;
  • int indexOf(String str, int fromIndex)根据字符串查找,但指定起始位置。
1
2
3
4
5
6
7
8
9
10
11
12
public class Main
{
public void main()
{
String test = "yileinatianxiadiyikeai";
int n1 = test.indexOf(97);
int n2 = test.indexOf("y");

System.out.println(n1);
System.out.println(n2);
}
}

4.继承

java使用extends关键字进行继承

1是java的extends继承,2是c++的继承

1
2
3
class student extends Person{

}
1
2
3
class student:public Person{

}

Person是超类(supper class)、父类(parent class),基类(base class),

Student 是子类(subclass),拓展类(extended class)

对于没有写extends 基类的,默认extends Object

子类使用父类字段时可以用supper.字段,一般与字段是一样的

但是supper在基类有自定义的构造函数,则子类的构造函数必须调用supper(),例如

1
2
3
4
5
6
7
8
class Student extends Person {
protected int score;

public Student(String name, int age, int score) {
super(name, age); // 调用父类的构造方法Person(String, int)
this.score = score;
}
}

对于父类为默认构造函数

其实相当于

1
2
3
4
5
6
7
8
class Student extends Person {
protected int score;

public Student( int score) {
super(); // 调用父类的构造方法Person(String, int)
this.score = score;
}
}

public,private, protected

public任何地方都能通过对象访问,类内或子类可直接用

protected子类可直接使用,外部无法访问

阻止继承

正常来说一个class没有final修饰,那么任何类都可以继承该class

java15开始允许sealed修饰class,并通过permits明确写出能够继承该class的子类名

1
2
3
public sealed class Shape permits Rect,Circle{

}

5.多态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// override
public class Main {
public static void main(String[] args) {
Person p = new Student();
p.run(); // 应该打印Person.run还是Student.run?
}
}

class Person {
public void run() {
System.out.println("Person.run");
}
}

class Student extends Person {
@Override
public void run() {
System.out.println("Student.run");
}
}

@Override不是必需要的,但是写错方法签名会报错

Java的实例方法是基于运行时才能动态决定之类的方法,对于调用某个方法,实际上可能是某个子类的覆盖方法