java_系列_1_变量

变量

为什么要使用变量

• 变量是程序的基本组成单位
• 变量的组成：数据类型+变量名+值
• 变量相当于内存中的一个存储空间，可以把变量比喻为一个房间的门牌号，通过门牌号可以找到房间，而通过变量名可以找到变量的值。

int a=1;//定义了一个整型变量 变量名为a int 表示变量的类型
a=6;//表示把6赋值给a 则此时的a存储的是6

变量的使用

//声明变量
int a;
//使用变量
a=1;
//声明变量的同时使用变量
int b=1;

变量使用的注意事项

1. 变量表示内存中的一个存储区域。不同的变量，类型不同，占用空间的大小不同。

2. byte(1字节)、short(2字节)、int(4字节)、long(8字节)、char(2字节)、float(4字节)、double(8字节)、boolean(1字节)。

3. 该存储区域中有自己的名称【变量名】和类型【数据类型】。

4. 变量必须先声明后使用。

5. 该区域的数据可以在**同一类型范围内**不断变化。

6. 变量在**同一个作用域内**不能重名。

数据类型

1.  数据类型分为基本数据类型和引用数据类型。

2.  基本数据类型：byte(1字节)、short(2字节)、int(4字节)、long(8字节)、char(2字节)、float(4字节)、double(8字节)、boolean(1字节)。

3.  引用数据类型：类、数组、接口。【后面总结】

4.  java中各整数类型有固定的范围和字段长度。不受具体的OS【操作系统】的影响。以保证java程序的可移植性。

5.  Java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’。

6.  Java的浮点数默认为**double 型**，声明float型变量须后加‘f’或‘F’。

7. java程序中变量常声明为int型，除非不足以表示大数，才使用long。

整型

0. 整型的默认值是int 类型。

1.  byte[1],short[2],int[4],long[8]。

2.  byte也就是字节，1 byte = 8bits ，byte的默认值是0。[-128 ~ 127]

3.  short占用2字节 ,也就是16位，1 short=16 bits, 它的默认值0。[-2^15~2^15-1]

4.  int占用4字节 ，也就是32位，1 int = 32 bits,它的默认值0。[-2^31~2^31-1]-->(约21亿)

5.  long占用8字节 ，也就是64位，1 long = 64 bits,它的默认值0 L。声明long型变量，
必须以"l"或"L"结尾[-2^63~2^63-1]

浮点类型

0. 浮点型，表示带小数点的数值

1.  float表示数值的范围比long还大

2. float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
定义float类型变量时，变量要以"f"或"F"结尾。[4字节]

3. double:双精度，精度是float的两倍。通常采用此类型。所以浮点数默认类型为double
通常，定义浮点型变量时，使用double型。[8字节]

字符类型[可运算]

1. char 型数据用来表示通常意义上“字符”(2字节)

2. Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。

3. 字符型变量的三种表现形式

①字符常量是用单引号(‘ ’)括起来的单个字符。例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';

②Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’; // '\n'表示换行符

③直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n。

④char类型是可以进行运算的。因为它都对应有Unicode码。

4. [重点:]  
①：两个char类型相加，会发生自动类型提升，提升为int;
如：char ch1='中'；//'中'对应的数字是20013 
	char ch2='国'；//'国'对应的数字是22269
	char ch3=ch1+ch2;
	//报错 具体看图1 ；错误原因解释：需要的类型是char,而你提供的是int类型，所以报错！！
	int i3=ch1+ch2;
	//这个不报错！！

char ch4='中'+’国‘；//不报错！因为'中'和'国'对应的是一个数字，两个数字相加结果再转换为一个数字对应的字符。

验证：
        char ch3='中'+'国';
        char ch5=(char)(20013+22269);
        System.out.println(ch3);//ꔪ
        System.out.println(ch5);//ꔪ
        //说明上面验证正确！

char ch6='中'+'国'+'国'+'国';
//报错 四个数字相加超过了65535 只能通过int类型来接收
        
	 
总结：把char ch1='中‘； 把ch1看成是【0-65535】的一个整数，因为char 类型底层里存的是整数。所以才可以运算的。

• 图1
  

布尔类型

1. boolean 类型用来判断逻辑条件，一般用于程序流程控制.

2. boolean类型数据只允许取值true和false，无null。

3. 不可以使用0或非 0 的整数替代false和true，这点和C语言不同。

4. Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的
boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false
用0表示。

基本数据类型转换与强制类型转换

• 基本数据类型转换

1. 自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容
量大小排序为：【下图】

2. 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的
那种数据类型，然后再进行计算。

3. byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。

4. boolean类型不能与其它数据类型运算。

5. 当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类
型的值将自动转化为字符串(String)类型。

• 图
  
• 强制类型转换

1. 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使
用时要加上强制转换符：()，但可能造成精度降低或溢出,格外要注意。

2. 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可
以实现把字符串转换成基本类型。
如： String a = “43”; int i = Integer.parseInt(a);

3. boolean类型不可以转换为其它的数据类型。

略解String[不是基本数据类型！！]

1. String不是基本数据类型，属于引用数据类型.

2. 使用方式与基本数据类型一致。例如：String str = “abcd”;

3. 一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。
如：String str="hello";
	str=str+"123";
	int n=666;
	str=str+n;

运算符

算术运算符

1.  算术运算符是对**数值类型的变量**进行运算的。

2. 算术运算符需要注意的就是优先级问题，当一个表达式中存在多个操作符时，操作符的
优先级就决定了计算顺序，最简单的就是先乘除后加减。（）的优先级最高，不必要记住
所有的优先级，不确定的直接使用`()`就行了。

3. 算术运算符中比较重点的有[/, % , ++]。

4.  除法[/]：整数除和小数除。整数之间做除法时，只保留整数部分而舍弃小数部分。小数除法时，保留的时double类型。

int x=10/3;//3
double y=10.0/3;//3.3333333333333335

• 自增[++]

 1. 作为独立语句的使用-->前++和后++都是一样的。

 2. 作为表达式（前面有等号的）使用。前++：++i先自增后赋值。后++：i++先赋值后自增。

 3. 作为表达式使用时。先看到什么，左值就是什么。

//比如：
int i=5;
i=i++;
//右边先看到i,则输出时i=5;
//分解成3条语句 int temp = i(temp=5); i = i + 1(i=6);  i = temp;(i = 5)
System.out.println(i);//5
i=++i;
//i= i+ 1(i=6), int temp = i; i= temp;
System.out.println(i);//6

• 取模 [%]：当对一个数取模时，可以等价 a%b=a-a/b*b ， 这样我们可以看到 取模的一个本质运算。取模时，结果的正负与a的正负有关。

//关于自增的一个面试题
int i=1; 
i=i++;   
System.out.println(i);   // 1
int i=1;
i=++i;  
System.out.println(i);  // 2

//关于取模（取余）和除法的一道题目
//定义变量保存 秒数，打印输出 xx小时xx分钟xx秒

        long second=656231;//自定义的秒数
        long hour=second/(60*60);//秒数对应的小时数 -->把目标秒数转换为小时做单位
        long m=(second/60)%60;//这里算的是分钟数，先把目标秒数的单位转换分钟作为单位（除以60），再取模就是分钟数
        long s=second%60;//秒数直接取余
        System.out.println("有"+hour+"小时"+m+"分"+s+"秒");

关系运算符（比较运算符）

• 关系运算符的结果都是boolean型，也就是要么是true，要么是false。
• 关系表达式 经常用在if结构的条件中或循环结构的条件中。
• 关系运算符组成的表达式，我们称为关系表达式。 a > b 。
• 比较运算符“==”不能误写成“=”, 小心。
  

逻辑运算符

• &&短路与：如果第一个条件为false，则第二个条件不会判断，最终结果为false，效率高。
• & 逻辑与：不管第一个条件是否为false，第二个条件都要判断，效率低。
• ||短路或：如果第一个条件为true，则第二个条件不会判断，最终结果为true，效率高。
• | 逻辑或：不管第一个条件是否为true，第二个条件都要判断，效率低。
• ^逻辑异或：相异为1（true）。
• ！取反。

//几道练习题
//1.
int x = 1;
int y=1;
if(x++==2 & ++y==2){
	x = 7;
}
System.out.println("x="+x+",y="+y);//x=2,y=2

//2.
int x = 1,y = 1;

if(x++==2 && ++y==2){
	x = 7;
}
System.out.println("x="+x+",y="+y);//x=2,y=1

//3.
int x = 1,y = 1;

