Java语言的数据类型

来源：互联网发布：dhcp 端口号43端口号编辑：程序博客网时间：2024/05/17 06:09

###02.01_Java语言基础(原码反码补码)(了解)

* A:为什么要学习原码反码补码?
* Java后面要学习强制类型转换,如果不知道有原反补会看不懂结果
* B:有符号数据表示法的几种方式
* 原码
* 就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。
* 通过一个字节,也就是8个二进制位表示+7和-7
* 0(符号位)0000111
* 1(符号位)0000111
* 反码
* 正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
* 补码
* 正数的补码与其原码相同；负数的补码是在其反码的末位加1。

###02.02_Java语言基础(原码反码补码的练习)(了解)

* A:已知原码求补码
* 0b10110100
* B:已知补码求原码
* 0b11101110

###02.03_Java语言基础(变量的概述及格式)(掌握)

* A:什么是变量
* 在程序执行的过程中，在某个范围内其值可以发生改变的量
* B:变量的定义格式
* 数据类型变量名 = 变量值;
* C:为什么要定义变量
* 用来不断的存放同一类型的常量，并可以重复使用

###02.04_Java语言基础(数据类型的概述和分类)(掌握)

* A:为什么有数据类型
* Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间
* B:Java中数据类型的分类
* 基本数据类型
* 引用数据类型
* 面向对象部分讲解
* C:基本数据类型分类(4类8种)
* 整数型
* byte 占一个字节 -128到127
* short 占两个字 -2^15~2^15-1
* int 占四个字节 -2^31~2^31-1
* long 占八个字节 -2^63~2^63-1
* 浮点型
* float 占四个字节 -3.403E38~3.403E38
* double 占八个字节-1.798E308~1.798E308
* 字符型
* char 占两个字节 0~65535
* 布尔型
* boolean
* boolean理论上是占八分之一个字节,因为一个开关就可以决定是true和false了,但是java中boolean类型没有明确指定他的大小

###02.05_Java语言基础(定义不同数据类型的变量)(掌握)

* A:案例演示

* 定义不同基本数据类型的变量，并输出

* 赋值时候注意float类型,long类型

* 整数给long赋值时，数据后面加L

* 小数给float赋值时，数据后面加f

案例：

class Demo1_DataType { 
// DataType数据类型
public static void main(String[] args) {
// 整数类型
byte b = 10; // 占一个字节,-128 到 127
short s = 20; // 占两个字节
int i = 30; // 占四个字节 整数默认的数据类型就是int类型
long x = 8888888888L; // 占八个字节 如果long类型后面加L进行标识最好加大L,因为小l太像一了
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(x);
 
// System.out.println(12345 + 54321l);
 
// 浮点类型
float f = 12.3F; // 占四个字节
double d = 33.4; // 占八个字节 小数默认的数据类型是double,double类型后面也可以用D或d标识,但是一般不加
System.out.println(f);
System.out.println(d);
 
// 字符类型
char c = 'a'; // 占两个字节
System.out.println(c);
 
// 布尔类型
boolean b1 = true;
boolean b2 = false;
System.out.println(b1);
System.out.println(b2);
}
}

###02.06_Java语言基础(使用变量的注意事项)(掌握)

* A:案例演示
* a:作用域问题
* 同一个区域不能使用相同的变量名
* b:初始化值问题
* 局部变量在使用之前必须赋值（我们现在所使用的变量都是局部变量，因为都是定义在方法中的）
* c
案例:
class Demo2_DataType {
public static void main(String[] args) {
/*
 * int x = 10; int x = 20;
 * 
 * System.out.println(x);
 * 
 * int y;
 * 
 * y = 10; System.out.println(y);
 */
 
int a, b, c, d, e;
 
a = 10;
b = 20;
c = 30;
d = 40;
e = 50;
 
System.out.println(a);
 
int x = 10;
int y = 20;
int z = 30;
}
}

###02.07_Java语言基础(数据类型转换之隐式转换)(掌握)

* A:案例演示

* a:int + int

* b:byte + int

* B:Java中的默认转换规则

* 取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算

* C:画图解释byte+int类型的问题

案例：

