小白学习java第二天

​
第二天

复习：

1.跨平台特性

2.jvm jre jdk

3.jdk的下载，安装，配置

4.编译工具javac 源文件。java 执行java 类名

5.规范，问题

6.关键字，标识符，，注释

7.常量（整数，浮点，布尔，字符，字符串，空null）

8.变量 格式：数据类型 变量名=数据；

强类型语言，在内存中开辟的空间必须确定大小

9.数据类型

引用类型：数组[]，类class，接口interface，枚举enum，注解annotation

基本类型：
整数：byte，short，int，long

浮点：float，double

布尔：boolean

字符：char

字符串：String

目标

基本数据类型间的转换问题
运算符
扫描器
流程控制语句—分支语句–判断语句

1.基本数据类型间的转换问题

自动转换：（不需要手动写代码）

小类型自动提升类型与大类型一致。

      byte short--> int --> long --> float --> double

      Boolean不参与计算

      字符：做计算提升类型为int

强制转换：（需要手动写代码）

大类型–>小类型
注意：强转后，数据的精确程度可能会降低，使用时慎用

public class Demo2{
	public static void main(String[] args){
		
		byte  b = 10;

		int  x = b;  //将b中的数据取出，赋值给x中

		int  y = b + 10;   // byte (提升int) + int
		System.out.println(y);

		float  f = 1.23f;
		f = f + 10;

		long  lo = 10;
		f = f + lo;
		System.out.println(f);

		System.out.println("---------------------------------");

		char c = 'a';
		char c1 = 97;
		char c2 = '\uff1b';
		/*

		编码表(字符集)：
		  字符和数字间对应关系的一张表格
		  ASCII编码表
		  iso8859-1
		  Unicode java内置的编码表，占两个字节存储  
		  GBK：中文库  2个字节
		  utf-8:  3个字节一个中文
		因为有编码表的存在，char遇到运算符，自动查表，将字符对应的整数找到，进行计算
		*/
		System.out.println(c + 0);
		System.out.println(c1);
		System.out.println(c2);

		System.out.println("---------------------------------");
		int m = 10;
		byte n = (byte)m;
		
		double  d = 1.23;
		m = (int)d;
		System.out.println(m);
	}
}

2.运算符

算数运算符：
二元运算：+ - * / %（取模，取余数） 几次方不用^

一元运算：++自增 --自减
（放在某个变量的前边或后边进行加一的求和，单独运算前后没区别，
多项运算时前边先运算自加减后取值变量输出，后边先取值变量输出后运算自加减）

//%：取余有负数出现最终结果正负看左边的数
//+：字符串连接符，字符串可以与任意类型做连接计算，最终也是字符串
//整数除以整数结果是整数，数据中有浮点类型，才会出现结果是浮点类型

赋值运算符：=（右边赋值给左边）

+= -= *= /= %= (自动完成强转操作)

             a += b --> a=a+b    模板，其他符号同理

比较运算符：> >= < <=
==(比较两边是否相等) ！=（比较两边是否不等）

逻辑运算符：是用来连接值为boolean类型的表达式的

&：and 与，连接的表达式两个都是true，结果才是true，否则false

|：or  或，连接的表达式两个都是false，结果才是false，否则true

！：not 非，取反的意思，！true=false，！false=true

短路与：&&，一旦计算出结果是false，后边不计算直接判定结果为false
                            True还是都算

短路或：||，一旦计算出结果是true，后边不计算直接判定结果为true
                            False还是都算

三元运算符：指的是需要三个操作数（表达式）

                      格式：条件表达式？表达式1：表达式2；

条件表达式的结果一定是boolean类型。条件表达式直接写true，false也可以

规则：先计算条件表达式，如果结果是true，最终执行表达式1

                      如果结果是false，最终执行表达式2

public class Demo3{
	public static void main(String[] args){
		//整数除以整除结果是整数
		//数据中有浮点类型，结果才会是浮点类型
		System.out.println(7896/1000); //7
		System.out.println(15 / 3.0); //5.0
		
		int  a = 10;
		//a++;
		//++a;  // a = a + 1;
		//放在某个变量的前边或后边，表示给当前的变量进行+1的求和。

		//结合使用：放在前边和放在后边是有区别的
		//int b = a++; //后边： 先取出a的值，做计算，然后再计算a++
		int b = ++a; //前边：先进行a++,然后再做其他计算
		System.out.println(b);
		System.out.println(a);


		int m = 10;
		int n = ++m + m++ + m-- + --m;
            //= 11  + 11  + 12  + 10
            //=先加1，m为11，取值做加法 + m取值11，后加1 + m取值12，后减1 + 先减1，m取值10
		System.out.println(n);
		System.out.println(m);


		//取余数运算
		System.out.println(6 % 4); //2
		System.out.println(4 % 6); //4
		System.out.println(4 % 2); //0

		//有负数出现，最终结果是正数还是负数看左边的数
		System.out.println(4 % -6);

		//+ ： 字符串连接符
		//     字符串可以与任意类型做连接计算，最终结果也是字符串类型

		System.out.println("5 + 5 = " + (5 + 5));

	}
}

