# 官方提供@yunTaoScripts JavaSE 基础语法 Ⅰ 🔥🔥

# Java程序的标识符和常用关键词

什么是标识符：
- java程序的组成，比如类名、方法名、变量名等

注意点：

标识符可以由字母、数字、下划线_、美元符（$）组成，但不能包含%，空格等其他特殊字符，不能以数字开头，区分大小写，不能是java关键字。
合法的标识符：age，User，_Student, $Boy, _1_value
不合法的标识符：#age，8User，my friend，class, if

什么是Java关键字：
- 是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，关键字不能用作变量名、方法名、类名、包名和参数

boolean、byte、 char、 double、 enum、float、int、 long、short、 void  
private、protected、public、default、abstract、extends、 class、 
interface、return、static、Super、assert、break、 case、 try
catch、const、 continue、 do、else、 final、 finally、 for、goto、
if、 implements、import、instanceof、native、new、package、Switch、
synchronized 、this、 throw、 throws 、transient、volatile、 while

# java修饰符和使用场景

修饰符的作用是啥？用来定义类、方法或者变量的访问权限

# 修饰符分类

访问修饰符：
- 限定类、属性或方法是否可以被程序里的其他部分访问和调用的修饰符
- private < default < protected< public
非访问修饰符：用来修饰或者辅助功能，
- 例如static、final、abstract、synchronized等

# 记忆技巧

类修饰符：
- public 或者为 default
方法、属性修饰符：
- private、default、protected、public
修饰符访问范围

修饰符	可见范围
private	仅对类内部可见
default	仅对当前包可见
protected	对包和所有子类可见
public	公开对外部可见

# 方法级别列表

修饰符	当前类	同一包内	不同包中的子类	子类(不同包)
private	Y	N	N	N
default	Y	Y	N	N
protected	Y	Y	Y	N
public	Y	Y	Y	Y

几点注意

属性或者成员变量，都用private修饰，不用其他的，这个是java开发的约束。
只有public修饰的类，才能在包外部包可⻅见;否则只是包内私有的类，类不不能被其他包访问。

Java中 public class 与 class 的区别

在一个*.java的文件中，只能有一个public class的声明，有多个public则编译报错，其类名称必须与文件名称完全一致，但是允许有多个class的声明，

public class A{
    public static void main(String [] args){
        System.out.println("A");
    }
};
class B{};
class C{};

# 八种基本数据类型

# 计算机基础知识

bit 位 ,即0或者1, 0101010110 byte字节，8位作为一个字节，字节是处理理数据的基本单位

1byte = 8bits
1KB   = 1024 bytes
1MB   = 1024 KB
1GB   = 1024 MB

每个数据都需要从计算机内存中申请空间，来存储它

byte

8位
最大127，最小-128
节省空间，占用int类型的四分之一
默认0

short

16位
最小-32768，最大32767
int类型的二分之一
默认是0

32位
最小-2147483648，最大2147483647
整数默认是int类型
默认是0

long

64位
最小-9223372036854774808， 
最大9223372036854774807 
默认是 0L，

float浮点

单精度32位
默认0.0f

double

双精度64位
浮点数默认位double类型
默认是0.0

boolean

1位
true或者false
默认是false

char

16位的 unicode字符， 即两个字节表示一个字符 
最小是\u0000 即0，做大 \ufff 即65535
例子 char demo = 'A'

类型转换

double > float > long > int > short > byte 
小转换到大，可以直接转换， 而从大到小，需要强制转，会有精度丢失

public class Test2 {
    public static void main(String[] args){
        byte a= 127;
        short b = 32767;
        int c = 1222222222;
        long d = 1L;
        float e= 1.23F;
        double f= 1.23;
        char g = 'a';
        boolean h= true;
        System.out.println(a);
        int i = (int) f ;
        System.out.println(i);
        int j = a;
        System.out.println(a);
    }
}

# 引用数据类型

# String

字符串对象，也是引用数据类型。Class创建的对象或者数组都是引用数据类型。

# 数组

需求场景：
- 需要声明 0~99，100个整数

int i=0; 
int i1=1;
int i99 = 100;

什么是数组
- 一种数据结构，用来存储同一类型之的集合
- 通过一个整形下标可以访问数组中的每一个值，从0开始计算，记住，特别重要
- 内存中存储相同数据类型的连续的空间