class Demo3_DataTypeConversion { 
// Conversion转换
public static void main(String[] args) {
// 数据类型转换之隐式转换
 
/*
 * int x = 3; byte b = 4;
 * 
 * x = x + b;
 * 
 * System.out.println(x);
 */
 
// 数据类型转换之强制转换
/*
 * int x = 3; byte b = 4;
 * 
 * b = (byte)(x + b); System.out.println(b);
 */
 
// 00000000 00000000 00000000 10000010 130的二进制
// 10000010 -126补码
// 00000001 -1求反码
// 10000001 -126反码
// 11111110 -126原码
byte b = (byte) (126 + 4);
System.out.println(b);
// 00000000 00000000 00000001 00101100 300的二进制
// 00101100
byte b2 = (byte) 300;
System.out.println(b2);
}
}

###02.08_Java语言基础(数据类型转换之强制转换)(掌握)

* A:强制转换问题
* int a = 10;
* byte b = 20;
* b = a + b;
* B:强制转换的格式
* b = (byte)(a + b);
* C:强制转换的注意事项
* 如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同
byte类型的数据的取值范围：

案例：

class Demo3_DataTypeConversion { 
// Conversion转换
public static void main(String[] args) {
// 数据类型转换之隐式转换
 
/*
 * int x = 3; byte b = 4;
 * 
 * x = x + b;
 * 
 * System.out.println(x);
 */
 
// 数据类型转换之强制转换
/*
 * int x = 3; byte b = 4;
 * 
 * b = (byte)(x + b); System.out.println(b);
 */
 
// 00000000 00000000 00000000 10000010 130的二进制
// 10000010 -126补码
// 00000001 -1求反码
// 10000001 -126反码
// 11111110 -126原码
byte b = (byte) (126 + 4);
System.out.println(b);
// 00000000 00000000 00000001 00101100 300的二进制
// 00101100
byte b2 = (byte) 300;
System.out.println(b2);
}
}

###02.09_Java语言基础(面试题之变量相加和常量相加的区别)(掌握)

* A:案例演示
* 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
* byte b1 = 3;
* byte b2 = 4;
* byte b3 = b1 + b2;
* 从两方面去回答这个题
* b1和b2是两个变量,变量里面存储的值都是变化的,所以在程序运行中JVM是无法判断里面具体的值
* byte类型的变量在进行运算的时候,会自动类型提升为int类型
* byte b4 = 3 + 4;
* 3和4都是常量,java有常量优化机制,就是在编译的的时候直接把3和4的结果赋值给b4了
案例：
class Test1_DataTypeConversion {
public static void main(String[] args) {
// 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
byte b1 = 3;
byte b2 = 4;
// byte b3 = b1 + b2;
/*
 * 从两方面
 * 1,byte与byte(或short,char)进行运算的时候会提升为int（因为整数默认的类型为int）,两个int类型相加的结果也是int类型
 * 2,b1和b2是两个变量,变量存储的值是变化,在编译的时候无法判断里面具体的值,相加有可能会超出byte的取值范围
 */
// System.out.println(b3);
// byte b4 = 3 + 4; //java编译器有常量优化机制，在编译的时候就把3+4的结果计算出来了，
byte b4 = 7; // 以判断7在-128至127之间
System.out.println(b4);
}
}

###02.10_Java语言基础(long与float的取值范围谁大谁小)(了解)

* 进行混合运算的时候,byte,short,char不会相互转换,都会自动类型提升为int类型,其他类型进行混合运算的是小的数据类型提升为大的
* byte,short,char -- int -- long -- float -- double（依次向右提升）
* long: 8个字节
* float：4个字节
* IEEE754
* 4个字节是32个二进制位
* 1位是符号位
* 8位是指数位
* 00000000 11111111
* 0到255
* 1到254
* -126到127
* 23位是尾数位
* 每个指数位减去127
* A:它们底层的存储结构不同。
* B:float表示的数据范围比long的范围要大
* long：2^63-1
* float：3.4*10^38 > 2*10^38 > 2*8^38 = 2*2^3^38 = 2*2^114 > 2^63-1
*几个基本类型的取值范围如下：byte,short,char < int < long < float < double

