土木转it行业(2)

今天是3月21日 培训班的第二节课

总共分为

第一章 Java基础语法

第二章 运算符

第一章 Java基础语法

1.1 关键字

关键字就是被Java赋予了特定含义的英文单词。

当我们在代码中，写了对应的单词之后，那么程序在执行时，就知道要做什么事情了。

1.1.1 关键字的特点

• 全部都是小写

• 在常用的代码编辑器中，关键字都有高亮的颜色显示。

1.1.2 class

class关键字

表示新建一个类。

class后面跟随的是这个类的名字，简称：类名。

类名后面跟随一对大括号，表示类的范围。

代码示例：

//表示新建了一个类
//类名：Demo
//类的范围：Demo后面的这对大括号决定。
public class Demo{
    
}

1.2 字面量

就是告诉程序员不同的数据在代码中如何表示

1.2.1 分类：

整数类型： 不带小数点的都是整数类型的字面量

小数类型： 只要带了小数点都是小数类型的字面量

举例：

123：不带小数点，整数类型

1.1 ：带小数点，小数类型

0：不带小数点，整数类型

10.0：带小数点：小数类型

字符串类型： 只要用双引号引起来的，不管里面的内容是什么，不管里面的内容有没有，都是字符串类型的。

字符类型：

一，需要用单引号引起来。二，里面有且只能有一个。

举例：

"abc"：用双引号引起来了，字符串类型

'a'：用单引号引起来了，内容一个，字符类型

" "（里面是一个空格）：用双引号引起来了，字符串类型

""（里面连空格都没有）：用双引号引起来了，字符串类型

“，”（里面是逗号）：用双引号引起来了，字符串类型

“123”：用双引号引起来了，字符串类型

'abc'：语法错误。因为字符里面只能有一个。

布尔类型：

只有两个值。true，false

true：真。false：假。

以后在实际开发中，我们会根据真假结果来执行不同的代码。

比如：用户登录。如果用户的用户名和密码输入正确了，那么比较结果就是true，此时会让用户登录成功。如果用户的用户名和密码输入错误了，那么比较结果就是false，此时会让用户继续输入。

空类型：

只有一个值：null

在后面的面向对象和数组的时候会再次学习。

代码练习：

输出Java中的6种字面量

public class HelloWorld{
    public static void main(String[] args){
        System.out.println(17);
        System.out.println(2.18);
        System.out.println("传智教育");
        System.out.println('男');
        System.out.println(true);
        System.out.println(false);
        //null简单理解：就表示什么东西都不存在。
        //不能直接输出使用的。
        System.out.println(null);
    }
}

1.3 变量

1.3.1概念

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

在实际开发中的使用场景

突出了变量的变字。

场景一

用户登录的时候，每一个用户的用户名和密码都有可能是不一样的。

在程序中，我们就可以定义两个变量，一个存储用户名，一个存储密码。

场景二

微信余额

微信的余额，也是经常发生改变的。

我们可以定义一个变量，用来记录微信的余额。当余额发生改变的时候，就修改变量记录的值。

场景三

银行卡余额

核心点

经常发生变化的。

1.3.2 格式

数据类型 变量名 = 数据值；

数据类型：用于限定存储数据的类型。

如果是整数类型，那么表示该变量只能存整数

变量名：就是给小空间起的一个名字，方便以后使用。

数据值：存在小空间里面的数据。

分号：表示语句的结束。

1.3.3 整体理解

我们可以把变量理解为一个临时存储数据的小空间（小箱子）。

变量名，就是这个小空间的名字。

数据类型，限定了以后什么数据能存到这个小空间中。

数据值：真实存在小空间中的数据。

代码示例：

//1.定义一个变量，用来记录整数
int a = 123;
//2.定义一个变量，用来记录小数（浮点数）
double b = 11.1;

1.3.4 变量的使用

使用方式一：直接打印

代码示例：

//定义一个变量记录10
int a = 10;
//打印的是变量a里面记录的值
System.out.println(a);//10

扩展的对比：

//此时小括号中，打印的是字符串a
System.out.println("a");//a 

