【JAVA】part1-Java基础常识

最新推荐文章于 2024-07-14 22:18:32 发布

曾经``沧海

最新推荐文章于 2024-07-14 22:18:32 发布

阅读量853

点赞数 26

分类专栏： Java language 文章标签： java 开发语言

本文链接：https://blog.csdn.net/kx_52517/article/details/138146435

版权

Java language 专栏收录该内容

5 篇文章 1 订阅

订阅专栏

本文详细介绍了Java的基础知识，包括语言特性、编译执行流程、HelloWorld示例、标识符和关键字、数据类型（原始和引用）、用户输入与输出、数组、接口、枚举、数学方法、随机数生成、条件语句、循环结构以及字符串处理和类型转换。此外，还涉及了格式化数字的方法。

摘要由CSDN通过智能技术生成

part1-Java基础常识

请添加图片描述

Java语言特性

简单
健壮
面向对象
多线程
可移植性
- 一次编写，到处运行，.class可以运行在安装在各系统的JVMJava虚拟机上，屏蔽了操作系统的差异，下载jdk安装后就有了JVM

Java程序编译与执行

编译
.java(源文件) --javac.exe(编译器)–> .class(字节码文件)
DOS；窗口
执行
.class --java.exe(启动JVM) JAM(启动类加载器ClassLoader) ClassLoader(找到字节码文件并装载到JVM) JVM(将.class解释成二进制数据)–> 操作系统执行二进制数据与底层硬件进行交互

第一个程序HelloWorld

注意
每个源文件可以没有，有最多有一个public class 文件名{}
每个类想要执行，都要有一个主方法

语言基础

标识符

分类
类名，方法名，接口名，变量名，常量名
命名规则
字母数字下划线美元符号
命名规范
类名、接口名：单词字母大写；变量名、方法名：首字母小写；常量名都大写

关键字

public
class
void
static
用于修饰类、方法或属性，表示它们是静态的，可以通过类名直接访问。
private
用于声明私有的类、方法或属性，只能在当前类中访问。
protected
用于声明受保护的类、方法或属性，可以在当前类、同一包内的其他类、以及继承它的子类中访问。
final
用于修饰类、方法或属性，表示它们是最终的，不能被继承、重写或修改。
用final修饰class可以阻止被继承
用final修饰method可以阻止被子类覆写
用final修饰field可以阻止被重新赋值
用final修饰局部变量可以阻止被重新赋值
new
if、else
for、else
try、catch、finally
return
interface
extends
implements

字面值

变量

[数据类型] [变量名];

局部变量、成员变量
1. 局部变量（Local Variables） - 在方法内部定义，只能在该方法内部使用。
2. 成员变量（Member Variables） - 定义在类中但在方法之外，可以是非静态的（也称为实例变量）或静态的（也称为类变量）。

数据类型

原始数据类型
1. 整数型：
- byte - 8位有符号整数
- short - 16位有符号整数
- int - 32位有符号整数
- long - 64位有符号整数
1. 浮点型：
- float - 32位单精度浮点数
- double - 64位双精度浮点数
1. 字符型：
- char - 16位Unicode字符
1. 布尔型：
- boolean - 表示真或假的值（true 或 false）
引用数据类型
1. 类（Class）：用户定义的数据类型，可以包含字段、方法、构造器等。
```
String name = "Java";  // String 是一个类
```
1. 数组（Array）：一种容器对象，它包含固定数量的同类型值。
```
int[] numbers = new int[5];  // 数组
```
1. 接口（Interface）：一种引用类型，它是方法的集合，类可以实现接口，实现接口中的方法。
```
List<String> strings = new ArrayList<>();  // List 是一个接口
```
1. 枚举（Enum）：一种特殊的数据类型，用来定义常量集合。
```
enum Color {
    RED, GREEN, BLUE;
}
Color color = Color.RED;  // 枚举类型
```

用户输入与输出

占位符	说明
%d	格式化输出整数
%x	格式化输出十六进制整数
%f	格式化输出浮点数
%e	格式化输出科学计数法表示的浮点数
%s	格式化字符串

Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
System.out.printf(“%d”,variablity)

UserInput.java

import java.util.Scanner;

public class UserInput {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("What is your name? ");
        String name = scanner.nextLine().trim();
        System.out.println("Hello,"+name);

        System.out.print("How old are you? ");
        int age = scanner.nextInt();
        System.out.printf("You are %d years old\n",age);