案例：
class Test2_DataTypeConversion {
public static void main(String[] args) {
float f = 12.3f;
long x = 12345;
//f = x;//隐式转换
//System.out.println(f);
x = (long)f;//强制转换
System.out.println(x);
/*
float占4个字节
IEEE 754
32个二进制位
1位代表是符号位
8位代表指数位
00000000 - 11111111
0 - 255
0代表0
255代表无穷大
1 - 254
 
-126 - 127
23位代表尾数位
*/
}
}

###02.11_Java语言基础(字符和字符串参与运算)(掌握)

* A:案例演示
* System.out.println('a');
* System.out.println('a'+1);
* 通过看结果知道'a'的值是多少,由此引出ASCII码表
* B:ASCII码表的概述
* 记住三个值：
* '0' 48
* 'A' 65
* 'a' 97
* C:案例演示
* System.out.println("hello"+'a'+1);
* System.out.println('a'+1+"hello");
* D:+在有字符串参与中被称为字符串连接符
* System.out.println("5+5="+5+5);
* System.out.println(5+5+"=5+5");
案例：
class Demo4_DataTypeConversion {
public static void main(String[] args) {
//System.out.println('a' + 1);//98,因为有ASCII码表,a字符对应的是int类型的97
//字符型数据和整型数据进行运算会将字符提升为整型
//System.out.println((char)('a' + 1));
 
System.out.println("hello"+'a'+1);//任何数据类型用+与字符串相连接都会产生新的字符串
System.out.println('a'+1+"hello");
 
System.out.println(" 5 + 5 = " + (5 + 5));
}
}

###02.12_Java语言基础(char数据类型)(掌握)

* A:char c = 97; 0到65535
* B:Java语言中的字符char可以存储一个中文汉字吗?为什么呢?
* 可以。因为Java语言采用的是Unicode编码。Unicode编码中的每个字符占用两个字节。中文也是占的两个字节
* 所以，Java中的字符可以存储一个中文汉字
案例：
class Demo5_Char {
public static void main(String[] args) {
char c = 'a';
System.out.println(c);
 
byte b = 100;
char c1 = 97;//0 - 65535
System.out.println(c1);
 
char c2 = 3;
char c3 = 4;
char c4 = 5;
char c5 = 6;
 
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(c5);
 
//char类型是否可以存储中文
char c6 = '中';
System.out.println(c6);
}
}

###02.13_Java语言基础(算术运算符的基本用法)(掌握)

* A:什么是运算符
* 就是对常量和变量进行操作的符号。
* B:运算符的分类
* 算术运算符，赋值运算符，比较(关系或条件)运算符，逻辑运算符，位运算符，三目(元)运算符
* C:算数运算符有哪些
* +,-,*,/,%,++,--
* D:注意事项：
* a:+号在java中有三种作用,代表正号,做加法运算,字符串的连接符
* b:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
* c:/获取的是除法操作的商，%获取的是除法操作的余数
* %运算符
* 当左边的绝对值小于右边绝对值时,结果是左边
* 当左边的绝对值等于右边或是右边的倍数时,结果是0
* 当左边的绝对值大于右边绝对值时,结果是余数
* %运算符结果的符号只和左边有关系,与右边无关
* 任何一个正整数%2结果不是0就是1可以用来当作切换条件
案例：
class Demo1_Operator {//operator 运算符
public static void main(String[] args) {
/*
* a:+号在java中有三种作用,代表正号,做加法运算,字符串的连接符
* b:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
* c:/获取的是除法操作的商，%获取的是除法操作的余数
* %运算符
* 当左边的绝对值小于右边绝对值时,结果是左边
* 当左边的绝对值等于右边或是右边的倍数时,结果是0
* 当左边的绝对值大于右边绝对值时,结果是余数
* %运算符结果的符号只和左边有关系,与右边无关
* 任何一个正整数%2结果不是0就是1可以用来当作切换条件 
*/
 
//System.out.println(10 / 3);//整数相除结果只能是整数
//System.out.println(10 / 3.0);//如果想得到小数,把其中一个数变成小数,另一个数在运算的时候会自动类型提升
//System.out.println(-5 % 5);
System.out.println(13 % -5);
}
}

###02.14_Java语言基础(算术运算符++和--的用法)(掌握)

