【Java】Java基础

松垮的屁兜

已于 2024-11-15 17:33:42 修改

阅读量1.4k

点赞数 8

文章标签： java

于 2024-05-24 16:55:48 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_38517665/article/details/139178772

版权

JAVA

学习顺序
第一部分：Java基础=》JavaSe
一、第一阶段
二、第二阶段
三、第三阶段
第二部分：Java高级
第三部分：JavaWeb
第四部分：主流的框架和项目管理

来源b站：https://www.bilibili.com/video/BV1fh411y7R8?p=1&vd_source=d72708da7af98fb37e7ffbdac67ee2ee
百度网盘：https://pan.baidu.com/s/1YB9bKDTiW3WTJ94vGtCmJA 提取码: njup
相关资料：Java发展史：https://www.oracle.com/cn/java/technologies/java-se-support-roadmap.html JDK官网：https://www.oracle.com/java/technologies/javase-downloads.html
参考文档：链接：https://pan.baidu.com/s/1FJB0Uj_zIGVZBBjzfPVL_g 提取码：ltsb

学习顺序

在这里插入图片描述

第一部分：Java基础=》JavaSe

一、第一阶段

1、Java概述

在这里插入图片描述

1.1 特点

在这里插入图片描述

1.2 安装

在这里插入图片描述

1、windows安装JDK
2、配置环境变量
3、doc重新打开窗口

在这里插入图片描述

1.3 编译运行

在这里插入图片描述

如果有中文，文件编码和dos编码需要保持一致

编译运行

运行的本质是把.class文件装载到JVM（java虚拟机）进行执行 被注释的不会被解释执行

1.4 编写细节

在这里插入图片描述

1.5 转义字符

在这里插入图片描述

1.6 注释

单行注释：// 注释文字
多行注释：/* 注释文字 */
文档注释[javadoc]：/** 注释文字 */
生成网页文档的方式：javadoc -d 存放网页的文件地址 -要生成的标签目标文件名.java

生成的网页文件示例

1.7 代码规范

在这里插入图片描述

1.8 API

在这里插入图片描述

1.9 DOS

基本原理：
在这里插入图片描述
基本指令（重点在linux中用，dos中了解就可以）：

返回上级：cd ..
查看指定目录下所有子级目录：tree 目录地址
清屏：cls
退出dos：exit
创建目录：md 文件夹1 文件夹2...
删除目录：rd 文件夹1 文件夹2...
拷贝文件：copy 源文件文件路径 目标路径
删除文件: del 文件名
创建文件并输入内容：echo 内容 > 文件夹

※ 本章总结

【章节总结P34】

2、变量

在这里插入图片描述

2.1 变量

在这里插入图片描述

2.2 数据类型

在这里插入图片描述

基本数据类型：

整数类型

在这里插入图片描述

浮点类型

在这里插入图片描述

字符类型

在这里插入图片描述

布尔类型

在这里插入图片描述

2.3 数据类型转换

自动转换

在这里插入图片描述

强制转换

在这里插入图片描述

基本数据类型和String类型的转换

在这里插入图片描述

引用数据类型：

※ 本章总结

【章节总结P62】

3、运算符

在这里插入图片描述

3.1 类型

1、算术运算符

在这里插入图片描述

2、关系运算符【比较运算符】

在这里插入图片描述

3、逻辑运算符

在这里插入图片描述

4、赋值运算符

在这里插入图片描述

5、三元运算符

在这里插入图片描述

3.2 优先级

在这里插入图片描述

3.3 标识符

在这里插入图片描述

3.4 键盘输入（Scanner类）

在这里插入图片描述

3.5 进制

介绍

在这里插入图片描述

转换

在这里插入图片描述

1、其他进制转十进制（乘）

在这里插入图片描述

2、十进制转其他进制（除）

在这里插入图片描述

3、低位转高位（8421相加）

在这里插入图片描述

4、高位转低位（8421分解）

在这里插入图片描述

3.6 原码、反码、补码

