javabasic

JAVABasic

一、计算机基础

1. 计算机组成

2. 进制的概念

2.1二进制的存储

计算机不管是内存还是硬盘，都是以二进制的形式存储。如同一张巨大的表格，里面都是由0和1组成。

• 二进制：逢2进1 基数为2，数值部分用不同的数字，0、1来表示。 （逢2进1便是没有2的概念，遇到2就像前面进一位）比如2，看到2向前进1，2用二进制表示便是10，3是11依此类推
• 十进制：逢十进一基数为10，数值部分用0、1、2、3、4、5、6、7、8、9来表示.
• 十六进制：逢十六进一基数是16，有十六种数字符号，除了在十进制中的0至9外，还另外用6个英文字母A、B、C、D、E、F来表示十进制数的10至15。

2.2二进制的存储（单位）

数据在计算机底层是如何存储的？

• 都是采用二进制：使用0、1按照逢2进1的规则表示数据来存储。

如何快速算出一个数据的二进制形式？

• 除2取余法 6便表示为110

数据在计算机底层存储的最小单位是什么？

• 字节，一个字节等于8个二进制位：1B =8b

二进制转十进制：

2.3关于ASCll编码表

3.java环境搭建

3.1安装java

将给定的安装包安装在电脑上，我们一起去官方网站看看（https://www.oracle.com/）

我们能看到目前java的版本已经更新到了java17，但是企业中常用的还是java8，原因是因为老的版本，更加稳定，不容易出现错误。我们可以根据实际需求自行选择安装版本。

系统会默认将jdk安装至"C:\Program Files\Java"目录下，(这里最好自己指定目录，目录中不要出现空格以及中文，避免后续产生不必要的麻烦)

接着我们需要配置环境变量，让其能够在任意窗口打开
path环境变量

• 用于记住程序路径，方便在命令行任意路径启动程序

我在最初学习时，也一直没弄懂环境变量是干嘛的，我们以QQ为例，再引入java的环境变量。帮助大家去直观的理解环境变量。

win+r 输入cmd 打开命令行窗口

我们此时输入qq是没有效果的

首先找到QQ程序的执行路径，通常在bin包，发现有qq程序

将这个路径复制
打开环境变量设置

用户变量只针对当前用户
系统变量针对所有用户

点击path

将qq环境变量加进去 点击确定

此时再次在命令行执行qq，你会发现

还是失败！！！

为什么呢？

• 因为我们的环境变量更改之后，原来打开的命令行还没有生效，重新打开命令行工具即可。
  此时输入qq，启动成功

接着我们引入正题，配置java环境变量
在最新版本，安装过程中会自动帮助我们配置好环境变量。
但是通常情况下，是需要我们手动添加环境变量

同样的 找到jdk的bin目录，复制路径，添加到环境变量中

图A

配置JAVA_HOME环境变量

复制这个路径

新建环境变量

将最开始图A的那个变量替换，通过%JAVA_HOME% 来固定位置

完成

java
java -version   --查看jdk版本 
1
2

有内容即可。

4.javac 和java的区别

我们编写的java程序都是高级语言，计算机底层是不能够直接识别的，需要通过javac工具的编译才能驱动机器干活。

5.命令行常用命令

6.编写第一个java程序

开发一个java程序，其中要经历三个步骤 编写代码，编译代码，运行代码

下面看一个简单的 Java 程序，它将输出字符串 Hello World

最初学习时，我们可以使用记事本编写代码。这样的好处是，能够更加熟悉Java的一个运行过程，以及对代码的熟练度。

新建一个文件，用记事本的方式打开

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello world!");  //这句话输出 Helllo world!
    }
}
1
2
3
4
5

需要注意的是文件名要和类名完全一致，否则会报错。

编写好之后通过在文件所在目录执行 javac HelloWorld.java 进行编译,然后运行

7.java工作原理jdk

7.1.jdk的组成

7.2.java的跨平台，工作原理

• 一次编译，处处可用（核心是因为java公司为不同的平台提供了jvm虚拟机）

## 变量

