Java从入门到大神（一）| 起飞~起飞~起飞~

一、Java入门

1. 打开cmd

Win + R 打开管理器，输入框输入 cmd 按下回车打开cmd窗口

2. 常见cmd命令

3. 环境变量

3.1. 配置环境变量

右击我的电脑→找到属性→高级设置→环境变量→添加Path→写入要添加的环境地址

3.2. 使用环境变量

打开cmd命令窗口→输入环境变量下地址的程序即可执行

4. jdk的安装和说明

4.1. 安装

①进入网站Oracle | Cloud Applications and Cloud Platform

②点击Products下拉菜单，进入到Java界面

③点击下载Java

④选择合适自己的版本和系统，点击第二项进行下载

⑤下载完成之后傻瓜式下一步安装就行，注意安装路径不要中文名称和空格

4.2. 目录说明

5. HelloWorld小案例

①创建文本文件，改写名称和后缀.java

②写入HelloWorld文件

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

③使用cmd命令进入到jdk的bin目录下使用javac对HelloWorld.java文件进行编辑

javac HelloWorld.java

这样之后HelloWorld.java所在文件夹下就会出现一个HelloWorld.class文件

④使用命令java HelloWorld 命令执行HelloWorld.class文件，注意命令行写文件名没有后缀

6. 配置环境变量

Java自己配置的环境变量只有四个

自己配置方便后期使用

7. notepad++软件

notepad是一个高级记事本软件，能够显示行，重要代码高亮显示

①到notepad++官网下载安装包

②中间傻瓜式安装，无需任何操作，一直下一步

③在软件，点击设置→首选项→新建，进行以下操作

8. Java的用处

Java SE

Java ME

Java EE

Java能做什么？？？

9. 高级语言的运行方式

C/C++语言（编译型）整体编译，然后执行

Python（解释型）按行解释然后执行

Java（混合型）虚拟机

Java跨平台的原理：①Java语言的跨平台是通过虚拟机实现的。②Java语言不是直接运行在操作系统里面的，而是运行在虚拟机中的。③针对于不同的操作系统，安装不同的虚拟机就可以了。

10. JDK和JRE

运行代码所需的东西（以下三类合称JDK，JDK是Java开发工具包）：

①JVM(Java VirtualMachine)：Java虚拟机，真正运行Java程序的地方

②核心类库：比如输出时所用到的static类

③开发工具：Java编译工具、Java运行工具、jbd调试工具、jhat内存分析工具......

JRE是什么，有哪些内容组成？

①JRE的Java的运行环境

②JRE包含：JVM、核心类库、运行工具

JDK包含JRE，JRE包含JVM

二、Java基础概念

1. 注释

注意：

①注释内容不会参与编译和运行，仅仅是对代码的解释说明

②不管是单行注释还是多行注释，在书写的时候都不要嵌套

public class HelloWorld{
	//叫做main方法，表示程序的主入口
	public static void main(String []args){
		// 叫做输出语句
		System.out.println("HelloWorld~？？");
	}
}

2. 关键字

①关键字是Java赋予了特殊含义的英文单词

②关键字的字母全部小写

③常用的代码编辑器对关键字有特殊颜色的标记，比较直观

第一个关键字：class：用于（创建/定义）一个类，类的Java最基本的组成单元

3. 字面量

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

制表符：在打印的时候，把前面字符串的长度补齐到8，或者8的整数倍。最少补1个空格，最多补8个空格

public class ValueDemo1{
	public static void main(String [] args){
		// 目标：掌握常见数据再代码中如何书写
		
		// 整数
		System.out.println(666);
		System.out.println(-777);
		
		// 小数
		System.out.println(1.93);
		System.out.println(-3.71);
		
		// 字符串
		System.out.println("KissFeng");
		
		// 字符
		System.out.println('s');
		
		// 布尔
		System.out.println(true);
		System.out.println(false);
		
		// 空(空不能直接打印，若要打印，可以用"null"）
		System.out.println("null");
	}
}