在这里插入图片描述

3.7 位运算符

在这里插入图片描述

※ 本章总结

【章节总结P102】

4、控制结构

在这里插入图片描述

4.1 顺序

4.2 分支

1、if else

2、switch

在这里插入图片描述

穿透是指执行完语句块1后，没有break等退出或结束语句，继续往下执行语句块
在这里插入图片描述

4.3 循环

1、for

在这里插入图片描述
！执行顺序重点

2、while

在这里插入图片描述

3、do while

在这里插入图片描述

4.4 多重循环

在这里插入图片描述

// 九九乘法表
public class Hello{
    public static void main(String[] args){
        for(int i = 1; i <= 9; i++){
            for(int j = 1; j<= i; j++){
                System.out.print(j + " * " + i + " = " + i * j + "  ");
            }
            System.out.println("");
        }
    }
}

结果：
在这里插入图片描述

在这里插入图片描述

// 基础版金字塔
import java.util.Scanner;
public class Hello{
    public static void main(String[] args){
     	Scanner myScanner = new Scanner(System.in);
        System.out.print("请输入层数：");
        int num = myScanner.nextInt();

        for(int i = 1; i <= num; i++){// 行数
            for(int j = 1; j <= i; j++){// 数量
                System.out.print("*");
            }
            System.out.println("");
        }
    }
}

结果：
在这里插入图片描述

在这里插入图片描述

// 进阶版金字塔
import java.util.Scanner;
public class Hello{
    public static void main(String[] args){
    	Scanner myScanner = new Scanner(System.in);
        System.out.print("请输入层数：");
        int num = myScanner.nextInt();

        for(int i = 1; i <= num; i++){// 行数
            // 空格
            for(int k = 1; k <= num - i; k++){
                    System.out.print(" ");
            }

            // 数量
            for(int j = 1; j <= 2 * i - 1; j++){
                System.out.print("*");
            }
            System.out.println("");
        }
    }
}

结果：
在这里插入图片描述

// 进阶版空心金字塔
import java.util.Scanner;
public class Hello{
    public static void main(String[] args){
    	Scanner myScanner = new Scanner(System.in);
        System.out.print("请输入层数：");
        int num = myScanner.nextInt();

        for(int i = 1; i <= num; i++){// 行数
            // 空格
            for(int k = 1; k <= num - i; k++){
                    System.out.print(" ");
            }

            // 数量
            for(int j = 1; j <= 2 * i - 1; j++){

                // 空心:第一个位置和最后一个位置都是*，其余为空
                if(j == 1 || j == 2 * i - 1 || i == num){
                    System.out.print("*");
                }else{
                    System.out.print(" ");
                }
            }
            System.out.println("");
        }
    }
}

结果：
在这里插入图片描述

4.5 break

在这里插入图片描述

字符串是否相等的方法，返回true or false

结果：

4.6 continue

在这里插入图片描述

4.7 return

在这里插入图片描述

4.8 三者区别

break：结束循环，循环不再执行
continue：结束本次循环，继续执行下一循环
return：完结
在这里插入图片描述

※ 本章作业

// 1.编程实现如下功能
// 1)某人有100,000元,每经过一次路口，需要交费，规则如下:1)当现金>50000时,每次交5%
// 2)当现金<=50000时,每次交1000编程计算该人可以经过多少次路口,要求: 使用 while break方式完成
public class Hello{
    public static void main(String[] args){
        double money = 100000;
        int sum = 0;
        while(true){
            if(money > 50000){
                money -= money * 0.05;
                sum++;
            }else if(money >= 1000){
                money -= 1000;
                sum++;
            }else{
                break;
            }
        }
        System.out.println(money + "可以过" + sum + "次路口");
    }
}

// 结果: 剩767.4979115529859可以过62次路口