数据类型

1.自动类型转换机制：

• 类型范围小的变量，可以直接复制给类型范围大的变量

2.我们为什么要进行类型转换？

• 因为在实际编写程序中，会存在不同类型的变量赋值其他类型的变量。

3.什么是自动类型转换？

• 类型范围小的变量，可以直接赋值给类型范围大的变量。

byte 的运算结果会转换为int，需要用int接收

数组

1.数组的基本概念

有一个需求，某某学校招生了，有一百个学生报名，我想记录一下这一百个学生的年龄和姓名，或者计算一下学生的平均年龄，难道我们要定义一百个变量吗？

string a = "杨航"
...
算了不写了。
1
2
3

合理的做法一定是，在内存里找一个片空间，按顺序存起来。其实这个道理很简单，计算机中，我们有这样一种数据结构能帮助我们把想同类型的数据统一聚拢放在一起，他就是【数组】。

2.数组的定义方式

定义：
int[] nums;
初始化：
nums = new int[3];
赋值：
nums[0] = 1;   
nums[1] = 4;
nums[2] = 3;

// 直接定义初始化并赋值
int[] nums = {1,2,3};

// 这样写也行
int nums[] = new int[5];
int nums[] = new int[]{1,2,4,5};

// 数组有一个属性，可以获得数组的长度
nums.length 

类型[] 名字 = new 类型[长度];
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.数组在计算机中的基本原理

数组在计算机中存储，主要是通过三个步骤

注意：数组变量名中存储的的是数组在内存当中的地址，数组是一种引用数据类型。
总结：

4.数组中的访问

语法：数组名[索引]

System.out.println(ages[0]);

计算数组长度（存放了多少数据）
数组名.length

System.out.println(ages.length);

数组的最大索引：

数组名.length - 1

注意：如果访问数组时，使用的索引超过数组的最大索引，会越界，显示异常

5.数组的遍历

什么是便历：？
所谓便历，就是说一个一个去访问属猪容器中的数据

for (int i = 0; i < ages.length; i++) { }

IDEA中的快捷便历

数组名.fori + 回车 直接生成

一个简单的小案例～

代码实现：