* A:++,--运算符的作用
* 自加（++）自减（--）运算
* ++:自加。对原有的数据进行+1
* --:自减。对原有的数据进行-1
* B:案例演示
* a:单独使用：
* 放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
* b:参与运算使用：
* 放在操作数的前面，先自增或者自减，然后再参与运算。
* 放在操作数的后面，先参与运算，再自增或者自减。
案例：
class Demo2_Operator {
/*
* a:单独使用：
* 放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
* b:参与运算使用：
* 放在操作数的前面，先自增或者自减，然后再参与运算。
* 放在操作数的后面，先参与运算，再自增或者自减。
*/
public static void main(String[] args) {
//单独使用
/*int a = 3;
//a++;//a = a + 1;
++a;//a = a + 1;
System.out.println(a);*/
 
//参与运算使用
int a = 3;
int b;
 
//b = a++;//当++在变量后面的时候,会先将变量中的值取出做赋值操作,然后再自身加1
b = ++a;//当++在变量前面的时候,会先自身加1,然后在将结果赋值
System.out.println("a = " + a);
System.out.println("b = " + b);
}
}

###02.15_Java语言基础(算术运算符++和--的练习)(掌握)

* A:案例演示

* 请分别计算出a,b,c的值?

int a = 10;

int b = 10;

int c = 10;

a = b++;

c = --a;

b = ++a;

a = c--;

* B:案例演示

* 请分别计算出x,y的值?

int x = 4;

int y = (x++)+(++x)+(x*10);

* C:面试题

* byte b = 10;

* b++;

* b = b + 1;

* 问哪句会报错,为什么

案例：

class Test1_Operator {
public static void main(String[] args) {
//第一题
/*int a = 10;
int b = 10;
int c = 10;
a = b++;//a = 10 ,b = 11
c = --a;//a = 9, c = 9
b = ++a;//a = 10, b = 10
a = c--;//a = 9, c = 8
System.out.println("a = " + a + ",b = " + b + ",c = " + c);*/
 
//第二题
/*int x = 4;
//4+6+60
int y = (x++)+(++x)+(x*10);
 
System.out.println("x = " + x + ",y = " +  y);*/
 
//第三题问哪句会报错,为什么 
byte b = 10;
//b++;//b = (byte)(b + 1)
b = b + 1;//当byte与int进行混合运算的时候,会提升为int类型,两个int相加的结果还是int,赋值给byte会损失精度
System.out.println("b = " + b);
}
}

###02.16_Java语言基础(赋值运算符的基本用法)(掌握)

* A:赋值运算符有哪些
* a:基本的赋值运算符：=
* 把=右边的数据赋值给左边。
* b:扩展的赋值运算符：+=,-=,*=,/=,%=
* += 把左边和右边做加法，然后赋值给左边。
案例：
class Demo1_Operator {
public static void main(String[] args) {
//赋值运算符
int a = 3;//把右边的常量值赋值给左边的变量,左边必须是变量
 
//a += 4;//a = a + 4;
a = a + 4;
System.out.println(a);
}
}

###02.17_Java语言基础(赋值运算符的面试题)(掌握)

* A:案例演示

* 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。

* short s=1;s = s+1;

* short s=1;s+=1;

案例：

class Test1_Operator {
public static void main(String[] args) {
// 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
//short s=1;s = s+1;//当short与int进行运算的时候,会提升为int类型,两个int类型相加的结果也是int类型
short s=1;s+=1;//s = (short)(s + 1);
 
System.out.println(s);
}
}

###02.18_Java语言基础(关系运算符的基本用法及其注意事项)(掌握)

* A:关系运算符有哪些(比较运算符,条件运算符)
* ==,!=,>,>=,<,<=
* 注意事项：
* 无论你的操作是简单还是复杂，结果是boolean类型。
* "=="不能写成"="。
案例：
class Demo1_Operator {
public static void main(String[] args) {
//==,!=,>,>=,<,<= 
System.out.println(4 == 3);
System.out.println(4 != 3);
System.out.println(4 > 4);
System.out.println(4 >= 4);
System.out.println(4 < 3);
System.out.println(4 <= 3);
}
}

###02.19_Java语言基础(逻辑运算符的基本用法)(掌握)

