java第二天——java基本语法

java语言的基本语法

一、关键字

概念:被java赋予特定含义的单词:
高级记事本:notepad++,editplus等等这些工具对关键字有特殊的颜色标记
开发工具:eclipse,myeclipse也是对关键字有特殊颜色标记
组成关键字:字母全小写
eclipse:
alt+/:自动提示,代码补全:神键
复制代码:ctlr+alt+向下方向键
删除代码:选中代码:ctrl+d
注释:多行注释:ctrl+shift+/
单行注释:选中:ctrl+/
/*public class HelloWold{
* public static void main(String[] args){
* System.out.println(“helloworld”);
*}
*}
*/

二、标识符

是一种规则：给包,类名,接口,方法,变量起名字的字符序列!
组成规则:
1)英文大小写字母
2)数字字符
3)_和$组成
给类,接口,变量,方法命名要遵循四个字:见名知意
如：Student:学生
1)包(目录)的命名:不管是单级包还是多级包:字母全都小写
写法:公司域名的反写(后面在跟上哪个部门)
单级包:
举例:
org
java的源文件…
多级包:
org.westos
org
westos
java的源文件..
2)类和接口的命名:
单个单词:首字母大写,其余小写
举例:Demo
多个单词:每个单词的首字母都大写,其余小写
举例:HelloWorld
3)给变量和方法的命名:
单个单词:字母全部小写
举例:main():程序的主入口 求两个数据之后:sum()
多个单词:第一个单词字母全部小写,从第二个单词开始,每个单词的首字母都大写,其余小写
举例:checkUserName(),checkPassword()
4)常量的命名:
单个单词:字母全部大写
举例:HELLO
多个单词:字母全部大写,每一个单词和单词之间用下划线隔开
举例:HELLO_WORLD
注意事项:
1)不能出现java中的关键字
2)不能以数字开头
3)java严格区分大小
/*public class MakeNameDemo {
* public static void main(String[] args) {
* //定义变量
* int a = 10 ;
* //不能以数字开头
* // int 1b = 20 ;
* //不能是java中的关键字
* // int class = 20 ;
* // int Class = 20 ;
* }
* }
*/

三、常量

在程序的执行过程中,其值不发生改变的量。
常量的分类:
1:字面值常量
a:字符串常量:使用双引号括起来的内容:
“helloworld”,”我爱java”….
b:字符常量:使用单引号括起来的单个字母或者数字
‘A’,’a’,’0’
‘ab’:错误的写法
c:整数常量:
100,1000
d:小数常量
3.1415926…
e:布尔常量:
true或者false
f:空常量:
null
2:自定义常量(与关键字:final有关:面向对象部分讲解)
public class ConstantDemo {
public static void main(String[] args) {
//字符串常量
System.out.println(“helloworld”);
//字符串 +(拼接符号) 任何数据 = 字符串
System.out.println(“helloworld”+’a’+1); //helloworlda1
System.out.println(‘a’+1+”helloworld”); //98helloworld
System.out.println(“5+5=”+5+5); //5+5=55
System.out.println(5+5+”=5+5”); //10=5+5
//字符常量
//不参与运算
System.out.println(‘A’);
System.out.println(‘a’);
System.out.println(‘0’);
//当字符参与运算的时候,就需要带ASCII码表中找字符对应的值
//’A’—->65
//’a’—->97
//’0’—->48
System.out.println(‘A’+1); //66
System.out.println(‘a’+1); //98
System.out.println(‘0’+1); //49
//整数常量
System.out.println(100);
//小数常量
System.out.println(3.1415926);
//布尔常量
System.out.println(true);
System.out.println(false);
//空常量
String s = null ; //针对引用类型
System.out.println(s);
}
}
3、进制转换：0b100表示二进制，0100表示八进制，100默认表示十进制，0x100表示十六进制

4、任意进制转换成十进制
位权展开式=系数*基数的全次幂
如：0b100=1*2^2+0*2^1+0*2^0=4
0100=1*8^2+0*8^1+0*8^0=64
100=1*10^2+0*10^1+0*10^0=100
0x100=1*16^2+0*16^1+0*16^0=256

5、十进制到任意进制的转换

//0b100,0100,0x100计算分别对应的十进制是多少？
//在工具中求进制的转换,必须jdk是1.7以上的包含1.7
public class JinZhiDemo {
public static void main(String[] args) {
System.out.println(0b100);
System.out.println(0100);
System.out.println(100);//默认十进制
System.out.println(0x100);
}
}

四、变量