// 4.判断一个整数是否是水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。例如:153=1*1*1+3*3*3+5*5*5
// ！！！思路：百位：n / 100  十位：n % 100 / 10  个位：n % 10
public class Hello{
    public static void main(String[] args){
		int n = 153;
		int n1 = n / 100;
		int n2 = n % 100 / 10;
		int n3 = n % 10;
		if(n1 * n1 * n1 + n2 * n2 * n2 + n3 * n3 * n3 == n){
		    System.out.println(n + "是水仙花数");
		}else{
		    System.out.println(n + "不是水仙花数");
		}
	}
}
// 结果：153是水仙花数

// 5.看看下面代码输出什么?
public static void main(String[] args) {
     int m=0,n=3;
     if(m>0){
         if(n>2)
             System.out.println("◎K1");// √
         else
             System.out.println("◎K2");
     }
} 

// 结果：没有任何输出

// 6.输出1-100之间的不能被5整除的数，每5个一行
public static void main(String[] args) {
	int count = 0;
	for(int i = 1; i <= 100; i++){
	    if(i % 5 != 0){
	        count++;
	        System.out.print(i + " ");
	        if(count % 5 == 0){
	            System.out.println("");
	        }
	    }
	}
}

// 结果: 
1 2 3 4 6 
7 8 9 11 12
13 14 16 17 18
19 21 22 23 24
26 27 28 29 31
32 33 34 36 37
38 39 41 42 43
44 46 47 48 49
51 52 53 54 56
57 58 59 61 62
63 64 66 67 68
69 71 72 73 74
76 77 78 79 81
82 83 84 86 87
88 89 91 92 93
94 96 97 98 99

// 7.输出小写的a-z以及大写的Z-A
public static void main(String[] args) {
     for(char i = 'a'; i <= 'z'; i++){
         System.out.print(i);
     }

     System.out.println();

     for(char j = 'Z'; j >= 'A'; j--){
         System.out.print(j);
     }
}

// 结果： 
abcdefghijklmnopqrstuvwxyz
ZYXWVUTSRQPONMLKJIHGFEDCBA

// 8.求出1-1/2+1/3-1/4....1/100的和
public static void main(String[] args) {
	double sum = 0;
	for(int i = 1; i <= 100; i++){
	    if(i % 2 == 0){// 偶数
	        sum -= 1.0/i; // 隐藏陷阱：要把分子写成浮点数才能得到精确的小数
	    }else{
	        sum += 1.0/i;
	    }
	}
	System.out.println(sum);
}

// 结果：0.688172179310195

// 9.求1+(1+2)+(1+2+3)+(1+2+3+4)+...+(1+2+3+..+100)的结果
public static void main(String[] args) {
    int sum = 0;
    for(int i = 1; i <= 100; i++){
        for(int j = 1; j <= i; j++){// 内层对1-i进行循环
            sum += j;
        }
    }
    System.out.print(sum);
}

// 结果：171700

※ 本章总结

【章节总结P153】

5、数组、排序、查找

在这里插入图片描述

5.1 一维数组

1、数组使用

在这里插入图片描述

※ 课堂练习

 // 1、创建一个char类型的26个元素的数组，分别放置"A'-Z'。使用for循环访问所有元素并打印出来
 public class Hello{
    public static void main(String[] args){
        char[] arr = new char[26];// 空数组
        for(int i = 0; i < arr.length; i++){
            arr[i] = (char)('A' + i);
        }
        System.out.println(arr);
     }
 }

// 结果：ABCDEFGHIJKLMNOPQRSTUVWXYZ

public class Hello{
    public static void main(String[] args){
        // 2、请求出一个数组int[]的最大值{4,-1,9，10,23}，并得到对应的下标
        int[] arr = {4, -1, 9, 10, 23};
        int max = arr[0];
        int index = 0;

        for(int i = 0; i < arr.length; i++){
            if(arr[i] > max){
                max = arr[i];
                index = i;
            }
        }
    }
}

// 结果：max:23 index:4