        System.out.print("How height are you? ");
        double height = scanner.nextDouble();
        System.out.printf("your height is %f\n",height); // 格式化输出

        scanner.close();
    }
}

PrintfIntro.java

public class PrintfIntro {
   public static void main(String[] args) {
       int someInt = 10;
       String someString = "Hello";
       double someDouble = 3.14159;

       System.out.printf("Integer: %d String: %s Floating Point: %.2f\n",someInt,someString,someDouble);
   }
}

图形对话框

import javax.swing.JOptionPane；

GuiIntro.java

import javax.swing.JOptionPane;

public class GuiIntro {
    public static void main(String[] args) {
        
        String name = JOptionPane.showInputDialog("Enter your name");
        JOptionPane.showMessageDialog(null, "Hello "+ name);

        int age =   Integer.parseInt(JOptionPane.showInputDialog("Enter your age"));
        JOptionPane.showMessageDialog(null, "You are "+ age + " years old");

        double height =   Double.parseDouble(JOptionPane.showInputDialog("Enter your height"));
        JOptionPane.showMessageDialog(null, "You are "+ height + " cm tall");

    }
}

Math类方法

MathMethods.java

import java.util.Scanner;

public class MathMethods {
    public static void main(String[] args) {

        double x = 3.14;
        double y = -10;

        double z = Math.max(x, y);
        double k = Math.abs(y);
        double l = Math.sqrt(x);    // 求根
        double m = Math.round(x);   // 四舍五入
        double n = Math.ceil(x);    // 向上取整
        double o = Math.floor(x);   // 向下取整
        double p = Math.round(Math.random()*100);   // 0-100之间随机数

        System.out.println(z);
        System.out.println(k);
        System.out.println(l);
        System.out.println(m);
        System.out.println(n);
        System.out.println(o);
        System.out.println(p);

        // Calculate hypotenuse斜边
        double a;
        double b; 
        double c;
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a: ");
        a = scanner.nextDouble();
        System.out.print("Enter b: ");
        b = scanner.nextDouble();
        c = Math.sqrt(Math.pow(a, 2)+Math.pow(b,2));
        System.out.print("Solve for hypotenuse:"+c);
        scanner.close();
    }
}

生成随机值

import java.util.Random;

nextInt()：生成一个随机的整数。
nextInt(int bound)：生成一个随机的整数，其值介于0（含）和指定的bound（不含）之间。
nextLong()：生成一个随机的长整型值。
nextDouble()：生成一个随机的双精度值，其值介于0.0（含）和1.0（不含）之间。
nextFloat()：生成一个随机的浮点数，其值介于0.0（含）和1.0（不含）之间。
nextBoolean()：生成一个随机的布尔值，结果为true或false。

RandomNumber.java

import java.util.Random;

public class RandomNumber {
    public static void main(String[] args) {

        Random random = new Random();

        // int x = random.nextInt(6)+1;
        // double y = random.nextDouble();
        boolean z = random.nextBoolean();
        System.out.println(z);

    }
}

条件语句

ConditionJudgement.java

public class ConditionJudgment {
    public static void main(String[] args) {
        int temp = 1;
        // if...else if...else
        if(temp > 10 || temp < 1 ){

            System.out.println("1");

        }else if(temp > 1 && temp < 10 ){

            System.out.println("2");

        }else if(temp != 10){

            System.out.println("temp is "+temp);
        }

        // switch()...case xxx:...break;default:...
        String day = "Monday";
        switch(day){
            case "Monday":System.out.println("Today is "+day);
            break;
            case "Tuesday":System.out.println("Today is "+day);
            break;
            case "Wednesday":System.out.println("Today is "+day);
            break;
            case "Thursday":System.out.println("Today is "+day);
            break;
            case "Friday":System.out.println("Today is "+day);
            break;
            case "Saturday":System.out.println("Today is "+day);
            break;
            default:System.out.println("Today is "+day);
        }
    }
}

循环语句

Loop.java

import java.util.Scanner;

public class Loop {
    public static void main(String[] args) {
        // while
        int sum = 0;
        int n = 1;
        while(n<=100){
            sum+=n;
            n++;
        }
        System.out.println("1-100:"+sum);

        // do while
        Scanner scanner = new Scanner(System.in);
        String name = "";

        do{
            System.out.println("Enter your name:");
            name = scanner.nextLine();

        }while(name.isBlank()); 

        System.out.println("Hello, "+ name );

        // for
        int res = 0;
        for (int i = 1; i <= 100; i++) {
            if(i < 50){
                continue; // 下面代码当前循环不执行
            }
            res += i;
            if(res > 4000){
                break;  //退出循环
            }
        }
        System.out.println(res);

    }
}