public class ValueDemo1{
	public static void main(String [] args){
		// 目标：掌握制表符的用法
		// "\t"把前面字符串的长度补齐到8
		System.out.println("name" + "\t" + "age");
		System.out.println("Tom" + "\t" + "20");
	}
}

4. 变量

4.1. 知识点

变量：在程序的执行过程中，其值有可能发生改变的量(数据)

定义方法：数据类型 变量名 = 变量值

public class VariableDemo2{
	public static void main(String [] args){
		// 1.变量基本用法：定义输出
		int a = 10;
		System.out.println(a);
		
		// 2.变量参与计算
		int b = 30;
		int c = 20;
		System.out.println(b + c);
		
		// 3.修改变量记录的值
		a =  50;
		System.out.println(a);
	}
}

注意：

①只能存一个值

②变量名不允许重复定义

③一条语句可以定义多个变量

int d = 100, e = 200, f = 300;
System.out.println(d);	// 100
System.out.println(e);	// 200
System.out.println(f);	// 300

④变量在使用之前一定要进行赋值

int g;
System.out.println(g);		//报错

⑤变量的作用域范围

4.2. 练习

public class VariableTest{
	public static void main(String [] args){
		//一开始没有乘客。
		int count = 0;
		//第一站:上去一位乘客
		count += 1;
		//第二站:上去两位乘客下来一位乘客
		count += 2;
		count -= 1;
		//第三站:上去两位乘客，下来一位乘客
		count += 2;
		count -= 1;
		//第四站:下来一位乘客
		count -= 1;
		//第五站:上去一位乘客
		count += 1;
		//请问:到了终点站，车上一共几位乘客
		System.out.println(count);		// 3
	}
}

5. 计算机数据存储

计算机中任意的数据都是以二进制的形式来存储的。

常见的进制：

二进制:由0和1组成，代码中以0b开头

十进制:由0~9组成，前面不加任何前缀

八进制:由0~7组成，代码中以0开头

十六进制:由0~9还有a~f组成，代码中以0x开头

Text文本：二进制、码表

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

分辨率，像素，三原色

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

6. 数据类型

要注意：先定义后输出，定义long、float要在整型结尾加上L、F

public class VariableDemo2{
	public static void main(String [] args){
		// byte
		byte b = 10;
		System.out.println(b);
		// short
		short s = 200;
		System.out.println(s);
		// int
		int i = 1000;
		System.out.println(i);
		// long
		// 定义long类型的数据，需要在结尾加上L(大写小写都行)
		long n = 9999999999L;
		System.out.println(n);		// 输出时候不显示L
	}
}

整数和小数取值范围大小关系：double>float>long >int >short > byte

7. 标识符

7.1. 命名规则

硬性要求：

软性建议：

8. 键盘录入

9. IEDA的讲解

三、运算符

1. 算数运算符

2. 隐式转换和强制转换

2.1. 隐式转换

隐式转换的两种提升规则：

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

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

2.2. 强制转换

3. 字符串加操作

第二个重点看

char类型的数据在运算的时候，都会直接先提升为int，然后再进行运算

4. 逻辑运算符

5. 三元运算符

6. 原码反码补码

第一个1表示负数，0表示正数

正数就是正常的二进制数字

反码出现的目的：

为了解决原码不能计算负数的问题而出现的。

反码的计算规则：

正数的反码不变，负数的反码在原码的基础上符号位不变,数值取反，0变1，1变0

反码的弊端：

负数运算的时候，如果结果不跨0，是没有任何问题的，但是如果结果跨0，跟实际结果会有1的偏差。

补码出现的目的：

为了解决负数计算时跨0的问题而出现的。

补码的计算规则：

正数的补码不变，负数的补码在反码的基础上+1。另外补码还能多记录一个特殊的值-128，该数据在1个字节下，没有原码和反码

补码的注意点：

计算机中的存储和计算都是以补码的形式进行的。

7. 其他运算符

逻辑与（全为1则为1）

逻辑或（只要有1就是1）

左移（低位补0）相当于乘2的移动的次方

右移（高位补0或1）相当于除以2的移动的次方