// 3、请求出一个数组的和和平均值。(养鸡场)
public class Hello{
    public static void main(String[] args){
        int[] arr = {1, 3, 8, 12};
        double total = 0;
        double avg = 0;
        for(int i = 0; i < arr.length; i++){
            total += arr[i];
        }

        avg = total / arr.length;
        System.out.println("total:" + total + " avg:" + avg);
    }
}

// 结果：total:24.0 avg:6.0

2、数组赋值

在这里插入图片描述

1）引用传递（数组默认）

在这里插入图片描述

2）值传递

在这里插入图片描述

3、数组反转

在这里插入图片描述

4、数组添加&缩减

在这里插入图片描述

5.2 排序

在这里插入图片描述

1、冒泡排序

在这里插入图片描述

5.3 查找

1、顺序查找

在这里插入图片描述

2、二分查找

5.4 多维数组 - 二维数组

1、二维数组介绍

在这里插入图片描述

※ 课堂练习

在这里插入图片描述

2、二维数组使用

在这里插入图片描述

※ 课堂练习

// 1、遍历该二维数组，并得到和
public class Hello{
    public static void main(String[] args){
        int arr[][]={{4,6},{1,4,5,7},{-2}}; 
        int sum = 0;
        for(int i = 0; i < arr.length; i++){// 二维数组中的一维数组
            for(int j = 0; j < arr[i].length; j++){// 一维数组中的元素
                sum += arr[i][j];
            }
        }
        System.out.println(sum);
    }
}

结果：25

// 2、使用二维数组打印一个 10行  杨辉三角
// 1
// 1 1
// 1 2 1
// 1 3 3 1
// 1 4 6 4 1
// 1 5 10 10 5 1
// ...
int[][] arr = new int[10][];
for(int i = 0; i < arr.length; i++){// 一维数组
    
    arr[i] = new int[i + 1];// 给每个一维数组开新空间 !!!重要，容易忽略!!!

    for(int j = 0; j < arr[i].length; j++){// 填充一维数组中元素
        if(j == 0 || j == arr[i].length - 1){
            arr[i][j] = 1;
        }else{
            arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
        }
        System.out.print(arr[i][j] + "\t");
    }

    System.out.println();
}

在这里插入图片描述

※本章作业

// 1.下面数组定义正确的有__BD__ Homework01.java
 A. String strs[] = { 'a' ,'b', 'c'} // × 类型错误， 单引号为char
 B. String[] strs = {"a","b","c"}// √ 静态赋值
 C. String[] strs = new String{"a" "b"} // × 没有这种写法，new String后面应该为[大小]格式
 D. String strs[]= new String[]{"a","b","c"} // √
 E. String[] strs = new String[3]{"a","b","c"} // × 

 // 解析：定义一维数组的三种方式：
 // 1）动态赋值：数据类型[] 数组名 = new 数据类型[大小];
 // 2）动态赋值：先定义：数据数据类型[] 数组名;  再赋值：数组名 = new 数据类型[大小];
 // 3）静态赋值：数据类型[] 数组名 = {元素值，元素值....};


// 2.写出结果 Homework02.java
String foo = "blue";
boolean[] bar = new boolean[2];
if(bar[0]){
    foo = "green";
}
System.out.print(foo); 

// 结果：blue  
// 解析：因为boolean默认值为false


// 3.以下Java代码的输出结果为()。Homework03.java
int num = 1;
while(num < 10){
    System.out.println(num);
    if(num>5){
        break;
    }
    num += 2;
}

// 结果：1 3 5 7

// 4.已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序,比如:[10，12，45，90]，添加23后,数组为[10，12，23，45，90]
int[] arr = {10, 12, 45, 90};
int[] arrNew = new int[arr.length + 1];
int num = 23;
int index = -1;
for(int i = 0; i < arr.length; i++){
    if(num < arr[i]){
        index = i;
        break;
    }
}

for(int i = 0, j = 0; i < arrNew.length; i++){
    if(i != index){
        arrNew[i] = arr[j];
        j++;
    }else{
        arrNew[i] = num; 
    }
    
    System.out.print(arrNew[i] + "\t");

}

