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)
变量
变量 : 常量是固定不变化, 变量的数据是可以随时改变的, 变量方便进行运算
变量的定义三要素 :
- 明确数据类型
- 变量的名字
- 变量的值
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9Iro7xc4-1594120263640)(images/变量定义三要素.jpg)]
变量定义的格式 :
数据类型 变量名字 = 值
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); }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i7pRmZIt-1594120263642)(images/类型转换自动.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 }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M8oRQIst-1594120263643)(images/字符编码表.jpg)]
-
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);
运算符
运算符在程序中作用是数据之间进行运算.运算符分类
算数运算符
+ - * / %- % 取模, 计算的结果要余数
赋值运算符
-
= 符号右边的数据,赋值到左边的变量
-
+= -= *= /= %= 不能分开
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); } -
++ 和 –
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:结果2public 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每天鸡犬相闻,但是老死不相往来
- 适合于多个条件的判断
ava
public static void main(String[] args) {
int i = 1 ;
if( i == 1)
System.out.println(“你好”);
System.out.println(“我好”);
}
if语句: (判断条件) 有一个写法,希望你用, 建议在判断里面,常量写在变量的前面.
```java
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每天鸡犬相闻,但是老死不相往来
- 适合于多个条件的判断
350
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