public class Test3 {
    public static void main(String[] args){
        // 定义一维数组
        int [] x =new int[5] ;
        // 给数组赋值
        x[0] = 5125;
        x[2] = 245;
        x[3] = 4152;
        x[4] = 4512;
        // 定义二维数组；
        int[][] t = new int[2][3];
        // 给二维数组赋值
        t[0][0] = 1;
        // 初始化一维数组
        int[] y= {51,23,635,234};
        String[] z= {"hello","world","bye bye"};
        // 初始化二维数组
        int[][] v= {{1,2},{3,4}};
        // 打印元素个数
        System.out.println(x.length);
        System.out.println(t.length);
    }
}

注意:

所有元素都初始化为 0，boolean 数组的元素会初始化为 false
旦创建了了数组，就不不能改变它的⼤大⼩小
数组需要初始化才可以操作，不不能索引越界

# Java内存空间堆栈

数据类型
- 基本数据类型 byte、short、int、long、 float、double、boolean、char
- 引⽤用数据类型，即除了了基本的变量量类型之外的所有类型
java在内存中存在堆、栈两块存储空间

# 数据类型在内存中的使用

基本的变量类型只有-块存储空间（分配在stack中），
- 传递的时候直接是值传递，
- 对数据进⾏操作，不影响原先的值
引用类型有两块存储空间（一块在stack中，一块在heap中）
- 一个对象在内存中会请求一块空间来保存数据，访问对象的时候不会直接是访问对象在内存中的数据，而是通过引用去访问

# 什么是引用？

也是一种数据类型，保存的是内存的地址，引用是存储在stack栈空间里面
不同的引用可以指向同一个对象，一个对象可以有多个引用

下面代码在堆栈里面怎么分配的

int a=1;
boolean flag=false;
Student s = new Student( ) ;
Person P = new Person( );

引用后修改结果如何呢？
- 因为字符串、数组或者对象是引用类型，所以修改后的数据都会发生变化
- 下面代码分别输出什么内容？

public class Test4 {
    public static void main(String[] args){
        String a = "@yuntaoscripts001";
        String b = "@yuntaoscripts002";
        System.out.println(a);
        System.out.println(b);
        System.out.println("b=a");
        b=a;
        System.out.println(a);
        System.out.println(b);
        System.out.println("a = \"@yuntaoscripts003\"");
        a = "@yuntaoscripts003";
        System.out.println(a);
        System.out.println(b);
    }
}

@yuntaoscripts001
@yuntaoscripts002
b=a
@yuntaoscripts001
@yuntaoscripts001
a = "@yuntaoscripts003"
@yuntaoscripts003
@yuntaoscripts001

数组拷贝，下面代码输出的是什么

数组是引用类型，所有的引用都是指向这个值的，也就是这个对象

import java.util.Arrays;
public class Test5 {
    public static void main(String[] args) {
        int[] a = {1, 2, 3};
        int[] b = a;
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(b));
        b[0] = 0;
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(b));
    }
}

输出结果
[1, 2, 3]
[1, 2, 3]
[0, 2, 3]
[0, 2, 3]

# 变量类型

# 类变量（静态变量）

使用static声明的变量，可以直接使用类名.变量名访问。
一个类不管创建了多少个对象，类只拥有类变量的一份拷贝，数值默认值是0，布尔型默认值是false，引用类型默认值是null
生命周期
- 在第一次被访问时创建，在程序结束时销毁
- 声明为public类型，一般这样声明public static final
存储在方法区，和堆栈不一样的一个空间


public class Test6 {
    public static String NAME;
    public static void static_set_NAME(String name){
        NAME = name;
    }
    public void class_set_name(String name){
        NAME = name;
    }
}

public class Test7
{
    public static void main(String[] args){
        System.out.println("default="+Test6.NAME);
        Test6.static_set_NAME("static_name");
        System.out.println("static_set_NAME="+Test6.NAME);
        Test6.NAME = "class_name";
        System.out.println("class_name="+Test6.NAME);
        Test6 test6 = new Test6();
        test6.class_set_name("class_method_name");
        System.out.println("class_method_name="+Test6.NAME);
    }
}

