Java语言基础_003

java基础知识

三、java语言基础

3.1.java主类结构

• Java基本组成单元是类，若干个类组成Java程序

• 每一个Java程序必须包含一个main()方法，含main（）方法的类叫做主类

• 包声明：说明当前的类处于哪个包

• 类体

  • 属性
  • 方法
  • 属性方法参考第七章(请点击)

• 声明成员变量和局部变量

  • 全局（成员）变量，类的属性
  • 局部变量，方法的属性

• 主方法

  • main()方法，类的主方法，程序的开始{和结束}
  • public，main（）方法的权限修饰符
  • static，main（）方法的静态修饰符
  • void，main（）方法的返回值修饰符
  • Java程序中main（）方法必须声明为public static void
  • String[ ]args，main（）方法的参数，一个字符串类型的数组

3.2.基本数据类型

3.2.1.整数型

• 表示方法

  • 十进制
    • 除“0”以外，不可以以“0”作为其其它十进制数的开头
    • 可使用范围0----9
    • Java编程最常用的进制
  • 八进制
    • 必须以“0”作为开头
    • 可用范围0—7
    • 028不是八进制，属于非法数据
  • 十六进制
    • 必须以“0X或0x”开头
    • 0x25=37，另一种表示25H
    • 可使用范围，0x 0X后面跟多个0–9或者A—F或者a—f

• 知道有这么回事就行，在实际操作中，只用电脑自带的计算机进行进制转换，没必要硬性要求掌握进制具体怎么转换，会各种进制转换自然更好

  

  选择程序员，进行进制转换

练习：将其它进制转换为十进制

public class Demo{
    public static void main(String args[]){
        int a=33;
        int b=033;
        int c= 0x33;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        
    }
}

• 分类

  • byte

    • 内存空间：1字节，8位
    • 范围：-128~127
    • 缺省值(默认值)：0

  • short

    • 内存空间：2字节，16位
    • 范围：-32768~32767
    • 缺省值：0

  • int

    • 内存空间：4字节，32位

    • 范围：-21,4748,3648~21,4748,3647

      ​ -21亿~21亿

    • Java的整型默认类型

    • 缺省值：0

  • long

    • 内存空间：8字节，64位
    • 使用时在数字后面加上L或l，否则就是默认的int，在超出int范围时，会产生数据溢出，导致数据不准确
    • 如：Long a=23448147858L或Long a=76723483548l

范围：-9223372036854775808~92233772036854775807

反正几乎无限小和无限大了，不要去记到底是多少

记忆：从byte到long，依次2倍增加，1字节、2字节、4字节、8字节

注意：

• 不管在操作系统下，遵循位不变原则，体现出平台无关性
• 也就是数据基本类型在linux /mac /win/手机，其存储空间的位数不变

练习：数据溢出/精度丢失?

解决：加上相应的标识符，对数据进行标识

package jiaocai;
//精度溢出，赋值变量时注意后缀，不加就是默认的int 型

public class test2 {

	public test2() {
		// TODO 自动生成的构造函数存根
	}

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		long a=123456789*987654321;
/*未在后面加上后缀，123456789*987654321整型x整
型结果为整型，但结果明显是超出了整型的最大范围，
导致结果失真，成为了一个负数，并将这个负的结果
赋值给了一个long型的变量a,故a的结果为负数,
这个结果肯定错误，常识:正数x正数怎么会是负数?*/
		long b=123456789L*987654321L;
        //加上对应的后缀
		System.out.println(a);
		System.out.println(b);
		
		
	}

}

3.2.2.浮点型

根本原因：在Java中属于近似值，隐患近似值不准确

• 浮点型介绍

浮点型	存储空间	缺省值	默认	表示符
float	32位	0.0	否	F / f
double	64位	0.0	是	L / l

浮点型	数据范围
float	1.4E-45 ~ 3.4028235E38
double	4.9E-342 ~ 1.797693157E308
注解	E或者e代表数学的 x10
注解	在使用float是必须用F或者f进行表示，否则报错，而double型可以不用，因为默认的浮点型就是double

1E23 等价于 1x10^23

2e-34 等价于 2x10^-34

练习：浮点值不准确及其处理办法？

package jiaocai;
//浮点值是近似值，不准确与解决办法
//Math.round(duixiang)

public class test3 {

