Java入门二刷

Java基础概念

JDK和JRE

JDK是Java开发工具包，包含JVM虚拟机（Java程序运行的地方），核心类库（Java已写好的东西，可直接引用），开发工具（javac、java、jdb、jha等等）

JRE是Java运行环境，有JVM、核心类库、运行工具。（JDK包含了JRE）

关键字

关键字全部小写

class

用于（创建/定义）一个类，类是Java最基本的组成单元

字面量

告诉程序员数据在程序中的书写格式

字面量类型

整数类型，字符串类型，字符类型，布尔类型，空类型（null不能直接打印）

\ t :在打印的时候，把前面字符串的长度补齐到8，或者是8的倍数，最多补8个空格

计算机数据的存储

文本：数字（转二进制）、字母（查询码表）、汉字（查询码表）

图片：通过每一个像素点中的RGB三原色来存储

声音：对声音的波形图进行采样再存储

数据类型

基本数据类型

|------|----------------|
| 数据类型 | 关键字 |
| 整数 | byte（-128～127） |
| 整数 | short |
| 整数 | int |
| 整数 | long（L或l后缀） |
| 浮点数 | float（F或f后缀） |
| 浮点数 | double |
| 字符 | char |
| 布尔 | boolean |

标识符

给类、方法、变量起的名字

命名规则：

• 由数字、字母、下划线和美元符$组成
• 不能以数字开头
• 不能是关键字
• 区分大小写

方法、变量：小驼峰（name、firstName)

类名：大驼峰（Student、GoodStudent）

键盘录入

Scanner类

1.导包

import java.util.Scanner;

2.创建对象

Scanner sc = new Scanner(System.in);

3.接收数据

 int i=sc.nextInt();

运算符

隐式转换

取值范围小的和取值范围大的进行转换，小的会先提升大的，再进行运算

byte、short、char三种类型的数据在运算的时候，都会先提升为int，然后再进行运算

取值范围：double>float>long>int>short>byte

大的赋值给小的需要强制转换：（但是可能会发生错误）

double a=12.3;
int b=(int)a;

字符串

当"+"操作中出现字符串时,这个"+"是字符串连接符,而不是运算符,会将前后的数据拼接,产生一个新的字符串,连续进行"+"操作时,从左到右逐个执行.

"123"+123;//123123
1+99+"年";//100年
1+2+"abc"+1+2;//3abc12
0+'a';//97
'a'+"abc"//aabc

关系运算符(比较运算符)

= > < != <= >=

结果都是boolean类型的,要么是true,要么是false.

逻辑运算符

|----|--------|------------------|
| 符号 | 作用 | 说明 |
| & | 逻辑与(且) | 并且,都为真才是真 |
| | | 逻辑或 | 或者,都为假才是假 |
| ^ | 逻辑异或 | 相同为false,不同为true |
| ! | 逻辑非 | 取反 |

短路逻辑运算符

|------|-----|----------------|
| 符号 | 作用 | 说明 |
| && | 短路与 | 结果和&相同,但有短路效果 |
| || | 短路或 | 结果和|相同,但有短路效果 |

判断和循环

顺序结构

分支结构

• if
• switch

循环结构

• for：知道循环的次数或者循环的范围
• while：不知道循环的次数和范围，只知道循环的结束条件
• do while

无限循环

for(;;){
}

while(true){
}//使用最多

do{
}while(true)

跳转控制语句

• continue：跳过本次循环，继续执行下次循环
• break：结束整个循环

数组

数组的静态初始化

手动指定数组元素

完整格式：数据类型[ ] 数组名 = new 数据类型 [ ]{元素1，元素2，元素3...};

int []array = new int []{11,22,33};
String []arr2 = {"zhangsan","lisi","wangwu"};//简化格式

数组的地址值

String[]arr={"zhhangsan","lisi"};
System.out.println(arr);//[Ljava.lang.String;@6bdf28bb

• [：表示当前是一个数组
• Ljava.lang.String;：表示当前数组里面元素的类型是String类型的
• @：表示一个间隔符号
• 6bdf28bb：数组的真正的地址值

遍历数组

String[]arr={"zhhangsan","lisi"};
System.out.println(arr.length);//2
 for (int i=0;i<arr.length;i++){
      System.out.println(arr[i]);
     }

快速操作（idea提供）：数组名.fori

数组动态初始化

手动指定数组的长度，由系统为数组分配初始值。

格式：数据类型[ ] 数组名 = new 数组类型[数组长度]

数组默认初始化

• 整数类型：默认初始化值 0
• 小数类型：默认初始化值 0.0
• 字符类型：默认初始化值 '/u0000'
• 布尔类型：默认初始化值 false
• 引用数据类型：默认初始化值 null

练习：打乱数组元素的顺序

 public static void main(String[] args) {
        int []arr={1,2,3,4,5};
        Random random= new Random();
        for (int i = 0; i < arr.length; i++) {
            int index= random.nextInt(arr.length);
            int temp =arr[i];
            arr[i]=arr[index];
            arr[index]=temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]+" ");
        }
    }