数组Arrays

ArrayOperations.java

import java.util.Arrays;

public class ArrayOperations {
    public static void main(String[] args) {
        // 定义与初始化
        int[] source = new int[] {1,2,3,4,5};
        int[] arr = new int[10];// 声明一个整型数组并创建10个空间，但未显式初始化，元素默认为0
        Arrays.fill(arr, 5);
        System.arraycopy(source, 0, arr, 5, source.length);

        // fori
        if(1==0){
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i]);            
            }
        }
        // foreach
        if(1==0){
            for (int i : arr) {
                System.out.println(i);
            }
        }

        // Arrays.toString();
        System.out.println(Arrays.toString(arr));

        // 排序：Arrays.sort(array);
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

        // 多维数组
        int[][] matrix = new int[][]{
            {1, 2, 3}, // 第一行
            {4, 5, 6}, // 第二行
            {7, 8, 9}  // 第三行
        };

        int[][] dynamicArray = new int[3][4]; // 创建一个3x4的二维数组

        int[][] irregularArray = new int[2][]; // 先只指定第一维的大小
        irregularArray[0] = new int[3]; // 第一行有3个元素
        irregularArray[1] = new int[2]; // 第二行有2个元素

    }
}

String类

StringIntro.java

import java.util.Arrays;

public class StringIntro {
    public static void main(String[] args) {
        // 字符串创建
        String greeting = "Hello, World!";

        String s = new String("Hello, World");

        // 字符串方法
        String t = greeting + s; // + 号 连接两个字符串

        int len = greeting.length(); //返回字符串的长度。

        char ch = greeting.charAt(0);//返回指定索引处的字符。

        int index = greeting.indexOf("o"); // 返回字符或字符串第一次出现的索引

        boolean empty = greeting.isEmpty();// 检查是否为空

        String trimString = greeting.trim();//求掉前后多余的空格

        String sub = greeting.substring(0, 5);//返回字符串的子字符串。

        boolean contains = greeting.contains("World");//检查字符串是否包含指定的字符序列。

        boolean isEqual = greeting.equals("Hello, World!");//比较两个字符串的内容是否相同。

        boolean isEqualIgnoreCase = greeting.equalsIgnoreCase("Hello, World!");//忽略大小写比较两个字符串。

        String[] parts = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z".split(",");//根据给定正则表达式的匹配拆分此字符串。

        String replaced = greeting.replace("World", "Java");//替换字符串中的某部分。

        String upper = greeting.toUpperCase();//将字符串转换为全部大写或小写。
        String lower = greeting.toLowerCase();


        System.out.printf("t = %s \n",t);
        System.out.printf("len = %s \n",len);
        System.out.printf("ch = %s \n",ch);
        System.out.printf("index = %s \n",index);
        System.out.printf("empty = %s \n",empty);
        System.out.printf("trimString = %s",trimString);
        System.out.printf("sub = %s \n",sub);
        System.out.printf("contains = %s \n",contains);
        System.out.printf("isEqual = %s \n",isEqual);
        System.out.printf("isEqualIgnoreCase = %s \n",isEqualIgnoreCase);
        System.out.printf("parts = %s \n",Arrays.toString(parts));
        System.out.printf("replaced = %s \n",replaced);
        System.out.printf("upper = %s \n",upper);
        System.out.printf("lower = %s \n",lower);
    }
}

类型转换

TypeExchange.java
隐式
显示
强制

public class TypeExchange {
    public static void main(String[] args) {
        // Implicit casting
        // byte > short > int > long > float > double

        // 字符串转换特定类型
        String x1 = "1";
        String x2 = "1.1";
        Integer y1 = Integer.parseInt(x1);
        Double y2 = Double.parseDouble(x2);
    }
}

Number

Format类格式化输出数字
NumberFormatIntro.java

import java.text.NumberFormat;

public class NumberFormatIntro {
    public static void main(String[] args) {
        NumberFormat currency = NumberFormat.getCurrencyInstance();
        NumberFormat percent = NumberFormat.getPercentInstance();

        String result1 = currency.format(1234567.891);
        String result2 = percent.format(0.891);

        System.out.println(result1);
        System.out.println(result2);

        // 方法连接
        System.out.println(NumberFormat.getPercentInstance().format(0.12));
    }
}