	public test3() {
		// TODO 自动生成的构造函数存根
	}
public static void main(String [] args) {
	double a=4.35*100;
	System.out.println(a);
	//输出的值明显错误，财务处理的大问题
	double b=4.35*100;
	System.out.println(Math.round(b));
	//Java中的四舍五入法
}
}

练习： 0.1==2.0-1.9 ？

• Math.abs(a-b)
  • 取a-b得绝对值

package jiaocai;
/**
理论最小数的作用:
与1e-6进行比较，比其小，若两个数相见的绝对值
小于理论最小数1e-6则认为这两个数“差”的绝对值
等于0，即这两个数相等
(Math.abs(a-b)<1e-6)，若结果为TRUE则，a=b
否则，a！=b
*/

public class test4最小数对比法 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		double a=0.1;
		double b=2-1.9;
		System.out.println("a=0.1\n"+"b=2-1.9\n");
		System.out.println("a的值为"+a);
		System.out.println("b=2-1.9的值为\n"+b);
		System.out.println("a=b吗\n"+(a==b));
		//输出结果为布尔型的false，说明a!=b,显然违背常识
		//解决Math.abs(a-b)<1e-6
		System.out.println("使用最小数对比法后，a与b是否相等\r"+(Math.abs(a-b)<1e-6));
		//结果为TRUE，说明两个数相等
		System.out.println("解析：与1e-6进行比较，比其小，若两个数相见的绝对值小于理论最小数\r\n"
		+ "1e-6则认为这两个数“差”的绝对值等于0，即这两个数相等");
		/**
		 * 解析：与1e-6进行比较，比其小，若两个数相见的绝对值小于理论最小数\r\n"
		       + "1e-6则认为这两个数“差”的绝对值等于0，即这两个数相等
		 */
		System.out.println("a与b差的绝对值等于？\n"+(Math.abs(a-b)));
		double c=8.326672684688674E-17;
		System.out.println("c=8.326672684688674E-17的值是否小于理论最小数\n"+(c<1e-6));
	}

}

结果：

a=0.1
b=2-1.9

a的值为0.1
b=2-1.9的值为 0.10000000000000009
a=b吗
false
使用最小数对比法后，a与b是否相等
true
解析：与1e-6进行比较，比其小，若两个数相减的绝对值
小于理论最小数1e-6则认为这两个数“差”的绝对值等于0，
即这两个数相等
a与b差的绝对值等于？
8.326672684688674E-17
c=8.326672684688674E-17的值是否小于理论最小数
true

3.2.3.字符型

• 字符型介绍

	存储空间	缺省值	符号
字符型	16位	‘\u0000’	‘’ 、 “”
举例	字符A 'A'	字符串A"A"	'8'
注解		双引号代表字符串

• 同C语言。将字符作为整数对待，但Java采用unicode（无符号编码），可存储65536（0x0000 ~ 0xffff）个字符，几乎可以处理所有国家的语言文字

练习：使用常规字符赋值法和整型进行赋值

因字符可以根据Unicode表进行相互转换，故字符的四则运算指的是对应的Unicode之间的运算

package jiaocai;

public class test5字符8与数字8 {
	public static void main(String[]args) {
		System.out.println('8');
		//输出的虽然是8，但确实字符8
		System.out.println(8);
		//普通的十进制数字8
		System.out.println(8*2);
		System.out.println('8'*2);
		//字符在进行数学运算时，自动将字符转换为相应的unicode码，然后计算
		int a='8';
		System.out.println("字符8对应的unicode码是"+a);
	
	}

}

结果：

8
8
16
112
字符8对应的unicode码是56

package jiaocai;
/*字符的赋值可以直接赋值字符，
 * 也可以使用相对应的unicode
 */

public class test6字符的两种赋值方法 {

	public static void main(String[] args) {
		
		// TODO 自动生成的方法存根
		char a1='a';
		char b1='汉';
		char c1='2';
		System.out.println("第一种赋值方法");
		System.out.println(a1);
		System.out.println(b1);
		System.out.println(c1);
		char a2=97;
		char b2=27721;
		char c2=50;
		System.out.println("第二种赋值方法");
		System.out.println(a2);
		System.out.println(b2);
		System.out.println(c2);
	}

}

• 第一种赋值方法
  a
  汉
  2
  第二种赋值方法
  a
  汉
  2

---

• 转义字符
  • 反斜杠\