// 解析：定位，扩容
// [10，12，45，90]        j的变化：0 1 2 3   (arrNew)
// [10，12，23，45，90]    i的变化：0 1 2 3 4  (arr)

// 5.随机生成10个整数(1-100的范围)保存到数组，并升序打印以及求平均值、求最大值和最大值的下标、并查找里面是否有8 Homework05.java
// 随机生成1-100内正整数
int[] arr = new int[10];
System.out.println("===原始数组：");
for(int i = 0; i < arr.length; i++){
    arr[i] = (int)(Math.random() * 100); 
    System.out.print(arr[i] + "\t");
}

double sum = 0;
double avg = 0;
int max = 0;
int maxIndex = 0;
int temp  = 0;
int findNum = 8;
int index = -1;
// 冒泡排序
for(int j = 0; j < arr.length; j++){
    for(int i = 0; i < arr.length - 1; i++){
        if(arr[i] > arr[i + 1]){
            temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
            
        }
    }
    sum += arr[j];

    // 顺序查找
    if(arr[j] == findNum){
        index = j;
        System.out.println("===数组中有8,下标为：" + j);
        break;
    }
}

avg = sum / arr.length;
max = arr[arr.length - 1];
maxIndex = arr.length;

System.out.println("\n===排序数组：");
for(int i = 0; i < arr.length; i++){
    System.out.print(arr[i] + "\t");
}

System.out.println("\n sum:" + sum + " ===avg:" + avg + " ===max:" + max + " ===maxIndex:" + maxIndex );
if(index == -1){
    System.out.println("===该数组中没有找到8");
}

// 解析：冒泡排序 + 查找
// 结果：
// ===原始数组：
// 22      0       30      74      66      80      21      16      87      77
// ===排序数组：
// 0       16      21      22      30      66      74      77      80      87
// sum:482.0 ===avg:48.2 ===max:87 ===maxIndex:10
// ===该数组中没有找到8


// 6.试写出以下代码的打印结果 Homework06.java
char[] arr1 = {'a','z','b','c'};
char[] arr2 = arr1;
arr1[2] = '韩';
for(int i = 0;i < arr2.length; i++){
    System.out.println(arr1[i] +"," + arr2[i]);
}

// 结果：
// a,a
// z,z
// 韩,韩
// c,c
// 解析：考察数组的引用传递

