02、Java基础语法

/**
* 1、这是一个文档注释
* @Author xiaoshan
* @version v1.0
* @Date 2023-05-26 
* 我定义了一个HelloWorld类
*/
public class HelloWorld(){
   
     
	// 2、这是一个单行注释。我定义了一个字符串静态变量 “Hello World!”
	public static String str = "Hello World!";
	
	/* 3、这是一个多行注释。
 	* 我定义了一个main方法，在方法中打印了字符串
 	*/
	public static void main(String args[]){
   
     
		System.out.println(str);
	}
}

//一、关键字 private
public class MyPublicClass{
   
     
	private class PrivateClass{
   
     ...}
	private int i;
	private void method(){
   
     ...}
}

//二、关键字 default
default class MyDefaultClass{
   
     
	default int a;
	default void method(){
   
     ...}
}
//default 关键字可以省略，于是以下代码和上面的代码一样：
class MyDefaultClass{
   
     
	int a;
	void method(){
   
     ...}
}

//三、关键字 protected
protected class MyProtectedClass{
   
     
	protected int i;
	protected void method(){
   
     ...}
}

//四、关键字 public
public class MyPublicClass{
   
     
	public int i;
	public void method(){
   
     ...}
}

//五、关键字 abstract. 抽象的
//定义抽象类. 抽象类只能通过其子实现类来实例化，实现类需要覆写抽象父类的所有抽象方法
public abstract class AbstractClass{
   
     
	//定义抽象方法. 抽象方法只有方法定义而没有具体逻辑，具体实现逻辑是交由子类处理的
	public abstract void abstractMethod();
}

//六、关键字 final. 最终的
//定义最终类. 最终类无法被继承，即无法拥有子类
public final class FinalClass{
   
     
	//定义最终变量. 最终变量是一个常亮，不可改变其值
	public final int i = 0;
	//定义最终方法. 最终方法无法被重写
	public final void finalMethod();
}

//七、关键字 static. 静态的
//定义静态类
public static class StaticClass{
   
     
	//定义静态变量. 静态变量可以直接通过类名调用
	public static int i = 0;
	//定义静态方法. 静态方法可以直接通过类名调用
	public static void staticMethod(){
   
     ...}
}

//八、关键字 native. 修饰方法，表示该方法是用Java以外的语言实现的。
//用native关键字修饰的方法没有方法体。它会进入本地方法栈，通过调用JNI接口实现对其他语言代码和代码库的使用。
native void nativeMethod();

//九、关键字 void. 修饰方法，表示该方法不返回任何值。
void method();

//十、关键字 transient. 修饰字段，表示在类实例序列化时，该字段不参与序列化
public class MyClass{
   
     
	private transient String filed;
}

//十一、关键字 synchronized. 应用于方法或语句块，表示在多线程时是同步的、线程安全的，保证了并发操作的原子性
//同步方法
public class MyClass{
   
     
	public synchronized void mySyncMethod(){
   
     ...}
}
//同步代码块	
public class MyClass{
   
     
	Object obj;
	public void method(){
   
     
		...
		synchronized(obj){
   
     ...}
}

//十二、关键字 volatile. 修饰字段，保证了并发操作的可见性、有序性
public class MyClass{
   
     
	volatile int sharedValue;
}

//正确的变量名
int a = 1;
//* 错误的变量名：不能以数字开头
int 1a = 1;
//* 错误的变量名：不能是Java中的关键字
int private = 1;
//* 错误的变量名：包含规则以外的字符 #
int a#b = 1;

//正确的类名
public class Student{
   