符号	含义
\'	单引号
\"	双引号
\\	反斜杠
\t	垂直制表符，相当于tab键格子数是8的整数倍
\r	回车
\n	换行
\b	退格
\f	换页
\八进制（3位）或者十六进制（4位）数	表示八进制或十六进制数

package jiaocai;//转义字符的应用效果

public class test7转义字符 {
	public static void main(String[]args) {
		System.out.println("[\']");
		System.out.println("[\\]");
		System.out.println("[\"]");
		System.out.println("[\n]");
		System.out.println("[\101]");
		//八进制表示的字母A
		System.out.println("[a\t]");
		//共有八个格子，a占用一个，后面还有7个
		String b="\101";
		//字符串\101表示的是字符串A，与字符打
		//印效果一样，但却有本质区别
		char c='A';
		//System.out.println(b==c);直接报错，
		//因为字符串A与字符A没有任何可比性
		System.out.println(b);
		System.out.println(c);
	}

}

结果：

• [’]
  []
  ["]
  [
  ]
  [A]
  [a ]
  A
  A

3.2.4.布尔型

类型	值	缺省值
boolean	true	false
boolean	false	false

• 注意
  • 布尔型只有两个值true/false
  • 布尔型进制转换为其它数据类型
  • String不是基本数据类型（考点）
  • 布尔型存储空间是多少，并未明确给出，有不少说法，布尔型存储空间1位，理由布尔型经过编译、解释后，最后成为二进制编码是就是0 或 1,就是一位

3.3.数据类型转换

• 原则

• 勿以小杯盛大物

• boolean类型禁止转换为其它数据类型

• 整型、字符型、浮点型在混合运算中自动相互转换，占位小的类型自动转换为占位大的类型

  占位大小：byte short (char) int long float double 小----大

• 在多种数据类型混合运算时，系统首先自动将数据类型转换为占位数最大的那种数据类型，然后再进行运算

3.3.1.隐式转换

隐式转换，别名自动转换，顾名思义，自动执行，无需人为干预，低级数据类型自动向高级类型转换

char与int精度虽然不同，但是在char取值范围内，int与char兼容

练习：低精度向高精度自动转换

package jiaocai;
//低精度向高精度转换永远是成功的，不会产生精度错误

public class test8隐式转化 {		
	//隐式转换也叫自动转换

	public static void main(String[] args) {
		
		// TODO 自动生成的方法存根
		byte a=8;
		//只在低精度byte赋值
		//依次给其它精度更高的进行赋值
		short b=a;
		int c=b;
		long d=c;
		double e=d;
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
		
	}

}

结果：

• 8
  8
  8
  8
  8.0

3.3.2.显式（强制）转换

• 须人为操作，也叫强制转换，可能会导致精度丢失，注意数据范围
• 高精度变量转换为低精度变量，不仅适用于基本数据类型，同样适用于引用类型（类、接口等）
• 作用于除布尔型以外的其它所有基本类型
• 语法（类型名）转换对象

高精度int向低精度byte转换，不可以直接转换，报错了

强制转换后，不会报错，而且结果正确，那是因为100在byte的范围内，强制转换个128试试😄

虽然数据在float范围内，但一样出现精度丢失，数据错误，小数默认double,高精度向低精度准换导致精度丢失

严重失真，129超出了byte的最大范围-128~127,数据越界

Java中涉及byte/short/char,类型的运算，均会把这些转换为int型，整型默认的是int，低精度向高精度，进行隐式转换，然后对int型值进行运算，最后的结果也是int型

class test{
  public static void main(String args[]){
   byte b1=10,b2=20;
   byte b3=b1+1;
//报错，默认为int型，且运算时，b1也
//会转换为int型，即右边结果为一个int型，无法赋
//值给一个byte型的b3，解决办法：byte b3=(byte)（b1+1);
System.out.println(+b3);
b3=b1+b2;
System.out.println(+b3);
//报错,因为b1+b2的结果也是int型，把这样的
//结果赋值给byte型的b3是不可以的，解决办法，同上
//但可能精度上丢失
   }
}

---

package jiaocai;
//高精度转换为低精度，若不再低精度的范围内，
//则会出现数据不准在精度范围内也可能出错

public class test9显式转换 {

	public static void main(String[] args) {
		
		// TODO 自动生成的方法存根
		int a=80;
		byte b=(byte)a;
		System.out.println(b);
		//数据正确，80在byte的（-128~127）
		//范围内，所以int转换为byte成功
		int c=32767;
		byte d=(byte)c;
		System.out.println("结果应该是32767,但事实却是(数值越界溢出)：\n"+d);
		//数据不准，32767不再byte（-128~127）范围内
		float e=(float)3.1415926;
		/*对于浮点型数据，在不使用后缀情况下，
		 * 默认为double型，使用显式转换
		将其转换为float型，虽然3.1415926在
		float的取值范围内，但仍就出现错误（大资金错误报表）
		*/
		System.out.println("结果错误3.1415926变成为：\n"+e);
		int i=(int)e;
		System.out.println("小数点丢失:\n"+i);
	}

}

• 80
  结果应该是32767,但事实却是(数值越界溢出)：
  -1
  结果错误3.1415926变成为：
  3.1415925
  小数点丢失:
  3

3.4.标识符和关键字

3.4.1.标识符

• 概念：就是一个名字，用于标识类名、变量名、方法名、数组名、文件名的有效字符序列，严格区分大小写，Java使用的是Unicode编码，最多可以标识65535个字符，使用字母，符号，中文，日文等多种语言

• 规则

  • 由任意的字母、下划线、美元符号、数字组成
  • 不可以以数字作为开头

• 非法标识符

  • 4word（使用数字开头） String（Java的关键字）
    user name（之间由空格，属于两个单词吗，视为两个字符）

• 合法标识符

  • 

  • 

• 使用中文在JDK环境下不会报错，可以使用，但变量的一旦发生更改，就会出现乱码，故最好不要使用中文标识，因为Java是跨平台语言，故环境很容易发生改变GBK支持中文，其它的编码方式的话，程序中有中文就会编译时产生乱码

• 标识符命名规范

  • 类名：通常用名词，首字母大写，非硬性要求
    • Demo
  • 方法名：通常动词，第一个动词首字母小写，第二个开始的动词首字母大写
    • openDoor
  • 变量名：首字母小写，后续单词首字母大写，以便区分第二个单词开始
    • yanyuName
  • 常量名：所有字母大写
    • PI

  注意：

  1.以上并非硬性要求，而是大家工作时，编写代码时的习俗、习惯、大家都这样写，便于大家交流而已

  2.只要是合法字符并且不是java保留的关键字，那就可以用于类名、方法名、变量名、常量名

3.4.2.关键字

int	public	this	finally	boolean	abstract
continue	float	long	short	throw	throws
return	break	for	static	new	interface
if	goto	default	byte	do	case
strictfp	package	super	void	try	class
else	catch	implements	private	final	char
extends	volatile	while	synchronized	instanceof	double
protecte	protected	transient	String	dafaule	switch

3.5.声明量

3.5.1.变量

变量：告诉编译器变量的数据类型以及需要分配多少空间，存放的数值是多少，程序运行过程中空间内的值是变化的，故称为变量

• 作用域
  • 概念：允许变量起作用的范围

public class V2 {
  static int i=10; 
    //声明类成员变量，作用域整个类，到最后
    public static void main（String args[]）{
       {int k=10;
        System.out.println("i="+i);
        System.out.println("k="+k);}
      System.out.println("k="+k);}
}
//编译会报错，因为最后一行语句中的K是在前面的语句块
中定义的，而最后一行语句在语句块之外，超出了K的作用
域，故报错，但是最后一行的K换成i可以，因为i作用域是
整个类

• 以作用域分类
  • 局部变量
    • 概念:在方法或语句块（两个大括号）中生命的变量{}
    • 作用域:方法内或者语句块内
    • 注意:在声明局部变量时，必须进行初始化，也就是赋初值
  • 类成员变量
    • 概念：在类体中声明的变量
    • 作用域：整个类体
    • 注意：可以不初始化，程序运行时，系统会自动初始化工作，若一致不给值，会根据其数据类型，将赋值相对应的缺省值
  • 方法参数
    • 概念：对应方法的参数，比如main(String args[]),括号里面的就是主方法的参数
    • 作用域：整个方法也就是方法的{}之间
  • 异常处理参数
    • 概念：针对异常进行处理的参数
    • 作用域：异常范围内

比如以下大括号内：

try {
			if(!playType.equals("human")) {
				throw new T8自定义异常("有非人类选手："+playType);
			}
			System.out.println("开始比赛！");
			//异常处理
		} catch (T8自定义异常 e) {
//创建一个“T8自定义异常”的对象e，用来调用成员方法printStackTrace()
// TODO 自动生成的 catch 块
			e.printStackTrace();
    //调用成员方法printStackTrace()
		}

• 变量名
• 为便于操作，存放变量的空间就是变量名，也就是内存地址的别名，第二个身份
• 为便于操作，存放变量的空间就是变量名，也就是内存地址的别名，第二个身份
• 程序运行时将数据加载到内存中，内存通过内存地址查找数据，而内存地址不好记（很不方便记忆），故使用变量名
• 约定:小写字母开头，若有多个单词构成，则从第二个单词开次，每个单词第一个字母大写，以示区分不同的单词,但是类名一般大写字母开头
• 变量值：内存空间的值，可以是声明变量时就赋初始值，也可以先声明变量，后赋初始值
• 语法：数据类型 变量名称=变量值

---

系统内存

• 三个区
• 系统区（OS）
• 系统区（OS）
• 数据区（date）
• 过程：
• 当程序执行时，程序代码会加载到程序区，而数据则会被加载到数据区进行暂时存储，假设两个变量定义在方法体中，当程序加载到程序区执行相对应的程序代码时，会在数据区配置空间给出这两个变量

3.5.2.常量

概念：

• 程序运行过程中保持不变的量，在程序中值赋值一次

特点：

• 为所有对象共享值时，经常使用，记住共享的概念，以后还会涉及到，后面一个章节，专门讲类和对象中静态（与共享一个意思），比如静态方法，静态变量

• 常量（constant）,也叫“final变量”，用于固定一个数字

约定：非硬性要求，大家的习惯而已

• 常量通常用大写字母，下划线常用于常量名，多个单词之间作为分隔
  GOOD_MOOD
• 当常量作为成员变量时，必须赋予初始值，否则产生编译错误
• 只能赋值一次，二次赋值则会报错
• 

3.5.3.变量的有效范围

变量的生命周期

• 变量定义出来后暂存与内存中，等程序执行到某一点后，变量便会被释放

有效范围

• 程序代码能够访问该变量的区域，超出时则编译出错,基本上以{}区分，作为界限

分类

• 成员变量：类体中的变量，对整个类有效

• 静态变量（类变量）：除了可以在定义它的类内存取，还可以跨类使用，甚至是整个程序中使用

  “类名.静态变量”

  var.static int a=1

• 实例变量：上面的static去掉，其它不变

• 局部变量：类的方法体中，{ }之间的变量只可以在本类的方法体中使用

• 生命周期

  • 取决于方法体是否被调用，当该方法体被调用时，Java虚拟机方法中的局部变量分配内存空间，调用结束后，方法体中局部变量占用的内存释放，局部变量被销毁

• 注意：局部变量可用与成员变量相同，但是成员变量会被暂时隐藏，输出的值以局部变量为准

  public class val{
     static int times=3;
     public static void main(String[]args){
        int times=4;
         System.out.println("times的值为"+times);
        }
  }
  结果为4，因为成员变量暂时被隐藏
  

3.6.运算符

• 定义:一些特殊符号，主要用于数学函数，类型赋值语句，逻辑比较，特定的运算

• 分类

• 功能：算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符、条件运算符、其它运算符

• 操作数：

  • 一元运算符：运算时操作数一个
  • 二元运算符：运算时操作数两个
  • 三元运算符：运算时操作数三个
    • b=条件（布尔式）？变量1：变量2（布尔式结果为真，b=变量1，为假，b=变量2）

3.6.1.赋值运算符

• =表示，是一个二元运算符（对两个操作数处理），将右边包含的值赋值给左边
• 左边:做读写的操作，接受右边赋予的值，必须是一个量，变量或者常量
• 右边：做读取操作，可以是一个数字、字母、公式等，从最右边依次向左边赋值

表达式	含义	备注
int a=1,b=2,c=3;	定义整型变量a,b,c
final int VAL =5;	定义整型常量
a=10;	√	前面已定义类型，无需重复定义
a=b+c;	√	前面已定义类型，无需重复定义
a=b=c=666;	√	不建议使用，虽然不报错、无语法错误，但是容易产生bug
6=c;	×	不能给常量赋值
a+b=c;	×	左边是一个表达式

3.6.2.算术运算符

• +

  • 一元正号
  • 拼接字符串,“hello”+“world”

• -

  • 一元负号
  • 算术减

package jiaocai;

public class test10四则运算 {

	public static void main(String[] args) {
		
		// TODO 自动生成的方法存根
		int a=4,b=5;
		float c=5.5f;
		System.out.println("4加5的值："+(a+b));
		System.out.println("5.5加5的值："+(c+b));
		System.out.println("4减5的值是："+(a-b));
		System.out.println("5除4的值是："+(b/a));
		//求商，小数点的保留与否，取决于原始数据
		System.out.println("5与4取余的值是："+(b%4));
		//百分号是取余，求余数
		System.out.println("5.0/2的值是："+(5.0/2));
		//分子或分母其中一个带小数点，则结果保留小数点
		System.out.println("5/2的值是："+(5/2));
		//分子分母均没有带小数点，结果不带小数点
		System.out.println("5.5乘5的值是："+(b*c));
		System.out.println("5.0乘5的值是："+(5.0*5));
		System.out.println("5乘5的值是："+(b*b));
		//乘法也是遵循与原始数据一致原则
		
	}

}

• 4加5的值：9
  5.5加5的值：10.5
  4减5的值是：-1
  5除4的值是：1
  5与4取余的值是：1
  5.0/2的值是：2.5
  5/2的值是：2
  5.5乘5的值是：27.5
  5.0乘5的值是：25.0
  5乘5的值是：25

3.6.3.自增自减运算符

• 操作数：一个，属于单目运算
• 对象：一个整型或者浮点型（可以隐式转换为整型）
• 分类：根据操作符为位置
  • 至前：先进行自增或自减，在拿去用
  • 至后：先拿去用，在进行自增或自减
  • 

3.6.4.比较运算符

• 属于二元运算符，用于变量之间，变量与自变量之间，以及其它类型信息之间的比较

结果一定是布尔型,true or false

运算符	说明	实例	结果
==	等于	2==3	false
<	小于	2<3	true
>	大于	2>3	false
<=	小于等于	4<=5	true
>=	大于大于	4>=4	true
!=	不等于	2!=3	false

练习：判断奇数偶数

package jiaocai;
//利用取余判断一个数的奇偶性

public class test12奇数偶数的判断 {
	public static void main(String[]args) {
		int a=13,b=20;
		System.out.println(a+"是偶数吗？\n"+(a%2==0));
		System.out.println(a+"是奇数吗？\n"+(a%2==1));
		System.out.println(b+"是偶数吗？\n"+(b%2==0));
		System.out.println(b+"是奇数吗？\n"+(b%2==1));

		

	}

}

• 13是偶数吗？
  false
  13是奇数吗？
  true
  20是偶数吗？
  true
  20是奇数吗？
  false

• 不可以串联使用比较运算符

原因：a<b的结果是布尔型（要么TRUE要么FALSE），布尔型不参与比较运算符

3.6.5.比较运算符

• 逻辑运算符
  • 与
    • &
      非短路运算符，会始终执行&两边的表达式
    • &&
      短路运算符，当判断出第一个表达式false时，直接出结果，省时
      从左往右
  • 或
    • ||
    • 从左往右
  • 非
    • !
    • 从右往左

package jiaocai;

public class test14与或非 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int a=3,b=5;int c=8;
		boolean result1=a<b&&b<c;
		//定义一个布尔型的变量result1
		boolean result2=a>b&&b<c;
		boolean result3=a!=b||b>c;
		boolean result4=b!=c;
		System.out.println(result1);
		System.out.println(result2);

		System.out.println(result3);

		System.out.println(result4);


	}

}