// 7.写出冒泡排序的代码 Homework07.java
int[] arr = {11, 55, 2, 34};
int temp = 0;
for(int j = 0; j < arr.length - 1; j++){// 外层循环（轮）： 3轮
    for(int i = 0; i < arr.length - 1 - j; i++){// 每轮的比较次数（次）： 3次-2次-1次
        if(arr[i] > arr[i + 1]){
            temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
    }
}

// 打印
for(int i = 0; i < arr.length; i++){
    System.out.print(arr[i] + "\t");
}

// 结果：2       11      34      55

※本章总结

【[章节总结P189]https://www.bilibili.com/video/BV1fh411y7R8?p=190&spm_id_from=pageDriver&vd_source=d72708da7af98fb37e7ffbdac67ee2ee)】

6、面向对象

在这里插入图片描述

6.1 类与对象（OOP）

1、背景

在这里插入图片描述

2、概述

在这里插入图片描述

3、使用（创建对象）

1）定义类
在这里插入图片描述

2）实例化
在这里插入图片描述

3）访问对象属性
在这里插入图片描述

在这里插入图片描述

4、类与对象的内存分配机制

在这里插入图片描述

6.2 成员方法

1、使用

在这里插入图片描述

※ 课堂练习

 方法（成员方法）
class Person{
    String name;
    int age;

    **// 老韩解读：
    // 1、public 公开方法
    // 2、void 方法没有返回值
    // 3、speak()  speak方法名，()形参列表
    // 4、{} 方法体
    // 5、System.out.println 输出内容**

    // 1）添加speak成员方法，输出我是一个好人
    public void speak(){
        System.out.println("努力奋斗吧！");
    }

    // 2）添加cal01成员方法，可以计算从1+...+1000的结果
    public void cal01(){
        int res = 0;
        for(int i = 1; i <= 1000; i++){
            res += i;
        }
        System.out.println("计算结果=" + res);
    }

    // 3）添加cal02成员方法，该方法可以接收一个数n，计算从1+...+n的结果
    public void cal02(int n){// int 控制传入参数类型，n 为形参列表
        int res = 0;
        for(int i = 1; i <= n; i++){
            res += i;
        }
        System.out.println("计算结果=" + res);
    }

    // 4）添加getSum成员方法，可以计算两个数的和
    // 老韩解读：
    // 1、int 表示方法执行后，返回一个 int 值
    // 2、(int num1, int num2) 形参列表，2个形参，可以接收两个传入的数字
    // 3、return 表示把两个参数的和的值返回
    public int getSum(int num1, int num2){
        return num1 + num2;
    }
}

 调用方法，先写好main方法
public class Method{
    public static void main(String[] args){
        // 方法使用：
        // 1、不调用不会输出
        // 2、先创建对象，然后调用方法
        Person P = new Person();

        P.speak();// 调用speak方法
        P.cal01();// 调用cal01方法
        P.cal02(5);// 调用cal02方法，同时传参数n = 5
        int returnRes = P.getSum(19, 20);// 调用getSum方法，同时传参数num1  = 19， num2 = 20
        System.out.println("getSum方法返回的值=" + returnRes);
    }

}

2、成员方法好处

在这里插入图片描述

※ 课堂练习

class MyTools{    
    public void printArr(int[][] map){
        // 对传入的map数组进行遍历
        for(int i = 0; i < map.length; i++){
            for(int j = 0; j < map[i].length; j++){
                System.out.print(map[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

public class Method{
    public static void main(String[] args){
        int[][] map = {{0,0,1},{1,1,1},{1,1,3}};

        // MyTools类名，tool方法名
        MyTools tool = new MyTools();
        tool.printArr(map);

    }
}

结果：
在这里插入图片描述

3、注意事项和使用细节

1）第一部分

在这里插入图片描述

2）第二部分

在这里插入图片描述

3）第三部分

在这里插入图片描述

同一个类中方法调用–直接调用：
在这里插入图片描述

跨类方法调用–通过调用对象名，eg:对象名.方法名（）
在这里插入图片描述

※ 课堂练习

在这里插入图片描述

/*
    1、编写AA类，有一个方法，判断一个数字是奇数odd还是偶数，返回boolean
    思路：
    1）方法的返回类型 boolean
    2）方法的名字 isOdd
    3）方法的形参 (int num)
    4）方法体 判断
*/ 
// 成员方法
class AA{
    public boolean isOdd(int num){
        // 方法一：
        // if(num % 2 == 0)
        // {
        //     return true;
        // }else{
        //     return false;
        // }

        // 方法二（简化为三元）：
        // return num % 2 == 0 ?  true: false;

        // 方法三（进阶）：
        return num % 2 == 0;

    }
}
// 调用方法
public class Method{
    public static void main(String[] args){

        AA a = new AA();
        // boolean b = a.isOdd(7);
        // System.out.println(b);

        if(a.isOdd(7)){
            System.out.println("是偶数");
        }else{
            System.out.println("是奇数");
        }
    }
}

/*
	2、根据行、列、字符打印对应行数和列数的字符，比如：行：4，列：4，字符：#，组打印相应的效果
    ####
    ####
    ####
    ####
    思路：
    1）方法的返回类型 没有return用void
    2）方法的名字 printChar
    3）方法的形参 (int row, int col, char c)
    4）方法体 循环
*/ 
// 成员方法
class AA{
    public void printChar(int row, int col, char c){
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                System.out.print(c);
            }
            System.out.println();
        }
    }
}

// 调用方法
public class Method{
    public static void main(String[] args){

        AA a = new AA();
        a.printChar(3, 4, '#');
    }
}