     ...}
//正确的方法名
public Student getStudent(){
   
     ...}
//正确的变量名
private int age;
//正确的常量名
private int AGE = 18;
//正确的包名
package com.xiaoshan.service;

//1、整型
//定义byte类型的变量
byte b=1;
//定义short类型变量
short s=10;
//定义int类型的变量
int i=100;
//定义long类型的变量，需要加后缀L或l
long l=10000000L; 

//2、浮点型
//定义float类型的变量，需要加后缀F或f
float f=3.14F; 
//定义double类型变量
double d=3.14;

//3、布尔型
//定义boolean类型变量
boolean flag=true;

//4、字符型
//定义char类型变量
char c='a';

//1、赋值运算符
public static void main(String args[]){
   
     
        // = 直接赋值
        int a=1, b=2;
        System.out.println("b=" + b + ", a=" + a);
        // += 先加a再赋值给b
        b += a;
        System.out.println("b += a 结果 b=:" + b);
        System.out.println("------------------------");

        System.out.println("b=" + b + ", a=" + a);
        // -= 先减再赋值
        b -= a;
        System.out.println("b -= a 结果 b=:" + b);
        System.out.println("------------------------");

        System.out.println("b=" + b + ", a=" + a);
        // *= 先乘再赋值
        b *= a;
        System.out.println("b *= a 结果 b=:" + b);
        System.out.println("------------------------");

        System.out.println("b=" + b + ", a=" + a);
        // /= 先除再赋值
        b /= a;
        System.out.println("b /= a 结果 b=:" + b);
        System.out.println("------------------------");

        System.out.println("b=" + b + ", a=" + a);
        // %= 先取余再赋值
        b %= a;
        System.out.println("b %= a 结果 b=:" + b);
    }

public static void main(String args[]){
   
     
        int a=1,b=2;
        System.out.println("a="+ a + ", b=" + b);
        //2、算数运算符
        // + 相加
        int sum = a + b;
        System.out.println("a+b=" + sum);
        // - 相减
        int diff = b - a;
        System.out.println("b-a=" + diff);
        // * 相乘
        int multi = a * b;
        System.out.println("a*b=" + multi);
        // / 相除。注意：整数相除只能得到整数, 要得到带有小数的准确结果, 必须有小数参与运算
        int div = b / a;
        System.out.println("b/a=" + div);
        // % 取模或取余
        int mod = b % a;
        System.out.println("b%a=" + mod);
        // ++ 让变量自身的值 + 1操作. ++在前: 先自增, 再操作.++在后: 先操作, 再自增
        System.out.println("运算前a=" + a);
        int c = ++a;
        System.out.println("前置++，++a=" + c + ", 运算后a=" + a);
        int d = a++;
        System.out.println("后置++，a++=" + d + ", 运算后a=" + a);
        // -- 让变量自身的值 - 1操作. --在前: 先自减, 再操作.--在后: 先操作, 再自减
        int e = --a;
        System.out.println("前置--，--a=" + e + ", 运算后a=" + a);
        int f = a--;
        System.out.println("后置--，a--=" + f + ", 运算后a=" + a);
}

public static void main(String args[]){
   
     
        int a=2,b=1;
        System.out.println("a = " + a + ", b = " + b);
        //3、关系运算符
        // > 判断大于、< 判断小于、>= 大于等于、<= 小于等于、== 等于、!= 不等于
        //判断结果是布尔型值
        boolean flag = b > a;
        System.out.println("b>a? 结果：" + flag);
        flag = b < a;
        System.out.println("b<a? 结果：" + flag);
        flag = b >= a;
        System.out.println("b>=a? 结果：" + flag);
        flag = b <= a;
        System.out.println("b<=a? 结果：" + flag);
        flag = b == a;
        System.out.println("b==a? 结果：" + flag);
        flag = b != a;
        System.out.println("b!=a? 结果：" + flag);
}

public static void main(String args[]){
   
     
        boolean flag1 = true, flag2 = false;
        System.out.println("flag1 = " + flag1 + ", flag2 = " + flag2);
        //4、逻辑运算符
        // & 与
        boolean flag = flag1 & flag2;
        System.out.println("flag1 & flag2 = " + flag);
        // | 或
        flag = flag1 | flag2;
        System.out.println("flag1 | flag2 = " + flag);
        // ! 非/取反
        flag = !flag1;
        System.out.println("!flag1 = " + flag);
        // && 短路与：从左往右依次判断，只要有一个为false则结果为false
        flag = flag1 && flag2 && true;
        System.out.println("flag1 && flag2 && true = " + flag);
        // || 短路或：从左往右依次判断，只要有一个为true则结果为true
        flag = flag1 || flag2 || false;
        System.out.println("flag1 || flag2 || false = " + flag);
}

public static void main(String args[]){
   
     
        //5、位运算符
        // 位运算是先将操作数转为二进制格式数，再进行运算
        byte a=2, b=1;
        System.out.println("a = " + a + ", b = " + b);
        // & 位与
        int c = a & b; //---->00000010 & 00000001 = 00000000
        System.out.println("a & b = " + c);
        // | 位或
        c = a | b; //---->00000010 | 00000001 = 00000011
        System.out.println("a | b = " + c);
        // ~ 位取反
        c = ~a; //----> ~00000010 = 11111101 符号位为1表示是负数，则再将符号位以外的位取反，再加1，即 10000010 + 1 = 10000011
        System.out.println("~a = " + c);
        // ^ 位异或
        c = a ^ b; //---->00000010 ^ 00000001 = 00000011
        System.out.println("a ^ b = " + c);
        // << 位左移
        c = a << 1; //---->00000010 << 1 = 00000100
        System.out.println("a << 1 = " + c);
        // >> 位右移
        c = a >> 1; //---->00000010 >> 1 = 00000001
        System.out.println("a >> 1 = " + c);
        // >>> 无符号右移
        c = a >>> 1; //---->00000010 >>> 1 = 00000001
        System.out.println("a >>> 1 = " + c);
}

public static void main(String args[]){
   
     
        int a=5,b=2;
        //6、三目运算符
        // 表达式 ?  值1 : 值2. 根据一个判断条件, 达成二者选其一.
        //当表达式的结果是true时 值1就是运算结果, 是false时 值2就是运算结果
        int max = a > b ? a:b;
        System.out.println("max = " + max);
}

//1、分支结构
//if-else ：当哪一个分支的判断条件为true，就会执行对应的语句体
if(判断条件1){
   
     
	语句体1;
}else if(判断条件2){
   
     
    语句体2;
}
...
else {
   
     
	语句体n;
}
//switch-case ：对表达式的值做选择判断，当case语句后的值满足则执行对应的语句体
switch ( 表达式 ) {
   
     
	case 值1 ：
		语句体1 ;
		break ;
	case 值2 ：
		语句体2 ;
		break ;
	...
	default ：
		语句体 n;
		break ;
}

//2、循环结构
/**
* for循环：明确循环次数的时候,使用for循环.格式：
* for(初始化语句; 判断条件; 条件控制语句){
*	循环体语句;
* }
* 初始化语句: 定义变量. 
* 判断条件: 控制循环是否需要继续的条件. 
* 循环体语句: 循环逻辑. 
* 条件控制语句 : 改变控制循环的变量
*/
for(int i = 1; i <= 5; i++){
   
     
	System.out.println(i);
}

/**
* while循环：不明确循环的次数,使用while循环.格式：
* 初始化语句;
* while(判断条件){
*	循环体语句;
*	条件控制语句;
* }
*/
int i = 1;
while(i <= 5){
   
     
    System.out.println(i);
    i++;
}

/**
* do-while循环：无论判断条件是否满足, 都至少执行一次循环体.格式：
* 初始化语句;
* do {
*	循环体语句;
*	条件控制语句;
* }while(判断条件)
*/
int i = 1;
do{
   
     
	System.out.println(i);
    i++;
}while(i <= 5);

//1、字符串定义
String str = "hello world";

//2、数组定义
//静态初始化方式:
int[] arr = {
   
     1,2,3,4,5};
//动态初始化方式:
int[] arr = new int[5];

//3、对象创建
// 对象的创建依赖于一个具体类
Student student = new Student();

//1、类定义格式
[private| default| protected| public] [abstract] [final] [static] class 类名 extends 父类名 implements 接口名{
   
     
	Filed...
	Method...
}
//2、方法定义格式
[private| default| protected| public] [abstract] [final] [static] 返回值类型 方法名(参数列表){
   
     
	...
	[return 返回值;]
}
//3、接口定义格式
[public] interface 接口名 extends 接口名{
   
     
	...
}