• true
  false
  true
  true

3.6.6.位运算符

位逻辑运算符

• 分类

  • & 与
  • | 或
  • ^ 异或
  • ~ 取反

• 正负号
  取决于左边的最高位，最高位为0则是正数，最高位为1则是负数

• 

• 

• 

上下对应每一列，进行与运算

• 

上下对应的每一列 ' |'

• 

上下对应的进行异或，上下不同则为1，相同则为0

• 

上下对应的列取反，0 1 互相改变，左边的最高位为1，故结果为负数

package jiaocai;

public class test15位逻辑运算符 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int a=12;
		//二进制为0000000000001100;
		int b=8;
		//二进制为0000000000001000;
		int c=a&b;
		//位与运算
		int d=a|b;
		//位或运算
		int e=a^b;
		//位异或运算，异1（对应为不同则为1，否则为0）
		int f=~b;
		//位取反是单目运算符
		System.out.println("有效位对应进行“位逻辑运算”");

		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
		System.out.println("000000001000等价于1000,取反后为0111等价于111,\n"+"最高位为1，故其值为负数,转换为十进制：\n"+f);
//位与、位或、位异或、位取反用于逻辑的运算
		System.out.println("true&false结果为\n"+(true&false));		
		System.out.println("true|false结果为\n"+(true|false));
		System.out.println("true^false结果为\n"+(true^false));
		/*boolean s=true;
		System.out.println("~true结果为\n"+s);*/



	}

}