public class LiteralDemo {
    public static void main(String[] args) {
        //定义一个五个员工的销售额度数组
        int[] money = {16,26,366,100};
        //定义一个变量，用作最后计算总额
        int total = 0;
        //分别遍历累加
        for (int i = 0; i < money.length; i++) {
            total += money[i];
        }
        //输出
        System.out.println(total);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

6.动态初试化数组

先初试化int[] rar = new int[3]
后赋值
rar[0]=1

两种数组定义初始化方式各自适合什么模式？

• 动态初试化：适合开始不确定具体元素值，只知道元素个数的具体场景。
• 静态初试化：明确具体元素值

案例1:

代码实现：

import java.util.Scanner;
public class LiteralDemo {
    public static void main(String[] args) {
        double[] scores = new double[6];
        Scanner sc =   new Scanner(System.in)；
      

        //遍历数组 输入6个评委的打分
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请您输入当前第"+(i+1)+"个评委的分数");
            scores[i] = sc.nextDouble();
        }

        double sum = 0;
        //  遍历数组中每个元素值进行求和
        for (int i = 0; i < scores.length; i++) {
            sum +=scores[i];
        }

        System.out.println("选手最终得分" + (sum / scores.length));
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

7.数组/java程序在计算机中的执行原理

java内存分配介绍

数组在计算机的执行原理

小思考：

8.多个变量指向同一个数组

注意：如果某个数组变量存储的地址是null,那么变量将不再指向任何数组对象。

多个数组变量，指向同一个数组对象的原因，注意事项

• 多个数组中存储的是同一个数组对象中的数据
• 多个变量中修改的都是同一个数组对象中的数据。

9.数组常见案例

数组求最值

代码实现：

public class LiteralDemo {
    public static void main(String[] args) {
        int[] faceScores = {15,9000,29993,3242,4242,5242,4345,543,534,543,543};
        //定义一个最大值
        int max = faceScores[0];

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

        System.out.println("当前妹纸中，颜值得分最高的是" + max +"分");

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

数组反转

public class LiteralDemo {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5}; 
        //临时变量
        int temp;
        for (int i = 0,j = a.length-1; i < j; i++,j--) {
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

随机排名

代码实现：

import java.util.Random;
import java.util.Scanner;
public class LiteralDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //初始化数组
        int[] codes = new int[5];

        //遍历录入
        for (int i = 0; i < codes.length; i++) {
            System.out.println("请您输入第" + (i+1) + "个工号");
            int code = sc.nextInt();
            codes[i] = code;
        }
        Random r = new Random();
        //打乱顺序
        for (int i = 0; i < codes.length; i++) {
            //随机索引
            int index = r.nextInt(codes.length);//0 1 2 3 4
            //定义临时变量
            int temp = codes[index];
            codes[index] = codes[i];
            codes[i] = temp;
        }
        for (int i = 0; i < codes.length; i++) {
            System.out.print(i+" ");
        }

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

debug工具的使用-断点调试

方法

1.方法的概念

**方法是一种语法结构，它可以把一段代码封装成一个功能，以便重复调用。**这句话什么意思呢？意思是，把一段功能代码围在一起，别人都可以来调用它。

方法定义方式

    public static int sum(int a,int b){
        int c = a+b;
        return c;
    }
1
2
3
4

我们看一个需求，比如现在张工、李工两个人都需要求两个整数的和。不使用方法，代码如下。

// 1、李工。
int a = 10;
int b = 20;
int c = a+b;
System.out.println("和是：" + c);


// 2、张工。
int a1 = 10;
int b1 = 20;
int c1 = a1+b1;
System.out.println("和是：" + c1);
1
2
3
4
5
6
7
8
9
10
11
12

阅读上面的代码，我们不难发现。两次求和的代码中，除了求和的数据不一样，代码的组织结构完全一样。

像这种做相同事情的代码，就可以用方法进行封装。需要用到这段代码功能时，让别人调用方法就行。代码如下

//目标：掌握定义方法的完整格式，搞清楚使用方法的好处。
public class MethodDemo1 {
    public static void main(String[] args) {
        // 需求：假如现在很多程序员都要进行2个整数求和的操作。
        // 1、李工。
        int rs = sum(10, 20);
        System.out.println("和是：" + rs);

        // 2、张工。
        int rs2 = sum(30, 20);
        System.out.println("和是：" + rs2);
    }

    public static int sum(int a,int b) {
        int c = a + b;
        return c;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

定义方法的要点

1. 方法的修饰符：暂时都使用public static 修饰。（目前看做是固定写法，后面是可以改动的）

2. 方法申明了具体的返回值类型，内部必须使用return返回对应类型的数据。

3. 形参列表可以有多个，甚至可以没有； 如果有多个形参，多个形参必须用“，”隔开，且不能给初始化值。

使用方法的好处

• 提高代码复用性，提升开发效率

• 让程序逻辑更清晰

如下图所示：写好一个方法之后，每一个人都可以直接调用，而不用再重复写相同的代码。所以是提高了代码的复用性，不用写重复代码，自然也提高了开发效率。

2.使用场景

那么让程序的逻辑更加清晰，是如何体现的呢？ 比如，我们后期会用所学习的技术，做一个ATM系统，ATM系统中有查看账户、存钱、取钱、修改密码等功能，到时候我们可以把每一个功能都写成一个方法。如下图所示，这样程序的逻辑就更加清晰了。

总结一下

1.什么是方法？
	答：方法是一种语法结构，它可以把一段代码封装成一个功能，以便重复调用
2.方法的完整格式是什么样的？
	//格式如下：
	修饰符  返回值类型  方法名( 形参列表 ){
    	方法体代码(需要执行的功能代码)
       	return 返回值;
    }
3.方法要执行必须怎么办？
	必须调用才执行; 
	//调用格式:
	方法名(...);

4.使用方法有什么好处？
	答：提高代码的复用性，提高开发效率，使程序逻辑更清晰。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.方法其它形式

实际上设计一个合理的方法，需要重点关注下面两点

• 该方法是否需要接收收据处理
• 方法是否需要返回数据

设计一个合理的方法的原则如下：

• 如果方法不需要返回数据，返回值类型必须申明成void（无返回值申明）, 此时方法内部不可以使用return返回数据。
• 方法如果不需要接收外部传递进来的数据，则不需要定义形参，且调用方法时也不可以传数据给方法。
• 没有参数，且没有返回值类型（void）的方法，称为值无参数、无返回值方法。此时调用方法时不能传递数据给方法。

需求1：写一个方法，打印3个"Hello World"

分析：需求已经非常明确，打印的是3个HelloWorld，在方法中直接循环3次就可以完成需求。不需要外部给方法传递数据，所以不需要参数。

需求2：写一个方法，打印若干个"Hello World"，具体多少个，由调用者指定

4.方法使用中的常见问题

- 1. 方法在内种没有先后顺序，但是不能把一个方法定义在另一个方法中。

- 2. 方法的返回值类型写void（无返回申明）时，方法内不能使用return返回数据，
	如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据。

- 3. return语句的下面，不能编写代码，属于无效的代码，执行不到这儿。

- 4. 方法不调用就不会执行,  调用方法时，传给方法的数据，必须严格匹配方法的参数情况。

- 5. 调用有返回值的方法，有3种方式：
     ① 可以定义变量接收结果 
     ② 或者直接输出调用，
     ③ 甚至直接调用；

- 6. 调用无返回值的方法，只有1种方式： 只能直接调用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5.方法的使用案例

我们知道Java程序的运行，都是在内存中执行的，而内存区域又分为栈、堆和方法区。那Java的方法是在哪个内存区域中执行呢？

答案是栈内存。 每次调用方法，方法都会进栈执行；执行完后，又会弹栈出去。

方法进栈和弹栈的过程，就类似于手枪子弹夹，上子弹和击发子弹的过程。最后上的一颗子弹是，第一个打出来的；第一颗上的子弹，是最后一个打出来的。

总结

1.方法的运行区域在哪里？
	答：栈内存。
	
2.栈有什么特点？方法为什么要在栈中运行自己？
	答：先进后出。保证一个方法调用完另一个方法后，可以回来继续执行。
1
2
3
4
5

4.java参数的传递机制 （非常重要）

java的传递机制都是：值传递

所谓值传递：指的是在传递实参给方法的形参的时候，传递的是实参变量中存储的值的副本。 同学们肯定想知道，形参是什么？实参又是什么呢？ 请看下面这个张图

• 实参：在方法内部定义的量
• 形参：定义方法时，（）中所声明的参数

4.1参数传递的基本类型数据

总结：

• 值传递，传输的是实参存储的值副本

4.2参数传递的引用数据类型

我们发现调用change方法时参数是引用类型，实际上也是值传递，只不过参数传递存储的地址值。此时change方法和main方法中两个方法中各自有一个变量arrs，这两个变量记录的是同一个地址值[I@4c873330，change方法把数组中的元素改了，main方法在访问时，元素已经被修改了。

总结一下：

1.基本类型和引用类型的参数在传递的时候有什么不同？
- 都是值传递
- 基本类型的参数传递存储的数据值。
- 引用类型的参数传递存储的地址值。

5.方参数传递案例

案例1：

代码：

案例2

代码：

思维：层层拦截，不通过就返回false

6.方法重载

什么是方法重载？

• 方法重载：所谓方法重载指的是：一个类中，出现多个相同的方法名，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。

方法重载的的注意事项：

• 一个类中，只要一些方法的名称相同，形参列表不同，那么他们就是方法的重载了，其它不用管。
• 形参的列表不同指个数、类型、顺序不同，不关心形参

方法重载的应用场景：

一般在开发中，我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。

比如，我们现在看一个案例

们现在看一个案例

需求：开发武器系统，功能需求如下：
    可以默认发一枚武器。
    可以指定地区发射一枚武器。
    可以指定地区发射多枚武器。

1
2
3
4
5

上面的几个需求中，不管以什么样的方式发武器，其实最终的目的都是发武器。

所以我们可以设计几个名称相同的方法，这样调用者调用起来就不用记那么多名字了

public class MethodTest2 {
    public static void main(String[] args) {
        // 目标：掌握方法重载的应用场景。
        fire();
        fire("岛国2");
        fire("米国", 999);
    }

    public static void fire(){
        fire("岛国");
    }

    public static void fire(String country){
        fire(country, 1);
    }

    public static void fire(String country, int number){
        System.out.println("发射了" + number + "枚武器给" + country);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

总结一下：

1.什么是方法重载？
	答：一个类中，多个方法的名称相同，但它们形参列表不同。
2.方法重载需要注意什么？
	- 一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，
	  其它的都不管（如：修饰符，返回值类型是否一样都无所谓）。
	
	- 形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称。
	
3、方法重载有啥应用场景？
	答：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很	专业的。
1
2
3
4
5
6
7
8
9
10

7.return的单独使用

关于方法的定义，我们还剩下最后一种特殊用法，就是在方法中单独使用return语句，可以用来提前结束方法的执行。

如，下面的chu方法中，当除数为0时，就提前结束方法的执行。

public class Test {
    public static void main(String[] args) {
        System.out.println("开始");
        chu(10 , 0);
        System.out.println("结束");
    }
    
    public static void chu(int a , int b){
        if(b == 0){
            System.err.println(“您的数据有误！！不执行！！”);
            return; // 直接跳出并结束当前chu方法的执行
        }
        int c = a / b;
        System.out.println("除法结果是："+c); 
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

第一阶段JAVA编程案例

案例一：买飞机票

我们来分析一下，这个需求该如何实现。将来我们去做一些需求，都是一个一个方法来实现的，所以在这里我们也采用方法来编写。

呢？采用下面的方式来思考

1.首先，考虑方法是否需要接收数据处理？
	阅读需求我们会发现，不同月份、不同原价、不同舱位类型优惠方案都不一样；
	所以，可以将原价、月份、舱位类型写成参数
	
2.接着，考虑方法是否有返回值？
	阅读需求我们发现，最终结果是求当前用户的优惠票价
	所以，可以将优惠票价作为方法的返回值。
	
3.最后，再考虑方法内部的业务逻辑
	先使用if判断月份是旺季还是淡季，然后使用switch分支判断是头等舱还是经济舱，计算		票价
1
2
3
4
5
6
7
8
9
10

代码如下

public class Test1 {
    public static void main(String[] args) {
        // 目标：完成买飞机票的案例。
        double price = calculate(1000, 11, "头等舱");
        System.out.println("优惠价是：" + price);
    }

    public static double calculate(double price,int month,String type){
        // 1、判断当前月份是淡季还是旺季
        if(month >= 5 && month <= 10) {
            // 旺季
            // 2、判断仓位类型。
            switch (type){
                case "头等舱":
                    price *= 0.9; // price = price * 0.9;
                    break;
                case "经济舱":
                    price *= 0.85;
                    break;
            }
        }else {
            // 淡季
            switch (type){
                case "头等舱":
                    price *= 0.7; // price = price * 0.7;
                    break;
                case "经济舱":
                    price *= 0.65;
                    break;
            }
        }
        return price;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

案例二：开发验证码

分析:

1.需要传递参数 指定多少位
2.需要一个返回值

3.最后，再考虑方法内部的业务逻辑
	1)先按照方法接收的验证码位数n,循环n次
	2)每次循环，产生一个字符，可以是数字字符、或者大小写字母字符
	3)定义一个String类型的变量用于记住产生的每位随机字符
1
2
3
4
5
6
7

public class Test2 {
    public static void main(String[] args) {
        // 目标：完成生成随机验证码。
        System.out.println(createCode(8));
    }

    public static String createCode(int n){
        //1)先按照方法接收的验证码位数n,循环n次
        Random r = new Random();
        //3)定义一个String类型的变量用于记住产生的每位随机字符
        String code = "";
        for (int i = 1; i <= n; i++) {
            // i = 1 2 3 4 5
            //2)每次循环，产生一个字符，可以是数字字符、或者大小写字母字符
            // 思路：随机一个0 1 2之间的数字出来，0代表随机一个数字字符，1、2代表随机大写字母，小写字母。
           r
            switch (type) {
                case 0:
                    // 随机一个数字字符
                    code += r.nextInt(10); // 0 - 9  code = code + 8
                    break;
                case 1:
                    // 随机一个大写字符 A 65   Z 65+25    (0 - 25) + 65
                    char ch1 = (char) (r.nextInt(26) + 65);
                    code += ch1;
                    break;
                case 2:
                    // 随机一个小写字符 a 97   z 97+25    (0 - 25) + 97
                    char ch2 = (char) (r.nextInt(26) + 97);
                    code += ch2;
                    break;
            }
        }
        return code;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

案例三：评委打分

1.首先，考虑方法是否需要接收数据来处理？
	需求中说，有多个评委的打分，但是到底多少个评委呢？ 可以由调用者传递
	所以，我们可以把评委的个数写成参数；

2.接着，考虑方法是否需要有返回值？
	需求中，想要的最终结果是平均分
	所以，返回值就是平均分；

3.最后，再考虑方法内部的业务逻辑
	1)假设评委的个位为n个，那么就需要n个评委的分数，首先可以新建一个长度为n的数组，		用来存储每一个评委的分数
	
	2)循环n次，使用Scanner键盘录入n个1~100范围内的整数，并把整数存储到数组中
	
	3)求数组中元素的总和、最大值、最小值
	
	4)最后再计算平均值； 平均值 = (和-最大值-最小值)/(数组.length-2);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

代码如下：

public class Test3 {
    public static void main(String[] args) {
        // 目标：完成评委打分案例。
        System.out.println("当前选手得分是：" + getAverageScore(6));
    }

    public static double getAverageScore(int n){
        // 1、定义一个动态初始化的数组，负责后期存入评委的打分
        int[] scores = new int[n]; // 6
        // scores = [0, 0, 0, 0, 0, 0]

        // 2、遍历数组的每个位置，依次录入评委的分数
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < scores.length; i++) {
            // i = 0 1 2 3 4 5
            System.out.println("请您录入第"+ (i + 1) +"个评委的分数：");
            int score = sc.nextInt();
            scores[i] = score;
        }

        // 3、从数组中计算出总分，找出最高分，最低分。
        int sum = 0; // 求总分用的变量
        int max = scores[0]; // 求最大值的
        int min = scores[0]; // 求最小值的。

        // 遍历数组找出这些数据的。
        for (int i = 0; i < scores.length; i++) {
            // i = 0 1 2 3 4 5
            int score = scores[i];
            // 求和
            sum += score;
            // 求最大值
            if(score > max){
                max = score;
            }
            // 求最小值
            if(score < min){
                min = score;
            }
        }
        // 4、计算出平均分并返回
        return 1.0 * (sum - min - max) / (number - 2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

案例四：数字加密

代码实现：

public class Test4 {
    public static void main(String[] args) {
        // 目标：完成数字加密程序的开发。
        System.out.println("加密后的结果是：" + encrypt(8346));
    }

    public static String encrypt(int number){
        // number = 198
        // 1、把这个密码拆分成一个一个的数字，才可以对其进行加密啊。
        int[] numbers = split(number);
        // numbers = [1, 9, 8, 3]

        // 2、遍历这个数组中的每个数字，对其进行加密处理。
        for (int i = 0; i < numbers.length; i++) {
            // i = 0 1 2 3
            numbers[i] = (numbers[i] + 5) % 10;
        }
        // numbers = [6, 4, 3, 8]

        // 3、对数组反转，把对数组进行反转的操作交给一个独立的方法来完成
        reverse(numbers);
        // numbers = [8, 3, 4, 6]

        // 4、把这些加密的数字拼接起来做为加密后的结果返回即可。
        String data = "";
        for (int i = 0; i < numbers.length; i++) {
            data += numbers[i];
        }
        return data;
    }

    public static void reverse(int[] numbers) {
        // 反转数组的
        // numbers = [6, 4, 3, 8]
        //            i        j
        for (int i = 0, j = numbers.length - 1; i < j; i++,j--) {
            // 交换i和j位置处的值。
            // 1、把后一个位置处的值交给一个临时变量先存起来
            int temp = numbers[j];
            // 2、把前一个位置处的值赋值给后一个位置处
            numbers[j] = numbers[i];
            // 3、把后一个位置处原来的值（由临时变量记住着）赋值给前一个位置
            numbers[i] = temp;
        }
    }

    public static int[] split(int number) {
        // number = 1983
        int[] numbers = new int[4];
        numbers[0] = number / 1000;
        numbers[1] = (number / 100) % 10;
        numbers[2] = (number / 10) % 10;
        numbers[3] = number % 10;
        return numbers;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

面向对象基础

1.面向对象入门

学习完前面的课程后，说明Java的基础语法就全掌握了。

接下来，我们要学习的是Java中最核心的课程——面向对象编程。

那这种编程套路是咋回事呢？ 接下来，我们通过一个案例快速的认识一下。

现在假设我们需要处理的是学生的姓名、语文成绩、数学成绩这三个数据，要求打印输出这个学生的总成绩，和平均成绩。

所谓编写对象编程，就是把要处理的数据交给对象，让对象来处理。

2.深刻理解面向对象

2.1面向对象有什么好处

Java的祖师爷，詹姆斯高斯林认为，在这个世界中 **万物皆对象！**任何一个对象都可以包含一些数据，数据属于哪个对象，就由哪个对象来处理。

有了对象，我们就可以把数据交给对象来进行处理。

所以面向对象编程的好处，用一句话总结就是：面向对象的开发更符合人类的思维习惯，让编程变得更加简单、更加直观。

2.2面向对象是什么

对象实际上是一种特殊的数据结构

你可以把对象，理解成一张表格，表格中所记录的数据，就是对象拥有的数据。

2.3 对象是如何出来的

刚刚我们讲到对象就是一张数据表，那么这个数据表是怎么来的呢？这张表是不会无缘无故存在的，因为Java也不知道你这个对象要处理哪些数据，所以这张表需要我们设计出来。

而设计这张的表的角色，就是类。类可以理解成对象的设计图

一句话总结：对象可以理解成一张数据表，而数据表中可以有哪些数据，是有类来设计的。

3.对象的执行原理

按照我们之前讲的数组的执行原理，数组变量记录的其实数数组在堆内存中的地址。其实面向对象的代码执行原理和数组的执行原理是非常类似的。

其实Student s1 = new Student();这句话中的原理如下

• Student s1表示的是在栈内存中，创建了一个Student类型的变量，变量名为s1

• 而new Student()会在堆内存中创建一个对象，而对象中包含学生的属性名和属性值

  同时系统会为这个Student对象分配一个地址值0x4f3f5b24

• 接着把对象的地址赋值给栈内存中的变量s1，通过s1记录的地址就可以找到这个对象

• 当执行s1.name=“播妞”时，其实就是通过s1找到对象的地址，再通过对象找到对象的name属性，再给对象的name属性赋值为播妞;

搞明白Student s1 = new Student();的原理之后，Student s2 = new Student();原理完全一样，只是在堆内存中重新创建了一个对象，又有一个新的地址。s2.name是访问另对象的属性。

4.类和对象的一些注意事项

第一条：一个代码文件中，可以写多个class类，但是只能有一个是public修饰，且public修饰的类必须和文件名相同。

假设文件名为Demo1.java，这个文件中假设有两个类Demo1类和Student类，代码如下

//public修饰的类Demo1，和文件名Demo1相同
public class Demo1{
    
}

class Student{
    
}
1
2
3
4
5
6
7
8

**第二条：**对象与对象之间的数据不会相互影响，但是多个变量指向同一个对象会相互影响。

如下图所示，s1和s2两个变量分别记录的是两个对象的地址值，各自修改各自属性值，是互不影响的。

如下图所示，s1和s2两个变量记录的是同一个对象的地址值，s1修改对象的属性值，再用s2访问这个属性，会发现已经被修改了。

5.this关键词的含义

this是什么呢？this实际上就是一个变量，可以用在方法中，拿到当前类的对象。

我们看下图所示代码，通过代码来体会这句话到底是什么意思。哪一个对象调用方法方法中的this就是哪一个对象

运行结果：

this有什么用呢？

通过this在方法中可以访问本类对象的成员变量。我们看下图代码，分析打印结果是多少

关于this关键字我们就学习到这里，重点记住这句话：哪一个对象调用方法方法中的this就是哪一个对象

JDBC

1.JDBC简介

• JDBC 就是使用Java语言操作关系型数据库的一套API

JDBC 本质：
官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口，各个数据库厂商去实现这套接口，提供数据库驱动jar包
我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。

JDBC 好处：
各数据库厂商使用相同的接口，Java代码不需要针对不同数据库分别开发
可随时替换底层数据库，访问数据库的Java代码基本不变

2.JDBC快速入门

步骤：

/*
JDBC快速入门
 */
public class JDBCDemo {
    public static void main(String[] args) throws Exception {
        //1. 注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2. 获取连接
        String url = "jdbc:mysql:///db1";
        String username = "root";
        String password = "***";
        Connection conn = DriverManager.getConnection(url, username, password);

        //3.定义syl语句
        String sql = "update stu set name=\"小八\" where id =2";
        //4. 执行sql的对象
        Statement statement = conn.createStatement();
        //5.执行sql
        int count = statement.executeUpdate(sql);

        //6.处理结果
        System.out.println(count);
        
        // 7.释放资源
        statement.close();
        conn.close();


    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

3.JDBC API详解

DriverManager
注册驱动

Class.forName("com.mysql.jdbc.Driver");
1

Diver类原码

获取连接

Connection conn = DriverManager.getConnection(url, username, password);
1

参数

语法：jdbc:mysql://ip地址(域名):端口号/数据库名称?参数键值对1&参数键值对2…
1

示例：jdbc:mysql://127.0.0.1:3306/db1
1

细节：
如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称?参数键值对
配置 useSSL=false 参数，禁用安全连接方式，解决警告提示

Connection
1.

 //执行sql的对象
        Statement statement = conn.createStatement();
        //5.执行sql
        int count = statement.executeUpdate(sql);
1
2
3
4

2.事务管理

• mysql事务管理
  开启事务：BEGIN; / START TRANSACTION;
  提交事务：COMMIT;
  回滚事务：ROLLBACK;
  MySQL默认自动提交事务
• JDBC 事务管理：Connection接口中定义了3个对应的方法
  开启事务：setAutoCommit(boolean autoCommit)：true为自动提交事务；false为手动提交事务，即为开启事务
  提交事务：commit()
  回滚事务：rollback()

代码演示

public class JDBCDemo {
    public static void main(String[] args) throws Exception {
        //1. 注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2. 获取连接
        String url = "jdbc:mysql:///db1";
        String username = "root";
        String password = "***";
        Connection conn = DriverManager.getConnection(url, username, password);

        //3.定义syl语句
        String sql = "update stu set name=\"小八\" where id =2";
        //4. 执行sql的对象
        Statement statement = conn.createStatement();
        //5.执行sql
        int count = statement.executeUpdate(sql);
        //6.处理结果
        System.out.println(count);
        // 7.释放资源
        statement.close();
        conn.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Statement
作用:执行sql语句

int    executeUpdate(sql)：执行DML、DDL语句
返回值：(1) DML语句影响的行数 (2) DDL语句执行后，执行成功也可能返回 0
1
2

ResultSet    executeQuery(sql)：执行DQL 语句
返回值： ResultSet 结果集对象
1
2

ResultSet

数据驱动