Java简单语法--已掌握一门语言快速入门

发布时间:2024年01月20日

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中
内置数据类型

类型字节数
byte1
short2
int4
long8
float4
double8
boolean1
char2

常量
使用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++完全一样

数组定义

  1. 初始化
    初始化定长数组,长度可以是变量,可以在初始化时赋值

    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中的元素也会改变
    
  2. 多维数组

        int[][] a = new int[2][3];
        a[1][2] = 1;
        int[][] b = {
                {1, 2, 3},
                {4, 5, 6},
        };
    

    多维数组输出

    System.out.println(Arrays.deepToString(b));
    
  3. 常用API

    • 属性length: 返回数组长度,注意不加小括号
    • Arrays.sort(): 数组排序
    • Arrays.fill(int[] a, int val): 填充数组
    • Arrays.toString(): 将数组转换成字符串,只能转换一维
    • Arrays.deepToString(): 将多维数组转换成字符串
    • 数组长度不可变

字符串

String类

  1. 初始化:

    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 转换成浮点数
    
  2. 只读变量,不能修改

    String a = "Hello ";
    System.out.println(a.hashCode());
    a += "World";
    System.out.println(a.hashCode());// 会发现a变量的地址发生变化了
    
  3. 访问String中的字符

    String str = "Hello World";
    for (int i = 0; i < str.length(); i ++)
        System.out.print(str.charAt(i));//只能读取,不能写入
    
  4. 常用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)中的子串

  5. StringBuilderStringBuffer

    • String不能被修改,如果打算修改字符串,可以使用StringBuilderStringBuffer
    • 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());//不同的行为

接口
interfaceclass类似。主要用来定义类中所需包含的函数。
接口也可以继承其他接口,一个类可以实现多个接口

接口的定义

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的最小元素,不存在则返回null
  • floor(key):返回小于等于key的最大元素,不存在则返回null

Map

接口java.util.Map<K, V>
实现

  • java.util.HashMap<K, V>: 哈希表
  • java.util.TreeMap<K, V>:平衡树

函数

  • put(key, val):添加关键字和对应的值
  • get(key):返回关键字对应的值
  • containsKey(key):是否包含关键字
  • remove(key):删除关键字
  • size():返回关键字
  • isEmpty():是否为空
  • clear():清空
  • entrySet():获取Map中的所有对象的集合
  • Map.Entry<K, V>:Map中的对象类型
    • getKey():获取关键字
    • getValue():获取值

java.util.TreeMap<K, V>多的函数:

  • ceilingEntry(key):返回大于等于key的最小元素,不存在则返回null
  • floorEntry(key):返回小于等于key的最大元素,不存在则返回null

SpringBoot框架课

文章来源:https://blog.csdn.net/m0_64372178/article/details/135629181
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。