• 有效位对应进行“位逻辑运算”
  8
  12
  4
  000000001000等价于1000,取反后为0111等价于111,
  最高位为1，故其值为负数,转换为十进制：
  -9
  true&false结果为
  false
  true|false结果为
  true
  true^false结果为
  true

3.6.7.位移运算符

• 对数据按二进制位进行移位操作
• 最高位为0则为正数，最高位为1则为负数
• 移位可以实现整数乘以或除以2^n,y<<2与y*4结果相同，y>>1与y/2的结果相同，前提不出现正负变化

• 左移位

  • <<
    • a<<2
  • 不分正负数进行处理
  • 在最高位不改变的前提下，每左移移位，是原来的二倍
  • 移位时，左边溢出的舍去，舍去几位，便在低位补几个0

• ​
  ​

• 

• 右移位 >>

  • 正数右移
    • 右边的溢出舍去，左边补0，移了几位，补几个0
    • 正数的右移，正负号一定不会改变

• 

  • 负数右移
    • 右边的溢出舍去，为保证数仍为负数，左边补1，移几位补几位

• 无符号右移位 >>>
  • 不考虑符号进行右移，移了几位，左边补几个0
  • 注意：不可以用于低精度的byte short 进行无符号右移，否则精度溢出，比如byte、short型的负数右移一位，本应变为正数，但事实却仍为负数（精度溢出）