if(x++==1 | ++y==1){
	x =7;
}
System.out.println("x="+x+",y="+y);//x=7,y=2

//4.

int x = 1,y = 1;

if(x++==1 || ++y==1){
	x =7;
}
System.out.println("x="+x+",y="+y);//x=7,y=1

//一道面试题
  class  Test4  {
        public static void main (String []  args)  {
           boolean x=true;
           boolean y=false;
           short z=42;
             if((z++==42)&&(y=true))z++; //这里需要注意的是“=”赋值运算符，而不是“==”判断。
            if((x=false) || (++z==45))  z++; 

           System. out.println(“z=”+z); // z 为?
            }
 }
结果为：46

赋值运算符

• 赋值运算符就是将某个运算后的值，赋给指定的变量。
• 基本赋值运算符“=”
• 复合赋值运算符： “+= ”，“-=” ，“*=” ， “/=” ，“%=”

//有两个变量，a和b，要求将其进行交换，最终打印结果

三元运算符

• 语法：条件表达式 ? 表达式1: 表达式2;
• 如果条件表达式为true，运算后的结果是表达式1；
• 如果条件表达式为false，运算后的结果是表达式2；
• 细节：表达式1和表达式2要为可以赋给接收变量的类型(或可以自动转换)。
• 三元运算符可以转成if–else 语句。

运算符优先级

进制转换

x进制转10进制【乘以10的x次方】

10进制转2进制【8421码】

2进制转8进制和2进制转16进制

• 2进制转8进制：规则：从低位开始,将二进制数每三位一组，转成对应的八进制数即可。
• 案例：请将 ob11(3)010(2)101(5) 转成八进制 —>ob11010101 => 0325
• 2进制转16进制：规则：第低位开始，将二进制数每四位一组，转成对应的十六进制数即可。
  比如：请将 ob11010101 转成十六进制 -->ob11010101 = 0xD5

8进制 16进制转2进制

• 8转2，每位扩展为3位2进制
• 16转2，每位扩展位4位2进制

位运算

• 原码、反码、补码
• 对于有符号的而言：

1. 二进制的最高位是符号位: 0表示正数,1表示负数。
2. 正数的原码，反码，补码都一样 (三码合一)。
3. 负数的反码=它的原码符号位不变，其它位取反(0->1,1->0)。
4. 负数的补码=它的反码+1 。
5. 0的反码，补码都是0。
6. java没有无符号数，换言之，java中的数都是有符号的。
7. 在计算机运算的时候，都是以补码的方式来运算的。
8. 当我们看运算结果的时候，要看原码。

程序控制

顺序结构

分支结构

• if else

//基本语法
/**
if(条件表达式)
*/

//编写一个程序，可以输入人的年龄，如果年龄满足18，则输出“你要对自己的行为负责”

单分支

• 单分支对应的流程图

双分支

单双的练习

//1.声明两个int型变量并赋值。判断两数之和，如果大于等于50，打印“hello world
int a=1;
int b=2;
int sum=a+b;
if(sum >= 50){
System.out.println("hello world");
}

//2.声明两个double 型变量并赋值，判断第一个数大于10.0，且第二个数小于20.0，打印两数之和。
double a=1.0;
double b=2.0;
if(a > 10.0&&b < 20.0){
System.out.println(a+b);
}

//定义两个变量int,判断二者的和，是否能被3又能被5整除，打印提示信息
int a = 10;
int b = 20;
int sum=a + b;


//判断一个年份是否是闰年，闰年的条件是符合下面二者之一
//1.年份能被4整除，但不能被100整除
//2.能被400整除
int year=2020;
if((year %4 ==0 && year%100 !=0)||year % 400 == 0){
System.out.println(year+"是闰年");
}

多分支

• 基本语法

import java.util.Scanner;
//小细节：导包后面用分号结束
public class excer {
	public static void main(String[] args) {
		System.out.print("请输入岳小鹏的成绩：");
		Scanner sc = new Scanner(System.in);
		int score = sc.nextInt();
		if(score > 0 && score <100){
		if (score == 100) {
			System.out.println("BMW");
		} else if (score > 80 && score <= 99) {
			System.out.println("i7");
		} else if (score >= 60 && score <= 80) {
			System.out.println("ipad");
		} else {
			System.out.println("啥都没");
		}
}else{
	System.out.println("数据不正确");
}
	}
}