DataTypeDemo 01

在程序的执行过程中,某一个范围内其值发生改变的量!
对于变量的数据类型的分类:
/*java高级特性:
* jdk5.0以后的新特性:
* 自动 拆装箱
* int基本数据类型—->引用类型:Integer —->valueOf()
* Integer f1 = 100;===>Integer f1 = new Intger(100) ;
* Integer f2 = 100 ;
* Sop(f==f2) ; true
* Integer b1 = 150 ;
* Integer b2 = 150 ;
* Sop(b1==b2);false
* char基本数据类型—>引用类型:Character
*1、:基本数据类型:
* 4类8种
*a:整数类型:整数类型默认该类型
* byte:字节类型——–占用1个字节——取值范围：-128~127—–8bit
* short:短整型 ——-占用2个字节——16bit
* int:整数类型默认该类型 ——占用4个字节——32bit
* long:长整型——占用8个字节——-64bit
* b:浮点类型:默认double类型
* 单精度:float类型——- 占用4个字节
* 双精度:double类型——占用8个字节
* c:字符类型:
* char类型—–占用 2个字节
* d:布尔类型(逻辑判断上)
* boolean 1
* 布尔类型默认值:false
* 2、引用类型(面向对象讲)
* 数组也是引用类型
* 对于整数类型:
* 默认的类型:int类型
* 使用long类型定义变量,在当前变量值的后面加上L或者l(推荐使用L),告诉系统我定义的是一个long类型
* 浮点类型:默认双精度:double
* 定义float类型,在该变量值的末尾跟上F或者f
* */
public class DataTypeDemo {
public static void main(String[] args) {
//byte类型
byte b = 100 ;
System.out.println(b);//100
//短整型
short s = 20 ;
s = 50 ;
System.out.println(“s:”+s);//s:50
// int i = 1000000000000;
// System.out.println(“i:”+i);//定义类型错误，不能生成.class文件。
long l = 1000000000000L;
System.out.println(“l:”+l);/l:1000000000000
//浮点类型:默认double类型
double d = 12.56 ;
System.out.println(“d:”+d);//d:12.56
//单精度
float f = 12.34F ;
System.out.println(“f:”+f);
//由于浮点类型存储和整数类型的存储不一致.导致:永远是一个近似值:BigDecimal
// System.out.println(1.0-0.32);//0.6799999999999
//char类型
char ch = ‘A’ ;
System.out.println(ch);
//boolean类型
boolean flag = true;
System.out.println(flag);//true
}
}

---

DataTypeDemo 02

---

/*
* 定义变量的注意事项:
* 1)在java中,定义一个变量不能重复定义
* //javascript:web前端 定义变量可以重复定义,后面定义的变量会覆盖前面定义的变量
* 2)建议不要再同一行上定义多个变量
* 3)定义变量不能以数字开头
*
* */
public class DataTypeDemo2 {
public static void main(String[] args) {
//定义变量
int a = 10 ;
// int a = 20 ;同一个变量只能定义一次，可多次赋值
a = 20 ;

//一行定义多个变量,中间用逗号隔开
// int m = 10 ,n = 20 ,x = 30 ;
int m = 10 ;
int n = 20 ;
int x = 30 ;
//不能以数字开头
// int 2z = 40 ;
}
}

DataTypeDemo 03

/*
* 对变量进行数据操作的时候,比如求和,这几个数据的数据类型应该一致!
* 面试题:
* 面试题
byte b1=3,b2=4,b;
b=b1+b2;
b=3+4;
哪句是编译失败的呢？为什么呢
第一句编译失败:存在默认类型转换,如果想让改代码不报错,正常运行,必须强制类型转换
强制类型转换的格式;
目标数据类型 变量名 = (目标数据类型)(值);
强制类型转换的缺点:
会损失精度,不建议强制类型转换!
默认类型提升:
byte,short,char之间不转换,但是一旦参与运算
先提升—>int—>long—>float—>double
第三句话:b = 3 + 4 ;属于常量相加,先相加—->看结果是否在当前该数据类型范围内,在就不会报错!
* */
public class DataTypeDemo3 {
public static void main(String[] args) {
byte b1 = 3,b2 = 4 ,b ;
// b = b1 + b2 ;//错误的:byte类型不可能接收一个int类型的值
b = (byte)(b1 + b2) ;//强制类型转换
b = 3 + 4 ;
System.out.println(“b:”+b);//b:7
}
}

DataTypeDemo04

