Java简单语法--已掌握一门语言快速入门
文章目录
- Java基本概念
- Java语法
-
- 变量类型与输入输出
- 相关语句
- 数组定义
- 字符串
- 函数
- 类与接口
- Java中的STL
-
- List
- 栈
- 队列
- Set
- Map
Java基本概念
- JDK、JRE、JVM的关系
- JDK：Java Development Kit, Java开发工具包
- JRE：Java Runtime Environment, Java运行环境
- JVM：Java Virtual Machine, Java虚拟机
- JDK包含JRE, JRE包含JVM
- JAVA代码的编译运行流程
- 将JAVA源码编译成JAVA字节码
- 使用JVM将Java字节码转换成机器码
- JVM作用：跨平台、内存管理、安全
- JSE、JEE、JME的区别
- JSE：Java Standard Edition， 标准版
- JEE：Java Enterprise Edition，企业版
- JME：Java Mirco Edition，移动版
- Spring是JEE的轻量级代替品，需要配置较多东西
- Springboot是Spring + 自动化配置
Java语法
变量类型与输入输出
Java的所有变量和函数都要定义在class中
内置数据类型
| 类型 | 字节数 |
|---|---|
| byte | 1 |
| short | 2 |
| int | 4 |
| long | 8 |
| float | 4 |
| double | 8 |
| boolean | 1 |
| char | 2 |
常量
使用final修饰
final int N = 110;
类型转换
- 显式转换
int x = (int) 'A' - 隐式转换
double x = 12, y = 4 * 3.3，低精度向高精度
输入
- 方法1: 效率较低，输入规模较小时使用
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String str = sc.next(); //读入下一个字符串 int x = sc.nextInt(); //读入下一个整数 float y = sc.nextFloat(); //读入下一个单精度浮点数 double z = sc.nextDouble(); //读入下一个双精度浮点数 String line = sc.nextLine(); //读入下一行 } } - 方法2：
import java.io.BufferedReader; import java.io.InputStreamReader; public class Main { public static void main(String[] args) throws Exception{ BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String str = br.readLine();//读一行字符串 int x = Integer.parseInt(br.readLine());//读一个整数 // 读入多个整数时 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String[] strs = br.readLine().split(" "); int x = Integer.parseInt(strs[0]), y = Integer.parseInt(strs[1]); } }
输出
-
方式1：效率较低，输出规模较小时使用
- 输出带回车
System.out.println(); - 输出不带回车
System.out.print(); - 格式化输出
System.out.printf("%.2f\n", 3.1415); //float与double都用%f
- 输出带回车
-
方式2：效率较高，输出规模较大时是要用。需要抛出异常
import java.io.BufferedWriter; import java.io.OutputStreamWriter; public class Main { public static void main(String[] args) throws Exception{ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out)); bw.write("Hello world\n"); bw.flush();//需要手动刷新缓冲区 } }
相关语句
IF-ELSE、SWICTH与C++完全一样
逻辑表达式与条件判断语句与C++完全一样，但是java中int型不能用作bool类型
循环结构：WHILE, DO-WHILE, FOR循环等与c++完全一样
数组定义
-
初始化
初始化定长数组，长度可以是变量，可以在初始化时赋值int[] a = new int[5]; //初始长度为5的int数组，初始值为0 int n = 10; float[] b = new float[n]; //初始化长度为n的float数组，初始值为0.0F char[] c = {'a', 'b', 'c'}; //初始化长度为3的char数组，初始值为：'a', 'b', 'c' char[] d = c;// d与c地址相同，更改c中的元素，d中的元素也会改变 -
多维数组
int[][] a = new int[2][3]; a[1][2] = 1; int[][] b = { {1, 2, 3}, {4, 5, 6}, };多维数组输出
System.out.println(Arrays.deepToString(b)); -
常用API
- 属性length: 返回数组长度，注意不加小括号
- Arrays.sort(): 数组排序
- Arrays.fill(int[] a, int val): 填充数组
- Arrays.toString(): 将数组转换成字符串，只能转换一维
- Arrays.deepToString(): 将多维数组转换成字符串
- 数组长度不可变
字符串
String类
-
初始化：
String a = "Hello World"; String b = "My name is"; String x = b; //存储到了相同的地址 String c = b + "Lihua"; // String 可以通过加号拼接 String d = "My age is " + 18; //int 类型会被转换成字符串 String str = String.format("My age is %d", 18); //格式化字符串 String money_str = "123.45"; double money = Double.parseDouble(money_str);// 将String 转换成浮点数 -
只读变量，不能修改
String a = "Hello "; System.out.println(a.hashCode()); a += "World"; System.out.println(a.hashCode());// 会发现a变量的地址发生变化了 -
访问String中的字符
String str = "Hello World"; for (int i = 0; i < str.length(); i ++) System.out.print(str.charAt(i));//只能读取，不能写入 -
常用API:
-
length(): 返回长度 -
split(String regex): 分割字符串 -
str.indexOf(char c)、indexOf(String str): 查找，找不到返回-1 -
equals(): 判断两个字符串是否相等，而不能用== -
compareTo(): 判断两个字符串字典序大小，负数表示小于，0表示相等，整数表示大于 -
startsWith(): 判断是否以某个前缀开头 -
endsWith(): 判断是否以某个后缀结尾 -
trim(): 去掉首位的空白字符 -
toLowerCase(): 全部用小写字符 -
toUpperCase(): 全部用大写字符 -
replace(char oldChar, char newChar): 替换字符 -
replace(String oldRegex, String newRegex): 替换字符串 -
substring(int beginIndex, int endIndex): 返回[beginIndex, endIndex)中的子串
-
-
StringBuilder、StringBufferString不能被修改，如果打算修改字符串，可以使用StringBuilder和StringBuffer。StringBuffer线程安全(多线程要使用)，速度较慢；StringBuilder线程不安全速度较快- 例
StringBuilder sb = new StringBuilder("Hello "); //初始化 sb.append("World");//拼接字符串 System.out.println(sb); for (int i = 0; i < sb.length(); i ++){ sb.setCharAt(i, (char)(sb.charAt(i) + 1));// 读取和写入字符 } System.out.println(sb); - 常见API：
reverse
函数
java的所有变量和函数都要定义在类中。
函数或变量前加 static 表示静态对象，类似全局变量。共用。
静态对象属于 class ，而不属于class的具体实例,
使用静态函数，在调用时可以使用类名调用，非静态函数只能使用具体实例进行调用
静态函数中只能调用静态函数和静态变量。
例：
import java.util.Arrays;
public class Main{
public static void main(String[] args){
System.out.println(max(3, 4));
int[][] a = new int[3][4];
fill(a, 3);
int[][] b = getArray2d(2, 3, 5);
System.out.println(Arrays.deepToString(b));
}
private static int max(int a, int b){
if (a > b) return a;
return b;
}
private static void fill(int[][] a, int val){
for (int i = 0; i < a.length; i ++)
for (int j = 0; j < a[i].length; j ++)
a[i][j] = val;
}
private static int[][] getArray2d(int row, int col, int val){
int[][] a = new int[row][col];
for (int i = 0; i < row; i ++)
for (int j = 0; j < col; j ++)
a[i][j] = val;
return a;
}
}
类与接口
源文件声明规则
- 一个源文件只能有一个
public类 - 一个源文件可以有多个非
public类 - 源文件名称应该和
public类的类名保持一致 - 每个源文件中，先写
package语句，再写import语句，最后定义类
类的定义
public:所有对象均可以访问private:只有自己可以访问
例：
class Point{
private int x, y;
public Point(int x, int y){// 构造函数
this.x = x;
this.y = y;
}
public int getx(){
return x;//私有变量不能直接访问，需要定义接口
}
public int gety(){
return y;
}
public String toString(){
return String.format("(%d, %d)", x, y);
}
}
类的继承
每个类只能继承一个类
extends继承对应的父类
super就表示父类的意思
class ColorPoint extends Point{
private String color;
public ColorPoint(int x, int y, String color) {
super(x, y);
this.color = color;
}
public String toString() {
return String.format("%d, %d, %s", super.getx(), super.gety(), this.color);
}
}
类的多态
多态：同一个类的实例，调用相同的函数，运行的结果不同
Point point = new Point(3, 4);
Point colorPoint = new ColorPoint(1, 2, "red");//这两个变量都是同一个类型
System.out.println(point.toString());
System.out.println(colorPoint.toString());//不同的行为
接口
interface与class类似。主要用来定义类中所需包含的函数。
接口也可以继承其他接口，一个类可以实现多个接口
接口的定义
interface Role{
public void greet();
public void move();
public int getSpeed();
}
接口的继承
每个接口可以继承多个接口
interface Hero extends Role{
public void attack();
}
接口的实现
每个类可以实现多个接口
class Zeus implements Hero{
private final String name = "Zeus";
public void attack(){
System.out.println(name + "attack!");
}
public void greet(){
System.out.println(name + "Hi!");
}
public void move(){
System.out.println(name + "Move!");
}
public int getSpeed(){
return 10;
}
}
接口的多态
public class Main{
public static void main(String[] args){
Hero[] heros = {new Zeus(), new Athena()};// 可以使用基接口表示不同子类对象
for (Hero hero : heros){
hero.greet();
}
}
}
泛型
类似于C++中的template, Java的类和接口可以定义泛型，即同一套函数可以作用于不同的对象类型。
泛型只能使用对象类型，不能使用基本变量类型。
Java中的STL
List
类似于c++中的vector
接口：java.util.List<>
实现：
java.util.ArrayList<>:变长数组java.util.LinkedList<>:双链表
函数:
add():在末尾添加一个元素clear():清空size():返回长度isEmpty()：是否为空get(i):获取第i个元素set(i, val):将第i个元素设置为val
栈
类：java.util.Stack<>
函数：
push():压入元素pop():弹出栈顶元素，并返回栈顶元素peek():返回栈顶元素empty():栈是否为空clear():清空
队列
接口： java.util.Queue<>
实现:
java.util.LinkedList<>:双链表java.util.PriorityQueue<>:优先队列
函数:
add(): 在队尾添加元素remove():删除队头isEmpty():是否为空size():返回长度peek():返回队头clear():清空
Set
接口：java.util.Set<>
实现：
java.util.HashSet<>: 哈希表(无序)java.util.TreeSet<>:平衡树（有序）
函数：
add():添加元素contains():是否包含某个元素remove():删除元素size():返回元素数isEmpty():是否为空clear():清空
java.util.TreeSet多的函数：
ceiling(key): 返回大于等于key的最小元素，不存在则返回nullfloor(key):返回小于等于key的最大元素，不存在则返回null
Map
接口：java.util.Map
实现：
java.util.HashMap: 哈希表java.util.TreeMap:平衡树
函数：
put(key, val):添加关键字和对应的值get(key):返回关键字对应的值containsKey(key):是否包含关键字remove(key)：删除关键字size():返回关键字isEmpty():是否为空clear():清空entrySet():获取Map中的所有对象的集合Map.Entry:Map中的对象类型getKey():获取关键字getValue():获取值
java.util.TreeMap多的函数：
ceilingEntry(key):返回大于等于key的最小元素，不存在则返回nullfloorEntry(key):返回小于等于key的最大元素，不存在则返回null
SpringBoot框架课