运行结果：
default=null
static_set_NAME=static_name
class_name=class_name
class_method_name=class_method_name

# 实例变量（属性）

需要使用对象.变量名才可以访问
对象被实例化之后，实例变量的值就跟着确定，可以是赋值，也可以是默认值
生命周期
- 在对象创建的时候创建，在对象被销毁的时候销毁
访问修饰符可以修饰实例变量，一般是私有的，private修饰，然后通过方法来行查看或者修改

public class Test8 {
    private String name;
    public static void main(String[] args){
        Test8 test8 = new Test8();
        System.out.println(test8.getName());
        test8.setName("hello world");
        System.out.println(test8.getName());
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
}

# 局部变量

方法中的变量
声明在方法、构造方法、语句块、形式参数等
生命周期
- 当它们执行完成后，变量将会被销毁
- 访问修饰符不能用于局部变量
- 局部变量没有初始值，必须初始化后才可以被使用

public class Test8 {
    private String name;
    private int age=19;
    public static void main(String[] args){
        Test8 test8 = new Test8();
        System.out.println(test8.getName());
        test8.setName("hello world");
        System.out.println(test8.getName());
    }
    public void setName(String name){
        age = 9;
        int height =0;  //如果不初始化报错
        this.name = name;
        System.out.println(height);
    }
    public String getName(){
        return name;
    }
}

public class Test9 {
    static String name = "@yuntaoscripts";
    int age=19;
    public  static void main(String[] args){
        Test9 test9 = new Test9();
        test9.showAge();
        System.out.println(name);
        showRes();
    }
    public static void showRes(){
        System.out.println("SHOW RES");
    }
    public void showAge(){
        System.out.println(age);
        showName();
    }
    public void showName(){
        System.out.println(name);
    }
}

总结

静态方法可以直接访问静态方法和静态变量，访问实例方法、实例变量需要需要创建对象。
实例方法可以直接访问实例方法，静态方法，实例变量，静态变量。

# 方法入参和返回值

方法入参
- 基础数据类型
- 引用数据类型

修饰符 返回类型 方法名 （参数类型参数名，参数类型参数名...）{
  //方法体
}

return 方法返回类型
- return XXX具体类型
- 如果不用返回，则方法返回类型. 上写void

修饰符 void 方法名 （参数类型参数名，参数类型参数名...）{
  //方法体
}

public class Test10 {
    public static void main(String[] args)
    {
        Student[] student = new Student[10];
        student[0] = new Student();
        changeAge(student[0],2);
        System.out.println(student[0].getAge());
    }
    public static void changeAge(Student student,int age){
        student.setAge(age);
    }
}
class Student{
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

# 运算符和优先级

# 算术运算符：

加法 +减法- 乘法* 除法/ 取余 % 自增1++ a++就是 a=a+1 自减1 a--就是 a=a-1 int a = 5; int b = a++; int c = ++a; int d = a--; int e = --a; 。注意自增（++）自减（--）运算符是一种特殊的算术运算符

o注意

■自增（++）自减（--）运算符是一种特殊的算术运算符自增（++）自减（一）在变量左右有不同的意义在变量左边则先自增减操作，再进行表达式运算 ■在变量右边则先进行表达式运算，在进行自增减操作 1自增和自减运算符只能用于操作变量，不能直接用于操作数值或常量

# 关系运算符

用于数值的比较，不能是字符串等其他非数值

等
不等！=
大于
大于或等于
小于
小于或等于<=

# 逻辑运算符

o逻辑与&& 仅当两个操作数都为真，条件才为真有短路作用 o逻辑或|| 任何两个操作数任何一个为真，条件为真 o有短路作用 o逻辑非！反转操作数，如果条件为true，则逻辑非运算符将得到false

# 赋值运算符

赋值 =加和赋值减和赋值乘和赋值除和赋值十 = = * = int a=5; int c=10; // c=c+a; c +=a; 放大文稿

# 三目运算符

格式条件？成功：否则例子 int age =5; age > 18： "成年"： "未成年"

# 运算符优先级

o和数学运算一样，可以加括号控制优先级■乘除取余*/% 加减+- 关系运算>，>=， <，<= 相等==、！= 逻辑与&& 逻辑或| 三目运算？：赋值=

← 快速链接