/*
* 面试题
byte b = 130;有没有问题?
如果我想让赋值正确，可以怎么做?结果是多少呢?
有问题:超出范围:byte的取值范围:-128~127
想让 赋值正确,就必须强制类型转换,结果-126
* */
public class DataTypeDemo04 {
public static void main(String[] args) {
//定义变量
byte b =(byte)130 ;
System.out.println(“b:”+b);
}
}
/*
* 130看成四个字节:默认int类型
* 计算出对应的二进制数据
* 00000000 00000000 0000000 10000010
* 最高符号位是0,当前整数,该数据对应的原码,反码,补码都一样
* 计算机底层是通过补码进行运算:byte b = (byte)130;
* 10000010(补码)—–>原码
* 最高符号位—–数值位
* 1 —–0000010—–补码
* 1 —–0000001—–反码 —>最高符号位不变,数值位按位取反
* 1 —–1111110
* 结论:
* - 64+32+16+8+4+2
* - 126
* 即-126
* */

---

五、算术运算符

*java中的运算符:
1)算术运算符
2)赋值运算符
3)比较(关系)运算符
4)逻辑运算符
5)位运算符
6)三元(三目)运算符*
1、 算术运算符
基本的算术运算符:+,-,*,/,%(取余数)
默认取整
public class OperatorDemo 01{
public static void main(String[] args) {
//定义两个变量
int x = 3 ;
int y = 4 ;
System.out.println(x+y);//7
System.out.println(x-y);//-1
System.out.println(x*y);12
System.out.println(x/y);0
//想让当前结果计算具体的小数,分子都可以乘以浮点类型的数据
System.out.println(x*1.0/y);//0.75
System.out.println(x%y);3
}
}
2、扩展的算术运算符
++或者- -:循环语句中使用
应用场景:
1)单独使用:不管是++或者- -在数据前还是数据后都是自增1或者自减1
2)参与运算使用:
a:++,- -在数据的前面,先自增1或者自减1,然后在运算(赋值)
b:++,- -在数据的后面.先运算(先赋值),然后自增1或者自减1
public class OperatorDemo02 {
public static void main(String[] args) {
//定义两个变量
int x = 3 ;
int y = 4 ;
//进行++,- -之前
System.out.println(“x:”+x);
System.out.println(“y:”+y);
System.out.println(“—————”);
//单独使用
//++,- -在数据前面
// ++x ;
// - -y ;
//++,- -在数据后面
// x++;
// y- -;
//参与运算
// int c = ++x ;
// int d = - -y ;
int c = x ++;
int d = y - - ;
System.out.println(“x:”+x);//4,4
System.out.println(“y:”+y);//3,3
System.out.println(“c:”+c);//4,3
System.out.println(“d:”+d);//3,4
}
}
3、/*
* 关于+的应用:
* 1)作为一个运算符
* 2)表示一个数据是正数
* 3)字符串拼接符
* */
public class OperatorDemo3 {
public static void main(String[] args) {
int a = 10 ;
int b = 20 ;
System.out.println(a+b);
System.out.println(+10);//正数
System.out.println(“hello”+’A’+1);//helloA1
//字符串在前，则+为拼接符。
System.out.println(‘0’+1+”hello”);//49hello
}
}

六、赋值运算符

1、/*基本的赋值运算符:=
* 表达的意思:等号右边的数据赋值左边的变量
* 扩展的赋值运算符：
* +=，-=，*=，、=，%=
* 举例：+=
* 表达的意思：将当前符号右边的数据和左边的数据相加赋值给左边的数据
* */
public class OperatorDemo 01{
public static void main(String[] args) {
//定义变量
//1)给定初始化值
int a = 10 ;
//2)先定义,使用该变量之前必须赋值,否则报错
// int b ;
// System.out.println(b);//当前该变量没有被赋值
System.out.println(a);
int m = 100 ;
m += 200;//相当于m = m + 200 ;
System.out.println(“m:”+m);//m:300
}
}
2、面试题：
short s=1;
s = s+1;
short s=1;
s+=1;
上面两个代码有没有问题，如果有，哪里有问题。

第一个有问题:
byte,short,char三者之间不转换,一旦参与运算先转换为int类型
需要强制类型转换
s = (short)(s+1) ;

第二个没有问题:
对于扩展的赋值运算符:隐藏了默认的强制类型转换
s += 1 不等价于s = s + 1
等价于 s = (short)(s+1);
public class OperatorTest {
public static void main(String[] args) {
//定义变量
// short s = 1 ;
// s = (short) (s + 1) ;
short s = 1 ;
s += 1 ;
System.out.println(s);
}
}

