Java基础语法
Eclipse IDE 的使用
创建工程
File -> JavaProject -> 写工程名字(授课天数命令) --> Finish 工程创建完毕,可以进行程序的开发
src文件夹, 写类使用的
在src文件夹,鼠标右键 -> new -> class -> name对话框写上类的名字
Eclipse的项目目录结构
默认的情况下,工程都放在了 workspace (工作空间)
工作空间中的文件夹就是在eclipse中的工程的名字
工程目录下:
bin : 存储编译后的可运行文件 class文件 eclipse自动编译
src : 存储是是我们编写的java文件 (源文件)
好处 : 程序是我们写的,源代码是否需要保护, 开发完了,交付使用,直接提供用户 class文件!
Eclipse的字体调整
Ctrl 和加号 以及减号 ,调整字体大小
window -> Rreferences -> General -> App -> color and Fonts -> java -> java Editor Text Font -> edit
Eclipse的窗口设置
package Explorer 包资源浏览器, 管理我们创建的工程,类
Window -> show view -> package Explorer 开启包资源浏览器
Eclipse的界面,混乱 (故意) 恢复到初始化状态
window -> pers -> reset
Eclipse快捷键
万能提示快捷键 alt + / 代码上的自动提示
-
注释的快捷键
单行注释 Ctrl + / 要注释哪行,光标在这行内即可
多行注释 Ctrl + Shift + / 必须要选中注释的行
取消多行注释 Ctrl + Shift + \ 不需要选中哪一行,只要光标在注释内即可
数据类型
注意 : Java语言是强制类型语言. 任何的数据,都是进行严格分类的
方便管理数据,Java语言将数据分成了两大类别.
-
基本数据类型 (四类八种)
-
整型
-
字节型 (关键字 byte)
字节型在内存中,占用1个字节(8个二进制位)
字节型的数据的取值范围 -128 ~ 127
-
短整型(关键字 short)
短整型在内存中,占用2个字节(16个二进制位)
短整型的数据的取值范围 -32768 ~ 32767
-
整型(关键字 int) Java的默认类型
整型在内存中,占用4个字节(32个二进制位)
整型的数据的取值范围 -2147483648~ 2147483647
-
长整型(关键字 long)
长整型在内存中,占用8个字节(64个二进制位)
长整型的数据的取值范围 -9223372036854775808~ 9223372036854775807
-
-
浮点
-
单精度(关键字 float)
单精度浮点在内存中,占用4个字节
单精度浮点的数据的取值范围 1.4E-45~ 3.4028235E38
-
双精度(关键字 double)Java的默认类型
双精度浮点在内存中,占用8个字节
双精度浮点的数据的取值范围 4.9E-324~ 1.7976931348623157E308
-
-
字符 (关键字 char)
类型每次只能存储1个字符
字符型在内存中,占用2个字节 (和short一致)
-
布尔 (关键字 boolean)
布尔类型只有true和false
内存中占1个字节
-
-
引用数据类型 (5种)
数组 (英语 Array)
类 (英语 class 也是关键字)
接口 (英语 interface 也是关键字)
枚举 (英语 enum 也是关键字)
注解 (英语 Annotation)
变量
变量 : 常量是固定不变化, 变量的数据是可以随时改变的, 变量方便进行运算
变量的定义三要素 :
明确数据类型
变量的名字
变量的值
变量定义的格式 :
数据类型 变量名字 = 值
public static void main(String[] args) {
/*
- 定义出所有的基本数据类型变量
- 4类8种
- 定义格式:
- 数据类型 变量名字 = 值
*/
//定义字节型,关键字 byte
byte b = 100;
System.out.println(b);
//定义短整型,关键字 short
short s = 10000;
System.out.println(s);
//定义整型,关键字 int 最常用的类型
int i = 999999;
System.out.println(i);
//定义长整型,关键字 long
//注意 : Java语言,任何整数默认都是int类型
//将整数变成long类型, 数字后面写字母L (不分大小写,建议大写)
long l = 1234567890123L;
System.out.println(l);
//定义浮点数据,单精度 关键字float
//Java中浮点数据,默认是double
//浮点数变成float类型,数字后面写字母F (不分大小写,建议大写)
float f = 3.14F;
System.out.println(f);
//定义浮点数据,双精度 关键字 double
double d = 3.14;
System.out.println(d);
//定义字符类型, 关键字char
char c = '去';
System.out.println(c);
//定义布尔类型,关键字 boolean
boolean bool = true;
System.out.println(bool);
}
变量定义的注意事项
-
变量定义,但是没有赋值,不能使用
public static void main(String[] args) {
int i ;
System.out.println(i);
} 可以先定义变量,再赋值
public static void main(String[] args) {
int i ;
i = 1;
System.out.println(i);
}
-
在同一个大括号内,变量名不能相同
public static void main(String[] args) {
int i ;
i = 1;
System.out.println(i);
int i = 2;
System.out.printl(i);
} 作用范围,变量只能作用在定义的一对大括号内有效,出去大括号无效
变量定义格式补充
先声明变量,后赋值
public static void main(String[] args) {
int a;
a = 1;
//一次定义多个变量名字
int b,c,d,e;
//分别进行赋值
b=1;
c=2;
d=3;
e=4;
//比较恶心
int f = 1, m=2, n,g;
n=1;
g=2;
}
数据类型转换 (有点难)
Java语言是强制类型语言,要求在数据进行运算的时候,必须保证类型的一致性.
如果数据在运算的时候,类型不一致,发生类型转换现象.
所有的基本数据类型中,只有布尔类型不参与转换
自动类型转换
-
转换原则 : 数据类型取值范围小的会自动提升为取值范围大的类型
-
byte -> short -> int -> long -> float -> double
public static void main(String[] args) {
/*- 字节byte和整型int 求和
- byte取值范围小的类型,int取值范围大
- 求和的时候,发生类型的转换!!
*/
byte b = 1;
int i = 2;
int j = b + i; // b+1 类型转换 b转成int
System.out.println(j);
}
类型转换自动.jpg
-
* byte和short的计算,默认转成int
public static void main(String[] args) {
//求和计算
//1 == Java默认int
//1.1 == Java默认double
//1 自动转换double 补: 1.0
double d = 1+1.1; //计算后的最终的类型结果是 double
System.out.println(d);
d = 1+0.0;
System.out.println(d);
/*
* 求和计算,认真思考
*/
byte b = 1;
short s = 1;
//b+s不能运算,数据类型不同,类型的转换,计算结果的数据类型int
//Java规定 : byte short 进行运算,都会自动转成int!!
int k = b+s;
System.out.println(k);
}
* char类型计算的时候,查询ASCII编码表,取出整数进行计算 (转成int类型)
public static void main(String[] args) {
//char 字符类型,内存中占用2个字节
char c = 'a';
System.out.println(c);
//char字符类型,也可以进行计算
//字符char类型计算的时候,转成int类型
//会到ASCII编码表中查询数字出来
System.out.println(c+1);// 98
}
* char类型是否存在取值范围
在内存中,和short占用2个字节 0-65535
强制类型转换
强制 : 程序人员手动的参与转换
强制类型转换 : 取值范围大的类型,转成取值范围小的类型
尽量少做,出现数据精度丢失问题.
-
浮点数,转成整数
- 1.5 转成整数 结果是1,小数部分直接丢弃
-
转换的公式 :
被转换后的类型 变量名字 = (被转换后的类型)要转换的数据;
public static void main(String[] args) {
//浮点数据,转成整数
double d = 1.5;
//d取值范围大的类型,转成int类型 (丢失精度)
//被转换后的类型 变量名字 = (被转换后的类型)要转换的数据;
int i = (int)d;
System.out.println(i);
} -
整数之间的类型转换
public static void main(String[] args) {
byte b = 1;int i = 2;
/*- b 1个字节
- i 4个字节
- b+i 的结果还是4个字节
- 4个字节的结果,复制到1个字节的c中
- b + i 的结果,强制的转成byte类型
- 被转换后的类型 变量名字 = (被转换后的类型)要转换的数据;
*/
byte c = (byte) (b + i);
System.out.println(c);
short s = 1 ;
/*- s + 1 int类型,和short类不能计算
- s 提升为int类型,求和后变成int
- 赋值回变量s ,需要类型的强制转换
- s + 1的结果,强制转换为short
*/
s = (short) (s + 1);
System.out.println(s);
}
public static void main(String[] args) {
/*- 1 是int类型
- int类型, 赋值到byte了呢
- javac 编译器 : .java文件,编译为可以执行的class文件
- 编译的时候,检测1是否超过byte的范围
- 没有超过byte范围, javac帮你将int类型的1,转成byte类型
*/
byte b = 1;
System.out.println(b);
byte b2 = (byte)300; //超过byte范围的300,强制转byte类型
System.out.println(b2);}
计算中,常量是已经确定计算结果,(固定不变)
-
变量,在计算中,不确定结果,运行完毕才可知
short s1 = 1;
short s2 = 1;
/*- s1 + s2 == > 变成int
/
short s3 = (short) (s1 + s2);
System.out.println(s3);
/ - s4 = 1+1 是正确的
- 变量计算和常量计算的区别
- s1 + s2 是变量, 编译的时候javac, 编译器不确定的值是什么
- 求和的结果按照int计算
- 1 + 1是常量,固定不变 javac编译,可以确定计算的结果
- 判断出结果没有超过short范围,不会报错
*/
short s4 = 1 + 1;
System.out.println(s4);
- s1 + s2 == > 变成int
运算符
运算符在程序中作用是数据之间进行运算.运算符分类
算数运算符
-
+ - * / %- % 取模, 计算的结果要余数
赋值运算符
= 符号右边的数据,赋值到左边的变量
-
+= -= *= /= %= 不能分开
public static void main(String[] args) {
int i = 1;
/*- i+1的结果,再赋值变量i
*/
i = i + 1;
System.out.println(i);
/*
- += 赋值运算符
- j+=1; 本质上理解为 j = j+1
*/
int j = 1;
j+=1; // 等价于 j = j + 1
System.out.println(j);
/*
- += 另一个问题
- s += 2; 等价于s = s + 2
- += 是一个符号,运算是一次完成 (javac自动的进行强制转换)
*/
short s = 1;
s += 2;
System.out.println(s);
}
- i+1的结果,再赋值变量i
-
++ 和 --
public static void main(String[] args) {
//++ 符号,含义是变量自增1 -- 变量自减1
int i = 1;
i++;
System.out.println(i);
/*++或者--符号,可以出现在变量的前面或者是后面
/
++i;
System.out.println(i);
/++在前在后的区别
*/
int m = 1;
//++在后面,后运算
//先将m的值,赋值变量n, m自己在增1
int n = m++;
System.out.println(m); //2
System.out.println(n); //1
//++在前面,先运算
//m自己先增1, 增1后的结果,赋值到n
n = ++m;
System.out.println(m);//3
System.out.println(n);//3
}-
++ 和--的结论:
变量只有自己的时候 ++ 写在前还是后没有区别,自己都会增1
-
变量和其他变量做运算
写后面,是先将自己的值赋给其他变量,自己在增1
写前面,先自己增1,增1后赋值另一个变量
比较运算符
比较运算符,是数据之间做比较的,特点:比较运算符的执行结果只能是布尔类型
比较运算符的运算结果,要么是true,要么是false,不会出现其他的结果
== 等等于 比较符号两边的数据是否相等,如果相等,计算结果是true
!= 不等于 比较符号两边的数据是否不相等,如果不等待,结算结果是true
>大于号比较符号左边的数是否大于右边的数,如果大于结果是true<小于号结果略>=大于等于 <=小于等于结果略
逻辑运算符
逻辑的运算符,计算结果也是布尔类型,要么是true,要么是false
& 逻辑与 &符号的两边 一边结果是false,整体运算结果是false,两边都是true,结果是true
| 逻辑或 |符号的两边 一边结果是true,整体的运算结果是true,两边都是false,结果是false
! 逻辑非 ! 取反 true取反变false, false取反变true
-
&& 双与 提高运算效率,和单符号的计算结果无区别
- 高效处理 : 左边是false,右边不计算
-
|| 双或 提高运算效率,和单符号的计算结果无区别
- 高效处理 : 左边是true,右边不计算
public static void main(String[] args) {
//&符号的两边 一边结果是false,整体运算结果是false
System.out.println(2==2 & 2==1);
//System.out.println(false & true );
//|符号的两边 一边结果是true,整体的运算结果是true
System.out.println( 1==1 | 2==3);
//! 取反 true取反变false, false取反变true
System.out.println( !false );
int i = 1;
int j = 1;
System.out.println( i==2 && ++j==2);
System.out.println(j);
System.out.println(i==1 || j==3);
}
位运算符
位运算,数字的二进制位的运算
运算之前,先将数字转成二进制后,才能计算
-
& | ^ << >> >>>
计算过程中,二进制0表示false,1表示true
计算结果,和逻辑运算符一致
^ (异或)相同结果是false,不相同结果是true
<<左移动 >>右移动 数字的二进制进行位置移动
>>>无符号右移动
public static void main(String[] args) {
System.out.println( 6 & 7 );
System.out.println(6 | 7);
// ^异或 计算结果,相同为false,不同为true
System.out.println( 6 ^ 7);
//2 向右移动1位 相当于原数字/2
System.out.println(2 >> 1);
//2左移动2位 相当于原数字*2
System.out.println( 2 << 2);
//无论数据的最高位是1还是0,移动后全部补0
System.out.println(-1 >>> 2);
}
三元运算符
三元又称为三目运算
-
运算符格式 :
布尔表达式?结果1:结果2
public static void main(String[] args) {
//布尔表达式?结果1:结果2
//布尔表达式 : 怎么写都可以,运算结果是true,false即可
//三元运算符的计算结果 : 布尔表达式结果是true,执行结果1,否则执行结果2
int i = 2==2?100:200;
System.out.println(i);
System.out.println(1==2?"等于":"不等于");
//System.out.println(1==1?5:1.0);
}
字符串数据的+计算
字符串和+一起计算, +变成连接作用,失去的求和的含义
计算的结果都是字符串类型.
public static void main(String[] args) {
//"5" 是字符串类型 ,5是int类型
//不计算,遇到字符串, + 变成连接作用
//计算的结果的类型,是字符串
System.out.println("5" + 5);
System.out.println(1+2+"3");
System.out.println(true+"1");
}
Scanner 键盘输入作用
在Java基础阶段 SE技术平台中,是有意义
Scanner是Java中,已经做好的一个类,拿来使用即可
注意 : 使用已经做好的类Scanner,我们自己创建类,类名不能是Scanner
//1: 导入该类所在的包
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
//2: 创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//3: 创建好的对象,调用方法,实现键盘的输入 (整数,字符串)
int i = sc.nextInt();//接收键盘输入,整数
System.out.println(i+1);
}
}
Sacnner接收字符串类型
public static void main(String[] args) {
//Scanner键盘输入字符串
Scanner sc = new Scanner(System.in);
//接收字符串, Scanner类中方法 next()
//String s = sc.next(); //字符串中有空格,空格后面不接收
//接收字符串,Scanner类中方法 nextLine()
String s = sc.nextLine(); //接收一行
System.out.println(s+123);
}
Scanner反复接收数据的问题
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//输入int
int i = sc.nextInt(); // 123 回车
System.out.println(i);
//输入字符串
String s = sc.nextLine();
System.out.println(s);
}
流程控制语句
现在阶段,写的所有程序,都称为顺序解构.程序只能从上向下依次执行.
实现更加复杂的功能,使用流程控制语句
判断语句 if ,选择语句 switch ,循环语句 for while do while
if判断语句
只有一个关键字 if (如果)
格式 :
if(条件的判断){
if语句的执行体
}
条件的判断 : 这里的结果必须是布尔类型
if的语句体 : 如果条件判断的结果是true,执行该语句体,判断的结果是false,什么也不做
- if的语句实现
public static void main(String[] args) {
int i = 1;
//if的判断语句
if( i > 0) {
System.out.println("执行了大括号里面程序");
System.out.println("if的条件判断是true");
}
}
if语句注意事项
if语句是可以省略大括号的 : 0基础,新手,大括号一定要写
如果不写大括号, if判断语句只能控制距离他最近的一行程序!!
public static void main(String[] args) {
int i = 1 ;
if( i == 1)
System.out.println("你好");
System.out.println("我好");
}
if语句: (判断条件) 有一个写法,希望你用, 建议在判断里面,常量写在变量的前面.
public static void main(String[] args) {
//定义布尔类型的变量
boolean bool = false;
//System.out.println(false == false);
if(false == bool) {
System.out.println("if的判断条件是true");
}
}
if...else语句
if是如果,else是否则. 如果怎么样,就怎么样. else语句是不能单独出现,只能跟随if出现
语句格式 :
if(条件判断){
if语句的执行体
}else{
else语句的执行体
}
-
执行流程 :
程序先执行if中的条件判断语句,如果判断语句是true,那么就执行if的语句体
如果if中的条件判断结果是false,那么就会执行else的语句体
-
if语句和else语句,永远不会同时执行,不会都不执行
- if和else每天鸡犬相闻,但是老死不相往来
适合于多个条件的判断