使用方式二：参与计算

代码示例1：

int a = 10;
int b = 20;
//把变量a和变量b里面的值相加，再把结果打印出来
System.out.println(a + b); 

代码示例2：

int a = 10;
int b = 20;
//把变量a和变量b里面的值相加，再把结果赋值给左边的变量c
int c = a + b;
//把变量c里面的值进行打印。
System.out.println(c); 

使用方式三：修改变量的值

核心：变量只能记录一个值，修改之后，原来的值就会被覆盖

代码示例：

//定义一个新的变量，变量里面记录为10
int a = 10;
//此时变量a还没有被修改，所以打印的是最初的值10
System.out.println(a); //10
//修改已有的变量a，把里面的值修改为20.原来的值就被覆盖了
a = 20;
//此时变量里面记录的值已经被修改，打印修改之后的值20
System.out.println(a); //20

1.3.5 变量的注意事项

1. 变量里面只能记录一个值。

   当修改了变量里面的值时，原来的值就会被覆盖。

2. 变量名不允许重复

   代码示例：

   int a = 10;
   int a = 20;
   System.out.println(a); //变量名重复了，所以报错

3. 一条语句可以定义多个变量（了解）

   建议：

   以后在定义变量的时候，一行定义一个。

   如果要定义多个变量，写在多行。

   代码示例：

   //表示在一行定义了4个变量，都是int类型的，以后能存整数
   //但是这种写法，不方便阅读。
   int a = 10,b = 20,c = 30,d = 40;
   System.out.println(a);
   System.out.println(b);
   System.out.println(c);
   System.out.println(d);

4. 变量在使用之前一定要赋值

   代码示例：

   int a = 10;
   //以等号为中间界，分为两部分。
   //第一部分：等号的左边，定义变量
   	int a
   //第二部分：等号的右边，给左边的变量赋值
   	= 10；

   代码示例：

   // 只定义不赋值
   int a ;
   //修改值
   a = 10;
   //打印a
   System.out.println(a);

   建议：

   虽然变量的定义和赋值可以分开写，但是不建议。

   建议，以后写代码的时候，定义变量直接给值。

1.3.6 变量的案例

根据情况计算车上乘客的数量

代码示例：

public class Test5{
	public static void main(String[] args){
		//一开始车上没人
		int count = 0;
		//到了第一站：上来一个人，没有人下去
		//先拿着count为0跟1进行相加
		//再把最终的结果赋值给count
		count = count + 1;	
		//到了第二站：上来两个人，下去一个人
		count = count + 2;
		count = count - 1;		
		//到了第三站：上来两个人，下去一个人
		count = count + 2;
		count = count - 1;		
		//到了第四站：下去一个人
		count = count - 1;
		//到了第五站：上来一个人
		count = count + 1;
		//到了终点站，count的值就是车上的乘客数量
		System.out.println(count);
	}
}

1.4 数据类型

1.4.1 Java中数据类型的分类

• 基本数据类型

• 引用数据类型

1.4.2 基本数据类型四类八种

整数类型：byte、short、int、long

浮点类型：float、double

字符类型：char

布尔类型：boolean

扩展：

引用数据类型，在代码中除了上面的四类八种其他所有的都是引用数据类型。

基本数据类型需要记忆的

• byte的取值范围：

  -128 ~ 127

• int的大概取值范围：

  -21亿多 ~ 21亿多

• 整数和小数的取值范围的大小关系：

  byte < short < int < long < float < double

扩展：

不同的数据类型，在内存中占用的字节数量是不一样的。

1.4.3 不同类型变量的定义

注意点：

定义long类型变量的时候，后面的数据值要加L后缀。建议大写。

定义float类型变量的时候，后面的数据值要加F后缀。建议大写。

代码示例：

//byte
byte b = 10;
System.out.println(b);//10

//short
short s = 100;
System.out.println(s);//100

//int
int i = 99;
System.out.println(i);//99

//long
//如果给long类型的变量赋值。
//后面的数据值要加L后缀。
//L可以是大写的，也可以是小写的。
//建议大写。
long n = 9999999999L;
System.out.println(n);