package jiaocai;
/*（1）左移多少位，右边补多少0
（2）右移多少位，正数则在左边补多少0，
     负数则在左边补多少1
（3）无符号右移，右移多少位在左边无
     脑补多少0，不考虑正负问题，
     但不可以用于低精度的byte和
     short类型，否则数据溢出*/

public class test16位移运算符 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int a=8;//00001000
		System.out.println("8左移1位结果："+(a<<1));
		System.out.println("8左移2位结果："+(a<<2));
		System.out.println("8右移1位结果："+(a>>1));
		System.out.println("8无符号右移3位"+(a>>>3));
		short b=(short)(-256>>>1);
		System.out.println("-256无符号右移2位"+b);
		/*-256说明最高位为1，无符号右移1位，
		在最高为补0，最高位为0，本应该为正
		数了，但事实却是--128   */
		byte c=(byte)(-32>>>1);
		System.out.println("-32无符号右移1位"+c);




	}

}

• 8左移1位结果：16
  8左移2位结果：32
  8右移1位结果：4
  8无符号右移3位1
  -256无符号右移2位-128
  -32无符号右移1位-16

3.7.三元运算符

• 三元运算符必须有接受返回值的量
  • 语法
    • 三元运算符： 判断公式？结果1：结果2
      格式：返回值=判断公式？结果1：结果2
    • 判断公式
      一个返回布尔值的公式
    • 结果1
      判断公式是true，则返回值为“结果1”
    • 结果2
      判断公式是false,则返回值为“结果2”