* A:逻辑运算符有哪些
* &,|,^,!
* &&,||
* B:案例演示
* 逻辑运算符的基本用法
* 注意事项：
* a:逻辑运算符一般用于连接boolean类型的表达式或者值。
* b:表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
* 算术表达式：a + b
* 比较表达式：a == b(条件表达式)
* C:结论：
* &逻辑与:有false则false。
* |逻辑或:有true则true。
* ^逻辑异或:相同为false，不同为true。
* !逻辑非:非false则true，非true则false。
* 特点：偶数个不改变本身。
案例：
class Demo1_Operator {
public static void main(String[] args) {
//&,|,^,!
//int x = 10;
//5 < x < 15
//x > 5 & x < 15
//逻辑与 & 并且and 遇false则false
int a = 10;
int b = 20;
int c = 30;
/*System.out.println(a < b & b < c);//true & true = true
System.out.println(a < b & b > c);//true & false = false
System.out.println(a > b & b < c);//false & true = false
System.out.println(a > b & b > c);//false & false = false*/
 
//逻辑或 或or 遇true则true
/*System.out.println(a < b | b < c);//true | true = true
System.out.println(a < b | b > c);//true | false = true
System.out.println(a > b | b < c);//false | true = true
System.out.println(a > b | b > c);//false | flase = false*/
 
//逻辑异或 ^ 两边相同为false,两边不同为true
/*System.out.println(a < b ^ b < c);//true ^true = false
System.out.println(a < b ^ b > c);//true ^false = true
System.out.println(a > b ^ b < c);//false ^ true = true
System.out.println(a > b ^ b > c);//false^flase = false*/
 
//逻辑非!
System.out.println(!true);
System.out.println(!!true);
}
}

###02.20_Java语言基础(逻辑运算符&&和&的区别)(掌握)

* A:案例演示
* &&和&的区别?
* a:最终结果一样。
* b:&&具有短路效果。左边是false，右边不执行。
* &是无论左边是false还是true,右边都会执行

*||和|的区别?
*a:最终结果一样
*b:||具有短路效果.左边是true,右边不执行
* |是无论左边是false还是true,右边都会执行

* B:同理||和|的区别?(学生自学)

* C:开发中常用谁?

* &&,||,!

案例：

class Demo2_Operator {
/*
&&与&的区别
* a:最终结果一样。
* b:&&具有短路效果。左边是false，右边不执行。
 
||与|的区别
a:最终的结果是一样
b:||具有短路效果,左边为true,右边不执行
*/
public static void main(String[] args) {
/*int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b && b < c);//true && true = true
System.out.println(a < b && b > c);//true && false = false
System.out.println(a > b && b < c);//false && true = false
System.out.println(a > b && b > c);//false && false = false*/
 
int x = 3;
int y = 4;
//System.out.println((++x == 3) & (++y == 4));//false & false = false
//System.out.println("x = " + x);//x = 4
//System.out.println("y = " + y);//y = 5
System.out.println("---------------------------");
System.out.println((++x == 3) && (++y == 4));//false & false = false
System.out.println("x = " + x);//x = 4
System.out.println("y = " + y);//y = 4
}
}

###02.21_Java语言基础(位运算符的基本用法1)(了解)

* A:位运算符有哪些
* &,|,^,~ ,>>,>>>,<<
* B:案例演示
* 位运算符的基本用法1
* &,|,^,~ 的用法

* &:有0则0
* |:有1则1
* ^:相同则0，不同则1
* ~:按位取反

案例：
class Demo1_Operator {
public static void main(String[] args) {
/*
* &,|,^,~ 的用法
* &:有0则0
* |:有1则1
* ^:相同则0，不同则1
* ~:按位取反
*/
 
System.out.println(6 & 3);//2
System.out.println(6 | 3);//7
System.out.println(6 ^ 3);//5
System.out.println(~6);//-7?
}
}
/*
110
& 011
-----------
010

110
| 011
-----------
111

110
^ 011
-----------
101

00000000 00000000 00000000 000001106的原码反码补码都是本身
11111111 11111111 11111111 11111001对6取反
- 00000000 00000000 00000000 00000001
---------------------------------------
11111111 11111111 11111111 11111000反码
10000000 00000000 00000000 00000111原码(-7)
*/