七、比较运算符

关系运算符:<,>,<=,>=,==,!=
符号连接的表达式结果都是boolean类型
public class OperatorDemo {
public static void main(String[] args) {
//定义变量
int x = 3 ;
int y = 4 ;
int z = 3 ;
//== 不能写出=
System.out.println((x+y)==(x+z));//false
System.out.println((x+y)==(y+z));//true
System.out.println(x!= y);//true
//定量两个变量
int a = 10 ;
int b = 20 ;
boolean flag = (a==b) ;
// boolean flag = (a=b) ;导致类型不匹配
}
}

八、逻辑运算符

1、逻辑运算符:
通过逻辑符号来连接boolean的表达式或者值;
逻辑运算符中基本的运算符:
public class OperatorDemo {
public static void main(String[] args) {
//定义三个变量
int a = 3 ;
int b = 4 ;
int c = 5 ;
//逻辑单与:&(并列,并且的意思)
// 特点:有false,则false
System.out.println((a>b) & (a>c));//false
//逻辑单或:|
//特点:有true,则true
System.out.println((a>b) | (a>c));//false
//逻辑异或:^
// 特点:相同则为false,不同则为true(简单记:(男女关系)男男 女女 男女 女男)
System.out.println((a>b) ^ (a>c));//false
//逻辑非:!
//非false,则true,非true则false;偶数个非是该数据本身的boolean类型的值
System.out.println(!(a>b));//true
System.out.println(!!(a>b));//false
2、扩展的逻辑运算符:(实际开发中)
逻辑双与:&&
逻辑双或:||
重点： 逻辑双与&&和逻辑单与& 的区别 (逻辑双或||和逻辑单或|)?
共同点:都是并且的意思,双与&&和单&的特点:有false,则false
最大的区别:逻辑双与&&连接的左边的表达式如果是一个flase,则右边的表达式不执行,具有短路效果
逻辑双或||:
如果左边的表达式是true,则右边不执行!,具有短路效果!
public class OperatorDemo2 {
public static void main(String[] args) {
int a = 3 ;
int b = 4 ;
int c = 5 ;
//逻辑双与:&&:有flase则false
System.out.println((a>b) && (a>c));//false
int x = 3 ;
int y = 4 ;
// boolean flag = (((++x)==4) && ((- -y)==5));
boolean flag = (((++x)==3) && ((- -y)==5));
//左边表达式是false,则右边不执行!
System.out.println(“x:”+x);//x=4,y=4
System.out.println(“y:”+y);//x=3,y=4
System.out.println(“flag:”+flag);//false,false
}
}

九、位运算符

一、位运算符:
位与:&
位或:|
位异或:^
~:反码
<<,>>,>>>
public class OperatorDemo {
public static void main(String[] args) {
//位运算符
System.out.println(3 & 4);
System.out.println(3 | 4);
System.out.println(3 ^ 4);//(位异或:重点)
System.out.println(~3);
}
}
/*
* 计算出int类型3和4对应的二进制数据
* //3
* 00000000 00000000 00000000 00000011
* //4
* 00000000 00000000 00000000 00000100
*1、位与:&
* 特点:有0则0
* 00000000 00000000 00000000 00000011
* 00000000 00000000 00000000 00000100
* ——————————————————-
* 00000000 00000000 00000000 00000000
* 结果：0
*2、 位或|:
* 特点:有1,则1
* 00000000 00000000 00000000 00000011
* 00000000 00000000 00000000 00000100
* ——————————————————-
* 00000000 00000000 00000000 00000111
* 结果:7
*
* 3、位异或:^
* 特点:相同则为0,不同则为1
* 00000000 00000000 00000000 00000011
* 00000000 00000000 00000000 00000100
* ——————————————————
* 00000000 00000000 00000000 00000111
* 结果:7
*
* 4、反码:~
* 特点:按位取反(底层对补码进行按位取反)
* 00000000 00000000 00000000 00000011 原码,反,补
* ~ ————————————————–
* //先求出补码，然后按位取反（符号位也取反），之后减1，再按位取反（符号位不变）
* 最高符号位——数值位
* 1——1111111 11111111 11111111 11111100(补码)—>原码
* 最后一位 -1
* 1—— 1111111 11111111 11111111 11111011 —>反码
* 1—— 0000000 00000000 00000000 00000100
* - 4
* 结果:-4
* /
二、重点
位异或的另一个特点:一个数据被另一个数据位异或两次,结果是该数据本身!
public class OperatorDemo2 {
public static void main(String[] args) {
//定义两个变量
int a = 10 ;
int b = 20 ;
System.out.println(a ^ b ^ b);
//10
System.out.println(a ^ b ^ a);
//20
}
}
三、移位
/*<<:左移,最左边的最高符号位丢弃,右边补齐0
*>>:右移,最高符号位为0,左边补0,最高符号位为1,左边补齐1
*>>>:无符号右移:不管最高符号位是0还是1,左边补齐0
*
* 面试题:
* 请用最有效的方式计算出2*8的结果;
* 2<<3
*
* */
public class OperatorDemo3 {
public static void main(String[] args) {
//特点:该符号左边的数据*2的移动次幂
//3 * 2^2
System.out.println(3<<2);//12
//特点:该符号左边的数据除以2的移动次幂
System.out.println(24>>2);//6
System.out.println(-24>>>2);//1073741818
}
}
/*
* 面试题:
* 定义两个变量并且赋值,让这两个变量的值进行交换(面试官想问的:能否使用位异或的特点解决)
* */
public class OperatorTest {
public static void main(String[] args) {
//定义两个变量
int a = 10 ;
int b = 20 ;
System.out.println(“交换前的a:”+a);//交换前的a：10
System.out.println(“交换前的b:”+b);//交换前的b：20
// //实现方式1:实际开发中,使用第三方变量:开发中使用
// int temp = a ;//temp=10
// a = b ;//a=20
// b = temp ;//b=10
//方式2:位异或的特点:一个数据被另一个数据位异或两次,值是它本身
//等号左边:a,b,a
//等号右边:a^b
// a = a ^ b ;
// b = a ^ b ;// a ^ b ^ b= a
// a = a ^ b ; //a ^b ^ a = b
//方式3:使用变量的相加或者相减
a = a + b ;// a = 30
b = a - b ;//b = 30 - 20 = 10 ;
a = a - b ;//a = 30 - 10 = 20 ;
System.out.println(“交换后的a:”+a);//交换后的a：20
System.out.println(“交换后的b:”+b);//交换后的b：10
}
}

十、三元（三目）运算符

/*
* 单目运算符:~3
* 双目运算符:3+4
* 三元运算符：
* 格式:
* (表达式)? true的结果 : false的结果;
* 执行流程:
* 如果表达式成立,执行true的结果
* 如果表达式不成立,执行false的结果;
*
* */
public class OperatorDemo {
public static void main(String[] args) {
//求两个数据是否相等
int a = 100;
int b = 200 ;
//用三元运算符实现
// boolean flag = (a==b) ? true : false;//==表示两个数据进行比较
// System.out.println(“flag:”+flag);//false
//优化改进
boolean flag = a==b ;
System.out.println(flag);
//求两个数据中的最大值
//先定义变量max
int max = (a>b) ? a : b ;
System.out.println(“两个数据中的最大值是:”+max);//200
//求三个数据中的最大值
int m = 10 ;
int n = 50 ;
int z = 20 ;
//可以使用中间第三方变量进行实现,实际开发中就使用第三方进行实现
// int temp = (m>n) ? m : n ;
// //定义max2
// int max2 = (temp > z) ? temp : z ;
//一步走:
int max2 = (m>n) ? ((m>z)? m: z) : ((n>z)? n: z) ;//不建议使用
System.out.println(“三个数据中的最大值是:”+max2);//50
}
}
//（表达式）？true的结果：false的结果；

十一、键盘录入

package 11.org.westos键盘录入;
//导包
import java.util.Scanner ;
/*
* 为了使我们的数据更符合开发的数据,并且灵活性引入键盘录入
* 键盘录入数据的开发步骤:
* 只要不是java.lang包下的类都需要导包
* A:创建键盘录入对象:Scanner类: java.util包下的类
* 固定格式:
* sc:对象名
* Scanner sc = new Scanner(System.in);
* //实质还是通过IO流实现的(java高级特性)
* B:导包:位置:class和package中间
* import java.util.Scanner;
* C:录入数据:使用对象名调用方法
* int a = sc.nextInt();
* D:输出
*
* */
public class ScannerDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//录入数据
//提示
System.out.println(“请您输入一个数据:”);
int a = sc.nextInt();
//输出
System.out.println(“您输入的数据是:”+a);
}
}
//源代码
//package 02.org.westos键盘录入;
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println(“请输入一个数据：”);
int a=sc.nextInt();
System.out.println(“您输入的数据是：”+a);
}
}
//请输入一个数据：
//10
//您输入的数据是：10