8. 键盘录入

8.1. 第一套体系

nextInt();接收整数

nextDouble();接收小数

next();接收字符串

ps：遇到空格，制表符，回车就停止接收，这些符号后面的内容不会接收了，如果有空格，会给下一次输入的内容赋值，就不需要下一次录入了

8.2. 第二套体系

nextLine();接收字符串

ps：可接收空格，制表符，遇到回车才停止接收

两种体系不宜混用，会出现问题，因为第一套体系中遇到回车停止，这个对象就结束了，不会再执行第二体系中的方法，如果是空格，则空格及其以后的数据赋值给第二体系

8.3. 两套体系同时使用解决方案

创建两个对象，一个对象使用第一个体系， 一个对象使用第二个体系可以避免这个问题的出现

四、判断和循环

1. 条件语句

格式：
if (关系表达式1) {
    语句体1;	
} else if (关系表达式2) {
    语句体2;	
} 
…
else {
    语句体n+1;
}

2. switch语句

switch (表达式) {
	case 1:
		语句体1;
		break;
	case 2:
		语句体2;
		break;
	...
	default:
		语句体n+1;
		break;
}

扩展知识：

• default的位置和省略情况：default可以放在任意位置，也可以省略
• case穿透：不写break会引发case穿透现象

JDK12以后版本新增特性：自动包含break，如果有多条语句需要用到花括号。

int number = 10;
switch (number) {
    case 1 -> System.out.println("一");
    case 2 -> System.out.println("二");
    case 3 -> System.out.println("三");
    default -> System.out.println("其他");
}

case多个数据：

import java.util.Scanner;
public class test1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入星期：");
        int day = sc.nextInt();
        switch (day) {
            case 1,2,3,4,5 -> System.out.println("工作日");
            case 6,7 -> System.out.println("休息日");
            default -> System.out.println("不存在");
        }
    }
}

3. for循环while循环

public class test2 {
    // 回文数字
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整型：");
        int a = sc.nextInt(), num = 0;
        int n = a;
        while (a != 0) {
            int ge = a % 10;
            a = a / 10;
            num = num * 10 + ge;
        }
        System.out.println("判断" + a + "是否为回文数字的结果为：" + (num == n));
    }
}

两种无限循环：

for (; ; ) {}
while (true) {}

4. 流程控制关键字

continue：跳过本次循环，继续执行下次循环。

break：结束整个循环，直接跳出循环。

public class random {
    public static void main(String[] args) {
        Random r = new Random();
        int a = r.nextInt(0, 100);
        Scanner sc = new Scanner(System.in);
        int count = 0;
        while (true) {
            System.out.println("请输入你猜的数字：");
            int b = sc.nextInt();
            count++;
            if (a > b) {
                System.out.println("猜小了");
            } else if (a < b) {
                System.out.println("猜大了");
            } else {
                System.out.println("猜中了， 猜了" + count + "次");
                break;
            }
        }
    }
}

五、数组

1. 概述和静态初始化

数组的静态初始化：

int[] a = new int[]{1,2,3,4,5};
double[] b = new double[]{1.1, 2.2, 3.3};

//简化之后
int[] a = {1,2,3,4,5};
double[] b = {1.1, 2.2, 3.3};
String[] s = {"Python", "C++", "Java", "Go"};

2. 数组的地址和元素访问

用 数组名.length 的方式获取一个数组的长度，也就是元素的个数

public class arraydemo1 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5};
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
}

idea快速生成：数组名.fori + 回车 生成

若是想要删除数组中的一个元素，则 数组名[索引] = null 即可完成删除

3. 动态初始化

先创建这个数组，然后再添加数据

public class arraydemo2 {
    public static void main(String[] args) {
        String[] arr = new String[10];
        arr[0] = "a";
        arr[1] = "b";
        System.out.println(arr[0]);	// a
        System.out.println(arr[1]);	// b
        System.out.println(arr[2]);	// null
    }
}

数组默认初始化值的规律：

//整数类型:默认初始化值0

//小数类型:默认初始化值0.0