###02.22_Java语言基础(位异或运算符的特点及面试题)(掌握)

* A:案例演示

* 位异或运算符的特点

* ^的特点：一个数据对另一个数据位异或两次，该数本身不变。

* B:面试题：

* 请自己实现两个整数变量的交换

* 注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。

案例：

class Demo2_Operator {
public static void main(String[] args) {
/*
* 位异或运算符的特点
 
* ^的特点：一个数据对另一个数据位异或两次，该数本身不变。
*/
 
//System.out.println(5 ^ 10 ^ 10);
//System.out.println(5 ^ 10 ^ 5);
 
/*
* 请自己实现两个整数变量的交换(不需要定义第三方变量)
* 注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。
*/
 
int x = 10;
int y = 5;
 
//需要第三方变量,开发推荐用这种
/*int temp;
temp = x;
x = y;
y = temp;*/
 
//不需要定义第三方变量,有弊端,有可能会超出int的取值范围
/*x = x + y;//10 + 5 = 15
y = x - y;//15 - 5 = 10
x = x - y;//15 - 10 = 5*/
 
//不需要第三方变量,通过^来做
x = x ^ y;// 10 ^ 5 
y = x ^ y;// 10 ^ 5 ^ 5y = 10
x = x ^ y;// 10 ^ 5 ^ 10  x = 5
 
System.out.println("x = " + x + ",y = " + y);
}
}

###02.23_Java语言基础(位运算符的基本用法2及面试题)(了解)

* A:案例演示 >>,>>>,<<的用法:

* <<:左移左边最高位丢弃，右边补齐0(正负数都适合)

* >>:右移最高位是0，左边补齐0;最高为是1，左边补齐1(正数适合,负数不适合)

* >>>:无符号右移无论最高位是0还是1，左边补齐0(正数适合,负数不适合,负数右移会变成正数)

* 最有效率的算出2 * 8的结果

案例：

class Demo3_Operator {
public static void main(String[] args) {
/*
*  <<:左移左边最高位丢弃，右边补齐0
*  >>:右移最高位是0，左边补齐0;最高为是1，左边补齐1
*  >>>:无符号右移 无论最高位是0还是1，左边补齐0
*  最有效率的算出2 * 8的结果
*/
 
//左移,向左移动几位就是乘以2的几次幂
//System.out.println(12 << 1);//24
//System.out.println(12 << 2);//48
 
/*
00000000 00000000 00000000 0000110012的补码
 (0)0000000 00000000 00000000 00001100024的补码
(00)000000 00000000 00000000 000011000048的补码
*/
 
//右移,向右移动几位就是除以2的几次幂
//System.out.println(12 >> 1);
//System.out.println(12 >> 2);
 
/*
00000000 00000000 00000000 0000110012的补码
000000000 00000000 00000000 0000110(0)6
0000000000 00000000 00000000 000011(00) 3
*/
 
//最有效率的算出2 * 8的结果
System.out.println(2 << 3);
}
}

###02.24_Java语言基础(三元运算符的基本用法)(掌握)

* A:三元运算符的格式
* (关系表达式) ? 表达式1 : 表达式2;
* B:三元运算符的执行流程
* C:案例演示
* 获取两个数中的最大值
案例：
class Demo1_Operator {
public static void main(String[] args) {
//(关系表达式) ? 表达式1 : 表达式2;
int x = 10;
int y = 5;
int z;
z = (x > y) ? x : y;
 
System.out.println("z = " + z);
}
}

###02.25_Java语言基础(三元运算符的练习)(掌握)

* A:案例演示

* 比较两个整数是否相同

* B:案例演示

* 获取三个整数中的最大值

案例：

class Test1_Operator {
public static void main(String[] args) {
/*
* A:案例演示
* 比较两个整数是否相同
* B:案例演示
* 获取三个整数中的最大值
*/
 
//比较两个整数是否相同
 
/*int x = 10;
int y = 10;
 
//boolean b = (x == y) ? true : false;
boolean b = (x == y);
System.out.println("b = " +  b);*/
 
//获取三个整数中的最大值
int a = 10;
int b = 20;
int c = 30;
 
//先比较任意两个数的值,找出这两个数中的最大值
int temp = (a > b) ? a : b;
//用前两个数的最大值与第三个数比较,获取最大值
int max = (temp > c) ? temp : c;
System.out.println("max =" + max);
}
}