//float
float f = 11.1F;
System.out.println(f);

//double
double d = 10.2;
System.out.println(d);

//char
char c = '我';
System.out.println(c);

//boolean
boolean bb = true;
System.out.println(bb);

1.4.4 变量的练习

练习的目的：

以后在实际开发中，根据不同的数据来选择不同的数据类型

练习1：

定义变量记录老师的信息。

代码示例：

public class VariableDemo2{
    public static void main(String[] args){
        //老师的姓名
        String s = "黑马谢广坤";
        //老师的年龄
        int i = 18;
        //老师的性别
        char c = '男';
        //老师的身高
        double d = 180.1;
        //是否单身
        boolean b = true;
        //输出所有变量
        System.out.println(s);
        System.out.println(i);
        System.out.println(c);
        System.out.println(d);
        System.out.println(b);
    }
}

练习2：

定义变量记录电影的信息。

代码示例:

public class VariableDemo2{
    public static void main(String[] args){
        //定义变量记录电影的名字
        String name = "送初恋回家";
        //定义变量记录主演的名字
        String personName = "刘鑫等等";
        //定义变量记录年份
        int year = 2020;
        //定义变量记录分数
        double score = 9.0;
        
        //输出所有变量
        System.out.println(name);
        System.out.println(personName);
        System.out.println(year);
        System.out.println(score);
    }
}    

练习3：

定义变量记录手机的信息。

代码示例：

public class VariableDemo2{
    public static void main(String[] args){
        //定义变量记录手机的价格
        double price = 5299.0;
        //定义变量记录手机的品牌
        String name = "华为";
        
        //输出所有变量
        System.out.println(price);
        System.out.println(name);
    }
}

1.5 标识符

1.5.1 什么是标识符？

给类、方法、变量起的名字就是标识符。

简单理解：在代码中，凡是我们自己起的名字都是标识符，都要遵守我们下面讲解的规则。

1.5.2 标识符的硬性要求

必须要这么做，否则代码就会报错。

• 必须由数字、字母、下划线、美元$符组成

• 不能以数字开头

• 不能是关键字

• 区分大小写

1.5.3 标识符的软性建议

如果不这么做，代码不会报错，但是影响阅读，也显得代码很low

建议：不管是硬性要求还是软性建议，咱们都要遵守。

小驼峰命名法：

适用于：方法名、变量名

• 一个单词，全部小写。

  比如：name，age，gender，address

• 多个单词，从第二个单词开始首字母大写。

  比如：firstName

大驼峰命令法：

适用于：类名

• 一个单词，首字母大写。

  比如：Demo，Test，Student

• 多个单词，每一个单词的首字母都要大写。

  比如：HelloWorld

建议：

不管起什么名字，都要遵守四个字：见名知意。

如果英文单词记不住，不要使用拼音，用有道词典查一下。如果担心自己时间长了忘了，写注释。

1.6 键盘录入

1.6.1 目的：为了让我们变量记录的数据变得更加灵活。

1.6.2 实现步骤：

1.导包

简单理解：先要找到Scanner这个类在哪？

2.创建对象

简单理解：申请一下去我要开始用Scanner这个类了。

3.接收数据

只有等号右边才是真正的接收数据，接收到之后，把数据赋值给左边的变量

代码示例：

//1.导包 ，实际作用：先找到Scanner这个类在哪
//必须要写在第一行，类定义的外面
import java.util.Scanner;		

public class ScannerDemo1{
    public static void main(String[] args){
        //2.创建对象 ， 实际作用：申请一下我要开始用Scanner这个类了。
        Scanner sc = new Scanner(System.in);
        //加一个提示
        System.out.println("请输入一个整数");
        //3.把接收到的数据赋值给一个变量
        int number = sc.nextInt();  
        System.out.println(number);
    }
}

1.6.3 键盘录入的练习

核心：如果我们需要多次键盘录入数据，那么第一步和第二步不需要多次书写。只要多次书写第三步即可

代码示例：

import java.util.Scanner;//找到Scanner这个类在哪	