//字符类型:默认初始化值 '/u0000' 空格

//布尔类型:默认初始化值 false

//引用数据类型:默认初始化值 null

public class test1 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        for (int i = 0, j = array.length - 1; i < j; i++, j--) {
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.println("array[" + i + "] = " + array[i]);
        }
    }
}

import java.util.Random;

public class test2 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            int x= r.nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[x];
            arr[x] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

4. 数组的内存图

栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行

堆：存储对象或者数组，new来创建的，都存储在堆内存

方法区：存储可以运行的class文件

本地方法栈：JVM在使用操作系统功能的时候使用，和我们开发无关

寄存器：给CPU使用，和我们开发无关

六、方法

1. 方法的定义和调用

1.1. 概念

1.什么是方法?

方法是程序中最小的执行单元，

2.实际开发中，什么时候用到方法?

重复的代码、具有独立功能的代码可以抽取到方法中。

3.实际开发中，方法有什么好处?

可以提高代码的复用性

可以提高代码的可维护性

1.2. 定义

2. 方法的重载

在同一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能。

每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系

public class test1 {
    public static void main(String[] args) {
        // 1.定义byte型的变量再进行使用
        byte a = 10;
        byte b = 20;
        compare(a, b);
        // 2.强制转换int型进行使用
        compare((int) a, (int) b);
    }
    public static void compare(short b1, short b2) {System.out.println("byte");}
    public static void compare(int b1, int b2) {System.out.println("int");}
    public static void compare(long b1, long b2) {System.out.println("long");}
}

3. 方法的练习

public class test2 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        System.out.println("情况：" + Test(1, arr));
    }
    public static boolean Test(int i, int[] j) {
        for (int i1 = 0; i1 < j.length; i1++) {
            if (i == j[i1]) return true;
        }
        return false;
    }
}

public class test3 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9};
        int[] arr2 = copyArray(arr, 5, 8);
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
    }
    // 返回值类型是一个整型的数组   参数：数组  从第几个开始  到第几个结束
    public static int[] copyArray(int[] arr, int start, int end) {
        int[] newArr = new int[end - start + 1];  // +1是为了包前包后
        for (int i = start, j = 0; i <= end; i++, j++) {
            newArr[j] = arr[i-1];
        }
        return newArr;
    }
}

4. 方法调用的基本内存原理

先进栈的后出栈；后进栈的先出栈；

每完成一个方法，就将该方法进行出栈操作；

5. 基本数据类型和引用数据类型

七、综合练习

1. 五位验证码

import java.util.Random;
public class test1 {
    public static void main(String[] args) {
        // 创建一个动态字符数组
        char[] chs = new char[52];
        // 在动态数组中添加数据
        for (int i = 0; i < chs.length; i++) {
            if (i <= 25) {
                chs[i] = (char) ('a' + i);
            }else {
                chs[i] = (char) ('A' + i - 26);
            }
        }
        // 取出四个随机字符型数组
        Random r = new Random();
        for (int i = 0; i < 4; i++) {
            int x = r.nextInt(chs.length);
            System.out.print(chs[x] + " ");
        }
        // 取出一个0~9的数字
        int y = r.nextInt(0, 10);
        System.out.print(y);
    }
}

2. 双色球彩票系统

import java.util.Random;
public class test3 {
    public static void main(String[] args) {
        int[] arr = createArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    // 生成数组
    public static int[] createArray() {
        int[] arr = new int[7];
        Random r = new Random();
        int i = 0;
        // 在1~33的红球中抽6个，不重复
        while (i < arr.length - 1){
            int num = r.nextInt(1, 34);
            // test函数去重
            if (test(num, arr)) {
                arr[i] = num;
                i++;
            }
        }
        // 在1~16个蓝球中抽1个
        int seven = r.nextInt(1, 17);
        arr[6] = seven;
        return arr;
    }
    // 判断整型是否在数组中
    public static boolean test(int i, int[] arr) {
        for (int j = 0; j < arr.length; j++) {
            if (i == arr[j]) return false;
            }
        return true;
        }
}