public class Demo4{
	public static void main(String[] args){
		byte a = 10;
//		a = (byte)(a + 10);  // 步骤：1.a+10的和  2.将和结果赋值给a

		a += 10; //好处：1.提高运算效率  2.自动完成强转操作

//		a = b + c;  a = a + b;模板

		System.out.println("a = "+ a);

//		a *= 10; // a = a * 10;


		System.out.println("-------------------------------------------------------");

		System.out.println(5 > 3);
		System.out.println(5 < 3);
		System.out.println(5 == 3);
		System.out.println(5 != 3);

		System.out.println(5 > 3 &  10 < 8);
		System.out.println(5 > 3 |  10 < 8);
		System.out.println(!(5 < 3));

		int  x = 10, y = 8;

		System.out.println( x > 5 && ++ y > 6);
		System.out.println("y = " + y);

		System.out.println("-------------------------------------------------------");

		//三元运算符： 条件表达式 ？表达式1 ： 表达式2；

		int num = false ? 5 : 7;
		System.out.println("num = " + num);

		//判断某一个数是否是偶数
		String  s = (num % 2  ==  0 ? "是偶数"  : "不是偶数");
		System.out.println(s);
		

	}
}

3.键盘录入

步骤：
1.导包语句：在class上边，写一条语句：import java.util.*;
2.创建扫描器：Scanner 变量名 = new Scanner（System.in）;
3.通过扫描器扫描录入的int类型的数据：sc.nextInt();
4.对数据进行想要的计算

//1.导包语句
import java.util.*;
public class Demo5{
	public static void main(String[] args){
		//2.创建扫描器
		Scanner  sc = new Scanner(System.in);
		System.out.println("请输入两个整数：");
		//3.通过扫描器，扫描录入的int类型的数据
		//定义变量，存储扫描到的数据
		int num1 = sc.nextInt();
		int num2 = sc.nextInt();
		//4.对数据进行计算
		System.out.println(num1+num2);

		//输入两个整数，打印两个整数的大数。

		int max = num1 > num2 ? num1 : num2;
		System.out.println("大数是："+max);
	}
}

4.语句

分支语句：写得多，执行的少。 程序执行到某一行，有多个执行顺序，最多选择其中一个执行顺序执行

判断语句：关键字：if else

 if （条件表达式）{
  …
 }

条件表达式的结果是boolean类型

条件表达式结果是true，执行大括号中的代码，执行括号外的后续代码

条件表达式结果是false，跳过大括号中的代码，执行括号外的后续代码

if （条件表达式）{
     语句块1；
} else{
     语句块2；
}

条件表达式结果是true，执行语句块1，执行括号外的后续代码

条件表达式结果是false，执行语句块2，执行括号外的后续代码

if（条件1）{
    语句块1；
}else if （条件2）{
    语句块2；
}else if （条件3）{
    语句块3；
}……else{
    语句块n；
} 

先执行条件表达式1，结果是true，执行语句块1，整个语句结束，执行语句外后续的代码；
如果是false，执行条件表达式2，结果是true，执行语句块2，执行语句外的后续的代码；
如果是false，执行条件表达式3，…
以此类推，当所以的条件表达式结果是false，执行语句块n，执行语句外的后续的代码。

**If大括号里只有一行语句时可以省略大括号，多行省略大括号只执行第一行的语句。** 

练习

定义三个整数变量，获取其最大值，并打印。

import java.util.*;
public class zuida{
	public static void main (String[] args){
	Scanner sc = new Scanner(System.in);
	System.out.println("输入三个整数");
	int num1 = sc.nextInt();
	int num2 = sc.nextInt();
	int num3 = sc.nextInt();
	if(num1>num2){
	  if(num1>num3){
			System.out.println("最大值为"+num1);
	  }
	  }else if(num2>num3){
			System.out.println("最大值为"+num2);
	}else {
			System.out.println("最大值为"+num3);
	} 
}
}

输入一个三位整数，判断是否是水仙花数。
水仙花数：每个位上的数字立方相加之和等于原数本身。
如：153 = 1的立方+3的立方+5的立方

import java.util.*;
public class flower{
	public static void main (String[] args){
	Scanner sc = new Scanner(System.in);
	System.out.println("输入一个三位整数");
	int i = sc.nextInt();
    int a = i/100 % 10; //百位
	int b = i/10 % 10;  //十位
	int c = i % 10;     //个位
	String s = i == a*a*a+b*b*b+c*c*c ? "是":"不是";
	System.out.println(s);
	}
}