public class ScannerDemo1{
	public static void main(String[] args){
		//申请一下，我准备要用Scanner这个类了。
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入第一个整数");
		int number1 = sc.nextInt();
		
		System.out.println("请输入第二个整数");
		int number2 = sc.nextInt();
		
		//求和
		int result = number1 + number2;
		
		System.out.println(result);
	}
}

第二章 运算符

2.1 算术运算符

2.1.1 分类：

+ - * / % 

2.1.2 细节：

1.运算规则，跟小学数学是一模一样的

2.如果是整数跟整数进行计算，结果只能是整数。直接去掉小数部分，保留整数。

3.如果想要结果中有小数，需要有小数参与计算。

4.只要有小数参与计算，那么结果是有可能不精确的

5.%，叫做取余或者取模，进行的也是除法运算，只不过获取的是余数。

代码示例：

// %
//取余  取模
//跟除法一样，做的也是除法运算。
//除法 取的是商 取余取的是余数
System.out.println(10 / 3);//3
System.out.println(10 % 3);//1

%的使用场景：

1.我们可以利用%判断数字a是否可以被数字b整除。（掌握）

10 % 7 
看他的最终结果是不是0，如果结果为0，那么就表示10是7的倍数。
如果结果不是0，那么就表示10不是7的倍数。

2.我们可以利用%判断一个数字是奇数还是偶数。（掌握）

10 % 2
看他的最终结果是不是0，如果结果为0，表示10是偶数
如果结果是1，表示10是奇数。

3.我们还可以利用%去做游戏中的发牌（了解）

斗地主牌
1.我们可以把54张扑克牌都定义一个序号：1~54
2.拿着每一张牌的序号对3取模
如果结果为1，就把当前的牌发给第一个玩家。
如果结果为2，就把当前的牌发给第二个玩家。
如果结果为0，就把当前的牌发给第三个玩家。

2.1.3 练习

需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台

代码示例：

//对于任意的一个整数
//个位：数字 % 10
//十位：数字 / 10 % 10
//百位：数字 / 100 % 10
//千位：数字 / 1000 % 10
//万位：数字 / 10000 % 10
//...以此类推


//分析：
//1.键盘录入一个三位数，123
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int number = sc.nextInt();
System.out.println(number);
//2.将其拆分为个位、十位、百位后，打印在控制台

//number是什么？就是键盘录入的数字
//拿着键盘录入的数字跟10进行取余的计算。
//把得到的余数赋值给左边的变量
int ge = number % 10;

//拿着键盘录入的数字先跟10相除，得到整数部分
//拿着得到的整数部分，再跟10进行取余的计算。
//把得到的余数赋值给左边的变量
int shi = number / 10 % 10;

int bai = 456 / 100 % 10;
System.out.println(ge);
System.out.println(shi);
System.out.println(bai);

2.2 隐式转换

概念

取值范围小的，变成取值范围大的。

细节：

隐式转换是不需要我们自己单独写代码实现的。是由虚拟机帮我们自动完成的。

触发时机：

在实际开发中，什么时候用到这个知识点。

1.取值范围小的跟取值范围大的进行计算的时候，小的会先提升为大的，然后再进行计算。

2.byte short char 这三种类型在参与计算的时候，先提升为int，再进行计算。

举例：

int a = 10;
double b = a;
//不会报错
//就是把一个取值范围小的，变成取值范围大的。
//把小的给大的不会报错，可以直接给。
//提升的时候，实际提升的不是变量a，而是变量a里面的数据10.

int a = 10;
long n = 100L;
??? result = a + n;
//问：result 是什么数据类型？long
//数据类型不一样，不能直接进行计算
//需要转成一样的才能进行计算。
//把变量a里面的数据10，提升为long类型的
//实际上，最终就是两个long类型的数据进行计算。
//最终的结果result就是long类型的

int a = 10；
long n = 100L;
double d = 20.1;
??? result = a + n + d;
//问：result 是什么数据类型？double
//数据类型不一样，不能直接进行计算
//需要转成一样的才能进行计算
//第一步：是a + n 类型不一样，变量a里面的数据先变成long，进行计算
//		 a + n 的结果是long类型的、
//第二步：long + double。需要继续提升，最终提升为double
//所以，最终的结果就是double类型。