int a=1;
int b=a<3?2:3;
若a<3成立，则b=2
			等价于
int a=1;
if(a<3)	{
b=2;
}else{
b=3;
}

在使用时一定要有返回值，把上面的字母b去掉，报错

直接这样输出是可以的，因为此时将三元运算符的结果直接输出，返回值作为方法（输出函数）的一个参数

3.8.运算符优先级

• 

• 

• 

• ​ 14三元运算符 ?:

• ​ 15赋值运算符 =

• 

int  x=1,y=-2,n=10;
求x  +  y  +  (--n)  *  (x>y&&x>0   ?   (x+1):y)的只是int,结果为？  
       1      2      3     4    5     6   7     8      9
解析：（）优先级最大，优先处理    结果17
3--5，7--6--9---4--1--2
x>y和x>0为真，所以x>y&&x>0为真，故条件？为真。为真则执行：前面的（X+1），即2，--n,--在前，先减后用，故--n=9
综上   1+（-2）+9*2=17

3.9.代码注释与编码规范

Java编译器直接忽略注释内容，不参与编译，做到可读性第一，效率第二，程序中的注释一般占20%---50%

作用

• 提高程序可读性便于程序的日后维护和升级
• 规范的编码可以有效的避免一些不必要的错误
• 调试程序时可暂时屏蔽掉某些语句