数组的内存图

Java内存分配

• 栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行
• 堆：存储对象或者数组，new来创建的，都存储在堆内存
• 方法区：存储可以运行的class文件
• 本地方法栈：JVM在使用操作系统功能的时候使用，和开发无关
• 寄存器：给CPU使用，和开发无关

1. 只要是new出来的一定是在堆里面开辟了一个小空间
2. 如果new了多次，那么在堆里面有多个小空间，每个小空间都有各自的数据
3. 当两个数组指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次访问的时候就是修改之后的结果了

方法

方法是程序中最小的执行单元。在实际开发中，可以将重复的代码、具有独立功能的代码可以抽取到方法中，这样可以提高代码的复用性和可维护性。

方法和方法之间不能嵌套

没有返回值（void）可以省略return;但是如果写return;后面不能加具体的数值

方法的定义和调用

定义在main方法的外面，调用在main方法的里面（先定义后调用）

最简单

public static void main(String[] args) {
   method();
}
public static void method(){
}

带参数

public static void main(String[] args) {
   method(10,20);
}
public static void method(int a,int b){
int sum=a+b;
System.out.println(sum);
}

• 形参：方法定义中的参数（需要什么才能完成方法的定义）
• 实参：方法调用中的参数

带返回值

方法的返回值就是方法运行的最终结果。

使用场景：根据方法的结果要去编写另一段代码

 public static int method(int a,int b){ //将void改为返回值的类型
    int sum=a+b;
    return sum;//return 返回值
    }

调用：

• 直接调用
• 赋值调用
• 输出调用

方法的重载

在同一个类中定义了多个同名的方法，这些同名的方法具有同种功能，每个方法具有不同的参数类型或参数个数，这些同名的方法构成了重载关系。

同一个类（class）中，方法名相同，参数不同的方法。与返回值无关。

参数不同：个数不同，类型不同，顺序不同。

方法的基本内存原理

• 基本数据类型：数据值是存储在自己的空间（栈）中。赋值给其他变量，也是赋的真实的值。
• 引用数据类型：数据值是存储在其他空间（堆）中，自己空间（栈）中存储的是地址值。赋值给其他变量，赋的地址值。

public static void main(String[] args) {
    int num=100;
    System.out.println(num);//100
    change(num);
    System.out.println(num);//100
}
public static void change(int num) {
     num=200;
}

public static void main(String[] args) {
    int num=100;
    System.out.println(num);//100
    num =change(num);
    System.out.println(num);//200
}
public static int change(int num) {
    num=200;
    return num;
}

对比以上代码，传递基本数据类型时，传递的是真实的数据，形参的改变不影响实际参数的值。

 public static void main(String[] args) {
        int []arr={1,2,3};
        System.out.println(arr[1]);//2
        change(arr);
        System.out.println(arr[1]);//20
    }
    public static void change(int []arr) {
        arr[1]=20;
    }

传递引用数据类型时，传递的是地址值，形参的改变影响实际参数的值

面向对象

类和对象

• 类：是共同特征的描述（设计图）；
• 对象：是真实存在的具体实例。

public class PhoneTest {
public static void main(String[] args) {
    Phone p=new Phone();//类名 对象名 = new 类名（）；
    p.brand="xiaomi";//访问行为：对象名.方法名（）
    System.out.println(p.brand);
    p.call();//访问属性：对象名.成员变量（）
    }
}
public class Phone {//得到对象
    String brand;//成员变量，名词
    public void call(){//成员方法，动词
        System.out.println("打电话");
    }
}

• 测试类：编写main方法，在测试类中可以创建javabean类的对象进行赋值调用
• Javabean类：不写main方法，用来描述一类事物

public class Student {
    //属性（成员变量）
    String name;
    double height;
    //行为（方法）
    public void study(){
    }
    public void sleep(){
    }
}

成员变量的完整定义格式是：修饰符 数据类型 变量名称 = 初始化值;（一般无需指定初始化值，存在默认值0，0.0，null）

封装

对象代表什么，就得封装对应的数据，并提供数据对应的行为。

private关键字

private关键字是一个权限修饰符，可以修饰成员变量和方法，被private修饰的成员只能在本类中才能访问。

针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作：

• 提供"setXxxx(参数)"方法，用于给成员变量赋值，方法用public修饰
• 提供"getXxxx()"方法，用于获取成员变量的值，方法用public修饰

就近原则和this关键字

private int age;
        public void method(){
            int age =20;
            System.out.println(age);//20，就近原则局部变量
            System.out.println(this.age);//0，成员变量
        }

构造方法

public class Student {
    修饰符 类名（参数）{
          方法体；
    }
}

特点：

1. 方法名和类名相同，大小写也要一致
2. 没有返回值类型和void
3. 没有具体的返回值，不能由return带回结果数据

构造方法的定义：

• 如果没有定义构造方法，系统将会给出一个默认的无参数构造方法
• 如果定义了构造方法，系统将不再提供默认的构造方法

构造方法的重载：带参构造方法和无参数的构造方法，两者方法名相同，但参数不同