###02.26_Java语言基础(键盘录入的基本格式讲解)(掌握)

* A:为什么要使用键盘录入数据
* a:为了让程序的数据更符合开发的数据
* b:让程序更灵活一下
* B:如何实现键盘录入呢?
* 先照格式来。
* a:导包
* 格式：
* import java.util.Scanner;
* 位置：
* 在class上面。
* b:创建键盘录入对象
* 格式：
* Scanner sc = new Scanner(System.in);
* c:通过对象获取数据
* 格式：
* int x = sc.nextInt();
* C:案例演示
* 键盘录入1个整数，并输出到控制台。
* 键盘录入2个整数，并输出到控制台。
案例：
import java.util.Scanner;
class Demo2_Scanner {
public static void main(String[] args) {
/*Scanner sc = new Scanner(System.in);//创建键盘录入对象
System.out.println("请输入一个整数:");
int x = sc.nextInt();//将键盘录入的数据存储在x中
System.out.println(x);*/
 
//录入两个整数
Scanner sc = new Scanner(System.in);//创建键盘录入对象
System.out.println("请输入第一个整数:");
int x = sc.nextInt();//将键盘录入的数据存储在x中
System.out.println(x);
 
System.out.println("请输入第二个整数:");
int y = sc.nextInt();//将键盘录入的数据存储在y中
System.out.println(y);
}
}

###02.27_Java语言基础(键盘录入的练习1)(掌握)

* A:案例演示

* 键盘录入练习：键盘录入两个数据，并对这两个数据求和，输出其结果

* B:案例演示

* 键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值

案例：

import java.util.Scanner;//导入包中的类Scanner
class Test2_Scanner {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);//创建键盘录入对象
//键盘录入练习：键盘录入两个数据，并对这两个数据求和，输出其结果
/*System.out.println("请输入第一个整数:");
int x = sc.nextInt();//将键盘录入的数据存储在x中
System.out.println("请输入第二个整数:");
int y = sc.nextInt();//将键盘录入的数据存储在y中
int sum = x + y;
System.out.println(sum);*/
 
//键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值
System.out.println("请输入第一个整数:");
int x = sc.nextInt();//将键盘录入的数据存储在x中
System.out.println("请输入第二个整数:");
int y = sc.nextInt();//将键盘录入的数据存储在y中
 
int max = (x > y) ? x : y;//获取x和y中的最大值
System.out.println("max = " + max);
}
}

###02.28_Java语言基础(键盘录入的练习2)(掌握)

* A:案例演示

* 键盘录入练习：键盘录入两个数据，比较这两个数据是否相等

* B:案例演示

* 键盘录入练习：键盘录入三个数据，获取这三个数据中的最大值

案例：

import java.util.Scanner;//导包
class Test3_Scanner {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);//创建键盘录入对象
 
//键盘录入练习：键盘录入两个数据，比较这两个数据是否相等
/*System.out.println("请输入第一个整数:");
int x = sc.nextInt();//将键盘录入的数据存储在x中
System.out.println("请输入第二个整数:");
int y = sc.nextInt();//将键盘录入的数据存储在y中
 
//boolean b = (x == y)? true : false;
boolean b = (x == y);
System.out.println(b);*/
 
//键盘录入练习：键盘录入三个数据，获取这三个数据中的最大值
System.out.println("请输入第一个整数:");
int x = sc.nextInt();//将键盘录入的数据存储在x中
System.out.println("请输入第二个整数:");
int y = sc.nextInt();//将键盘录入的数据存储在y中
System.out.println("请输入第三个整数:");
int z = sc.nextInt();//将键盘录入的数据存储在y中
 
//定义临时变量记录住比较出前两个变量中的最大值
int temp = (x > y) ? x : y;
//将比较后的结果与第三个变量中的值比较,比较出三个数中的最大值
int max = (temp > z) ? temp : z;
System.out.println(max);
}
}

###02.29_day02总结

* 把今天的知识点总结一遍。

0 0