注释

• 方法

  • 单行：//
  • 多行：/* neirong */
  • 文档注释
    • 方法1：/** 然后回车
    • 方法2：/**
      */两者之间内容均为注释的文档

• 

• 注释文档导出，生成API文档

• 

规范

• 每条语句单独占用一行，每条命令一个分号结束
• 声明变量时，尽量每个变量的声明单独占用一行，即使相同的数据类型也要单独占用一行，便于进行注释
• 局部变量应在其声明时进行初始化
• 
• Java代码中多行空格没有意义，反而带来阅读时的障碍
• 为了方便日后的维护，尽量不使用高技术、难懂、易混淆的语句，因为维护和开发的一般不会是同一个人
• 对于关键方法应多进行注释
• Java俄代码必须在“类”里面，用关键字class定义类
• 严格区分大小写
• 不要出现中文输入法下的分号、逗号，中文英文的标点在Java中的实现方式不同

---

• 注意事项
  • 源文件的组成
    • 使用纯文本编辑器，如记事本或者EditPlus
    • 不可以使用word，因为含有大量无法进行编译的不可见字符
    • 使用Java开发软件
    • 保存时，Java源文件的后缀名必须是 .java
  • 应用程序的主类
    • 一个Java程序必须有一个主类（public修饰的类）
    • public static void main(String args[ ]) 称为：主类
    • args[ ]是main方法的一个参数
    • 主类最多一个，两个主类以上，违规，可以没有主类
  • 命名规则
    • 源文件名一定=类名
    • 只有一个类，源文件名=该类名
    • 多个类名
      • 有主类
        • 源文件名=主类名
      • 无主类
        • 在类中随便选择一个作为源文件名
  • 良好的编程习惯
    • 一行最好只写一条语句
    • 类体用方法的{ }括起，并有明显的缩进

推荐：可以试着使用XMind软件，电脑和手机版配合使用
文档注释
- 方法1：/** 然后回车
- 方法2：/**
*/两者之间内容均为注释的文档

• [外链图片转存中…(img-TUDjGh8X-1646305713066)]

• 注释文档导出，生成API文档

• [外链图片转存中…(img-PXaiSv9b-1646305713067)]

规范

• 每条语句单独占用一行，每条命令一个分号结束

• 声明变量时，尽量每个变量的声明单独占用一行，即使相同的数据类型也要单独占用一行，便于进行注释

• 局部变量应在其声明时进行初始化

• [外链图片转存中…(img-6f83gMbE-1646305713068)]

• Java代码中多行空格没有意义，反而带来阅读时的障碍

• 为了方便日后的维护，尽量不使用高技术、难懂、易混淆的语句，因为维护和开发的一般不会是同一个人

• 对于关键方法应多进行注释

• Java俄代码必须在“类”里面，用关键字class定义类

• 严格区分大小写

• 不要出现中文输入法下的分号、逗号，中文英文的标点在Java中的实现方式不同

• 注意事项

  • 源文件的组成
    • 使用纯文本编辑器，如记事本或者EditPlus
    • 不可以使用word，因为含有大量无法进行编译的不可见字符
    • 使用Java开发软件
    • 保存时，Java源文件的后缀名必须是 .java
  • 应用程序的主类
    • 一个Java程序必须有一个主类（public修饰的类）
    • public static void main(String args[ ]) 称为：主类
    • args[ ]main方法的一个参数
    • 主类最多一个，两个主类以上，违规，可以没有主类
  • 命名规则
    • 源文件名一定=类名
    • 只有一个类，源文件名=该类名
    • 多个类名
      • 有主类
        • 源文件名=主类名
      • 无主类
        • 在类中随便选择一个作为源文件名
  • 良好的编程习惯
    • 一行最好只写一条语句
    • 类体用方法的{ }括起，并有明显的缩进

推荐：可以试着使用XMind软件，电脑和手机版配合使用