byte b1 = 10；
byte b2 = 20；
??? result = b1 + b2;
//问：result 是什么数据类型？int
//取值范围比int小的类型，在计算的时候。先直接提升为int。再进行计算。
//b1和b2里面的数据，在进行计算的时候，先提升为int，再进行计算
//所以，结果为int。

2.3 强制转换

核心：

把一个取值范围大的，交给取值范围小的。

在代码中，不能直接给，如果一定要这么干，就需要加入强制转换。

格式：

因为这个操作，不是虚拟机帮我们进行的，需要我们自己写代码实现。

简单理解：想要转成什么类型，就在前面的小括号中，写什么类型即可。

目标数据类型 变量名 = （目标数据类型）待转换的数据。

细节：

强制转换，有可能导致数据发生改变。

举例：

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

byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2;
//第三行代码是报错的，因为等号的右边最终结果为int类型
//而把大的给小的，是不能直接给的，会报错。
//所以我们可以加入强制转换

//错误的。此时强转的是b1.
byte b3 = (byte)b1 + b2;

//错误的。此时强转的是b1和b2
//就算转完了，他们在再次相加计算的时候，还会变成int类型
byte b3 = (byte)b1 + (byte)b2;

//正确的。先计算小括号中的b1 + b2 ，得到一个int类型的结果
//然后再把int类型的结果转换成byte类型
byte b3 = (byte)(b1 + b2);

2.4 字符串的加操作

规则1：

在+的过程中，如果有字符串参与计算，那么此时+就不是算术运算符了，而是字符串的拼接符。会把数据进行拼接，并产生一个新的字符串。

规则2：

如果有多个+连续存在，从左到右依次计算，如果没有字符串，就是普通的算术运算符。

如果有字符串参与，就是拼接。

规则3：

如果字符串跟变量进行拼接，是拿着变量里面的数据跟字符串进行拼接。

但是变量不能用双引号引起来。

举例：

"123" + 123  结果："123123"

123 + 123 + "123" 结果："246123"

int age = 18;
sout("我的年龄是" + age + "岁");//我的年龄是18岁
//此时是三个字符串进行拼接
sout("我的年龄是" + "age" + "岁");//我的年龄是age岁

System.out.println(1 + 2 + "abc" + 2 + 1);//3abc21
//当连续+的时候，从左到右依次计算的，如果有字符串就是拼接
//如果没有字符串，就是相加。
//第一步：1 + 2 结果3
//第二步：3 + "abc" 结果"3abc"
//第三步："3abc" + 2 结果"3abc2"
//第四步："3abc2" + 1 结果"3abc21" 

用法：

可以让我们的变量在展示的时候，更加有意义。

//分析：
//1.键盘录入一个三位数，123
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int number = sc.nextInt();
System.out.println(number);
//2.将其拆分为个位、十位、百位后，打印在控制台

//number是什么？就是键盘录入的数字
//拿着键盘录入的数字跟10进行取余的计算。
//把得到的余数赋值给左边的变量
int ge = number % 10;

//拿着键盘录入的数字先跟10相除，得到整数部分
//拿着得到的整数部分，再跟10进行取余的计算。
//把得到的余数赋值给左边的变量
int shi = number / 10 % 10;

int bai = number / 100 % 10;
System.out.println("个位是:" + ge);
System.out.println("十位是:" + shi);
System.out.println("百位是:" + bai);

2.5 字符的加操作

ASCII码表：

在这张码表中，字符跟数字有一个一一对应的关系。

'a' --- 97

'A' --- 65

规则：

当字符加字符 或者 字符加数字的时候，此时字符会到ASCII码表中找对应的数字，然后再进行计算。

注意点：

当字符跟字符串参与计算的时候，做的是拼接操作。

代码示例：

char c = 'a';
int result = c + 0;//97
//先拿着字符a到码表中查，查到了数字97，再跟0进行计算，结果就是97.

char c = 'a';
System.out.println("ABC" + c);//ABCa