java基础知识
文章目录
- java基础知识
- 三、java语言基础
- 3.1.java主类结构
- 3.2.基本数据类型
- 3.2.1.整数型
- 3.2.2.浮点型
- 3.2.3.字符型
- 3.2.4.布尔型
- 3.3.数据类型转换
- 3.3.1.隐式转换
- 3.3.2.显式(强制)转换
- 3.4.标识符和关键字
- 3.4.1.标识符
- 3.4.2.关键字
- 3.5.声明量
- 3.5.1.变量
- 3.5.2.常量
- 3.5.3.变量的有效范围
- 3.6.运算符
- 3.6.1.赋值运算符
- 3.6.2.算术运算符
- 3.6.3.自增自减运算符
- 3.6.4.比较运算符
- 3.6.5.比较运算符
- 3.6.6.位运算符
- 3.6.7.位移运算符
- 3.7.三元运算符
- 3.8.运算符优先级
- 3.9.代码注释与编码规范
三、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 |
|
|
|
|
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.9a的值为0.1
b=2-1.9的值为 0.10000000000000009
a=b吗
false使用最小数对比法后,a与b是否相等
true
解析:与1e-6进行比较,比其小,若两个数相减的绝对值
小于理论最小数1e-6则认为这两个数“差”的绝对值等于0,
即这两个数相等
a与b差的绝对值等于?
8.326672684688674E-17c=8.326672684688674E-17的值是否小于理论最小数
true
3.2.3.字符型
- 字符型介绍
存储空间 | 缺省值 | 符号 | |
字符型 | 16位 | ‘\u0000’ | ‘’ 、 “” |
举例 | 字符A | 字符串A |
|
注解 | 双引号代表字符串 |
- 同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
- 转义字符
- 反斜杠
\
符号 | 含义 |
| 单引号 |
| 双引号 |
| 反斜杠 |
| 垂直制表符,相当于tab键 |
| 回车 |
| 换行 |
| 退格 |
| 换页 |
| 表示八进制或十六进制数 |
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.隐式转换
隐式转换,别名自动转换,顾名思义,自动执行,无需人为干预,低级数据类型自动向高级类型转换
隐式转换
byte
short
int
long
float
double
char
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支持中文,其它的编码方式的话,程序中有中文就会编译时产生乱码
编码
设置编码
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; | √ | 不建议使用,虽然不报错、无语法错误,但是容易产生 |
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
javadoc
下一步
规范
- 每条语句单独占用一行,每条命令一个分号结束
- 声明变量时,尽量每个变量的声明单独占用一行,即使相同的数据类型也要单独占用一行,便于进行注释
- 局部变量应在其声明时进行初始化
- 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文档
文件
导出
java
javadoc
下一步- [外链图片转存中…(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软件,电脑和手机版配合使用