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)

变量

变量 : 常量是固定不变化, 变量的数据是可以随时改变的, 变量方便进行运算

变量的定义三要素 :

明确数据类型
变量的名字
变量的值

变量定义三要素.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);
    }
  类型转换自动.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
    }

   ![字符编码表.jpg](https://upload-images.jianshu.io/upload_images/23942007-0b10b3ef9a7f65a0.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)


*   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:结果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每天鸡犬相闻,但是老死不相往来
适合于多个条件的判断

Java基础语法

Java基础语法

Eclipse IDE 的使用

创建工程

Eclipse的项目目录结构

Eclipse的字体调整

Eclipse的窗口设置

Eclipse快捷键

数据类型

变量

数据类型 变量名字 = 值

变量定义的注意事项

变量定义格式补充

数据类型转换 (有点难)

自动类型转换

强制类型转换

运算符

算数运算符

赋值运算符

比较运算符

逻辑运算符

位运算符

三元运算符

字符串数据的+计算

Scanner 键盘输入作用

流程控制语句

if判断语句

if语句注意事项

if...else语句

数据类型变量名字 = 值