1.Java开发环境

1.1 编译运行过程：

编译期：.Java源文件，经过编译，生产.class字节码文件
运行期：JVM加载.class并运行.class(0和1)

特点：跨平台，一次编程到处使用

1.2 名词解释

JVM java虚拟机

加载.class并运行.class

JRE java运行环境

包含JVM和运行java程序所必须的环境
JRE= JVM+java系统类库（小零件）

java开发工具包

包含了JRE、开发java程序所必须的命令工具
运行java程序的最小环境为JRE
开发java程序的最小环境为JDK

2. 语法

2.1 变量

变量：存数的，代词，指代的就是里面的那个数

声明

int a; //声明了一个整型的变量，名为a
int b,c,d; //声明了三个整型的变量，名为b,c,d
//int a; //编译错误，变量不能同名

初始化：

int b;   //声明整型变量b
b = 250; //给变量b赋值为250
b = 360; //修改变量b的值为360

使用

int b = a + 10; //取出a的值5，加10后，再赋值给变量b
System.out.println(b);   //输出变量b的值15
System.out.println("b"); //输出b，双引号中的原样输出
a = a+10; //在a本身基础之上增10
System.out.println(a); //输出变量a的值15

命名
- 只能包含字母、数字、_和$符，不能以数字开头
- 严格区分大小写
- 不能使用关键字
- 允许中文命名，但不建议，建议“英文命名”、“小驼峰命名法”

//int a*b; //编译错误，不能包含*等特殊符号
//int 1a; //编译错误，不能以数字开头
int aa = 5;
//System.out.println(aA); //编译错误，严格区分大小写
//int class，final,String,if; //编译错误，不能使用关键字

int 年龄; //允许，但不建议
int nianLing; //必须杜绝，既不直观也不专业
int age; //建议---英文的见名知意
int score,myScore,myJavaScore; //建议"小驼峰命名法"

2.2 基本数据类型

2.2.1. 八种基本数据类型

byte、short、int、long、float、double、boolean、char

int 整型，4个字节

整数直接量默认为int类型，但不能超出范围，若超范围则发生编译错误
两个整数相除，结果还是整数，小数位无条件舍弃
运算时若超范围，则发生溢出（需避免）

long：长整型，8个字节

长整型直接量需在数字后加l或L
运算时若有可能溢出，建议在第一个数字后加l

//2)long:长整型，8个字节，很大很大很大
long a = 25L; //25L为长整型直接量
//long b = 10000000000; //编译错误，100亿默认为int类型，但超出int范围了
long c = 10000000000L;
//运算时若有可能溢出，建议在第1个数字后加L
long d = 1000000000*2*10L;
System.out.println(d); //200亿
long e = 1000000000*3*10L;
System.out.println(e); //不是300亿
long f = 1000000000L*3*10;
System.out.println(f); //300亿

double:浮点型，8个字节

浮点数直接量默认为double型，若表示float需在数字后加F或f
double和float型数据参与运算时，有可能会发生舍入误差，精确场合不能使用

boolean：布尔型，1个字节

只能存储true或false

char：字符型，2个字节

采用Unicode字符集编码格式，一个字符对应一个码，表现的形式是字符char，但本质上是码int(0到65535之间)ASCII码：‘a’—97 ‘A’—65 ‘0’—48
字符型直接量必须放在单引号中，有且仅有一个字符
特殊符号需通过\来转义

2.2.2 类型间的转换：

基本类型由小到大依次为： byte->short->int->long->float->double

自动/隐式类型转换“小类型到大类型”
强制类型转换：大类型到小类型 语法：（要转换成为的数据类型）变量

注意：强转有可能发生溢出或丢失精度

long b = a; //自动/隐式类型转换
int c = (int)b; //强制类型转换

long d = 5; //自动类型转换
double e = 5; //自动类型转换

long f = 10000000000L;
int g = (int)f; //强制类型转换
System.out.println(g); //1410065408，强转有可能发生溢出
double h = 25.987;
int i = (int)h; //强转类型转换
System.out.println(i); //25，强转有可能丢失精度

两点规则

整数直接量可以直接赋值给byte、short、char，但不能超出范围
byte、short、char型数据参与运算时，系统一律自动将其转换为int再运算

byte b1 = 5; //byte的范围为-128到127
byte b2 = 6;
byte b3 = (byte)(b1+b2);

System.out.println(2+2);     //4
System.out.println(2+'2');   //52，2加上'2'的码50
System.out.println('2'+'2'); //100，'2'的码50，加上'2'的码50

2.3 运算符

2.3.1 算术

算术符号：+，-，*，/，%，++，–

%:取模/取余，余数为0即为整除
++/–：自增1/自减1，可在变量前也可在变量后
- 单独使用时，在前在后都一样
- 被使用时，在前在后不一样
  - a++的值为----（a=a，a=a+1）
  - ++a的值为----（a=a+1，a=a）

//%的演示
System.out.println(8%2); //0，商4余0----整除
System.out.println(5%2); //1，商2余1
System.out.println(2%8); //2，商0余2

//++单独使用:
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6

//++被使用:
int a=5,b=5;
int c = a++; //1)保存a++的值5  2)a自增1变为6  3)将第1步保存的值5赋值给c--底层运算过程
//---粗暴记法:a++的值为5，c就是5
int d = ++b; //1)保存++b的值6  2)b自增1变为6  3)将第1步保存的值6赋值给d--底层运算过程
//---粗暴记法:++b的值为6，d就是6
System.out.println(a); //6
System.out.println(b); //6
System.out.println(c); //5
System.out.println(d); //6

//--单独使用:
int a=5,b=5;
a--; //相当于a=a-1
--b; //相当于b=b-1
System.out.println(a); //4
System.out.println(b); //4

//--被使用:
int a=5,b=5;
int c = a--; //a--的值为5，所以c的值为5
int d = --b; //--b的值为4，所以d的值为4
System.out.println(a); //4
System.out.println(b); //4
System.out.println(c); //5
System.out.println(d); //4

2.3.2 关系

关系：>，<，>=，<=，==，!=

关系运算的结果为boolean型，关系成立则为true，否则为false

2.3.3 逻辑

逻辑为&&，||，!

&&：短路与（并且），两边都为true则为true,否则为false 当第1个条件为false时，发生短路（后面的不执行了）
||:短路或（或者），有true为true，见true则true 当第1个条件为true时，发生短路(后面的不执行了)
!: 逻辑非（取反），非真则假，非假则真

2.3.4 赋值

赋值：=，+=，-=，*=，/=，%=

int a = 5;
a += 10; //相当于a=(int)(a+10)
System.out.println(a); //15
a *= 2; //相当于a=(int)(a*2)
System.out.println(a); //30
a /= 6; //相当于a=(int)(a/6)
System.out.println(a); //5

//小面试题:
short s = 5;
//s = s+10; //编译错误，需强转: s=(short)(s+10);
s += 10; //相当于s=(short)(s+10)

2.3.5 字符串连接：+

若两边为数字，则做加法运算
若两边出现了字符串，则做字符串连接任何类型与字符串相连，结果都会变为字符串类型

2.3.6 条件/三目：？：

语法：boolean？条件1：条件2，若Boolean为true，则条件1，否则为条件2

2.4 分支结构

语法：if(boolean){语句块}
执行过程：判断boolean的值：若为true，则执行语句块，结束，若为false，if语句直接结束。

if...else

语法：if(boolean){语句块1}else{语句块2}
执行过程：判断boolean的值:若为true，则执行语句块1(整结束)，若为false，则执行语句块2(整个结束)

if...else if

语法：if(boolean1){语句块1}else if(boolean2){语句块2}else{语句块3}
执行过程：判断boolean1，,若为true，则执行语句块1，否则判断boolean2，若为true，则执行语句块2，否则执行语句块3

swtich...case

优点：效率高，结构清晰
缺点：只能对整数判断相等
break：跳出switch

2.5 循环

循环：反复多次执行一段相同或相似的代码

2.5.1循环三要素：

循环变量的初始化
循环条件（以循环变量为基础）
循环变量的改变（向着循环的结束变） 循环变量：在整个循环过程中所反复改变的那个数

2.5.2 循环结构

2.5.2.1 while

while结构：先判断后执行，有可能一次都不执行
语法：while（boolean）{undefined 语句块---反复执行的代码}
执行过程：判断boolean的值，若为true则执行语句块，再判断boolean的值，若为true则再执行语句块，如此反复知道boolean值为false，则结束while循环
代码演示

//1)输出5次"行动是成功的阶梯":
int times = 0;  //1)循环变量的初始化
while(times<5){ //2)循环的条件
    System.out.println("行动是成功的阶梯");
    times++;    //3)循环变量的改变
}
System.out.println("继续执行...");

/*
  执行过程:----带数
                times=0
    true  输出  times=1
    true  输出  times=2
    true  输出  times=3
    true  输出  times=4
    true  输出  times=5
    false while循环结束
    输出继续执行...
 */

//2)输出9的乘法表:
int num = 1;     //3*9=27
while(num<=9){
    System.out.println(num+"*9="+num*9);
    num++;  //num+=2;
}
System.out.println("继续执行...");

2.5.2.2 do..while

语法 do{语句块}while(boolean);
执行过程：先执行语句块，再判断boolean的值，若为true则再执行语句块，再判断boolean的值，若为true则再执行语句块，再判断boolean的值，若为true则，再执行语句块，如此反复，直到boolean的值为false，则 do…while结束。

 int guess =10,num=4
 do{
            System.out.println("猜吧!");
            if(guess>num){
                System.out.println("太大了");
            }else if(guess<num){
                System.out.println("太小了");
            }else{
                System.out.println("恭喜你猜对了");
            }
            num++;
        }while(guess!=num); //2
————————————————

2.5.2.3 for结构

应用率高、与次数相关的循环
语法：for(要素1;要素2;要素3){需要循环的语句块4}
执行过程：124324324 ...2

for(int i=1;i<=9;i++){ 
System.out.println(i+"*9="+i*9); }

break:跳出循环
continue：结束本次循环进入下一次循环

2.5.3 嵌套循环

循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
执行过程：外层循环走一次，内层循环走所有次
建议：嵌套层数越少越好
break只能跳出当前一层循环

2.6 Scanner

接收用户输入的数据

package day04;
import java.util.Scanner; //1.导入一个扫描仪
//Scanner的演示
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in); //2.新建一个扫描仪
        System.out.println("请输入年龄:");
        int age = scan.nextInt(); //3.扫描一个整数给age
        System.out.println("请输入商品价格:");
        double price = scan.nextDouble(); //3.扫描一个小数给price
        System.out.println("年龄为:"+age+"，价格为:"+price);
    }
}

2.7 数组

是一种数据类型
相同数据类型元素的集合
定义：

//声明int型数组arr，包含10个元素，每个元素都是int型，默认值为0
int[] arr = new int[10];

初始化：给数组中的元素做初始化

int[] arr = new int[3]; //0,0,0
int[] arr = {1,4,7}; //1,4,7
int[] arr = new int[]{1,4,7}; //1,4,7
int[] arr;
//arr = {1,4,7}; //编译错误
arr = new int[]{1,4,7}; //正确

访问：访问的是数组中的元素

通过（数组名.length）可以获取数组的长度

int[] arr = new int[3];
System.out.println(arr.length); //3

通过下标/索引来访问数组中的元素，下标从0开始到数组长度-1

int[] arr = new int[3];
System.out.println(arr[0]); //输出第1个元素
arr[0] = 100; //给第1个元素赋值为100
arr[1] = 200; //给第2个元素赋值为200
arr[2] = 300; //给第3个元素赋值为300
//arr[3] = 400; //运行时会发生ArrayIndexOutOfBoundsException数组下标越界异常
System.out.println(arr[arr.length-1]); //输出最后一个元素的值

复制

System.arraycopy(a,1,b,0,4);

//7)数组的复制:
int[] a = {10,20,30,40,50};
int[] b = new int[6]; //0,0,0,0,0,0
//a:源数组
//1:源数组的起始下标
//b:目标数组
//0:目标数组的起始下标
//4:要复制的元素个数
System.arraycopy(a,1,b,0,4); //灵活性好
for(int i=0;i<b.length;i++){
    System.out.println(b[i]);
}

int[ ] b = Arrays.copyOf(a,6);

//常规复制
int[] a = {10,20,30,40,50};
//a:源数组
//b:目标数组
//6:目标数组的长度(元素个数)
//---若目标数组长度>源数组长度，则末尾补默认值
//---若目标数组长度<源数组长度，则将末尾的截掉
int[] b = Arrays.copyOf(a,6); //灵活性差
for(int i=0;i<b.length;i++){
    System.out.println(b[i]);
}

//数组的扩容
int[] a = {10,20,30,40,50};
//数组扩容(创建了一个更大的新的数组，并将源数组数据复制进去了)
a = Arrays.copyOf(a,a.length+1);
for(int i=0;i<a.length;i++){
    System.out.println(a[i]);
}

排序

Arrays.sort(arr); //升序排列(从小到大)

//8)数组的排序:
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
    arr[i] = (int)(Math.random()*100);
    System.out.println(arr[i]);
}

Arrays.sort(arr); //对arr进行升序排列

System.out.println("数组排序后的数据:");
for(int i=0;i<arr.length;i++){
    System.out.println(arr[i]);
}

Java语言基础

1.Java开发环境

1.1 编译运行过程：

1.2 名词解释

2. 语法

2.1 变量

2.2 基本数据类型

2.2.1. 八种基本数据类型

2.2.2 类型间的转换：

2.3 运算符

2.3.1 算术

2.3.2 关系

2.3.3 逻辑

2.3.4 赋值

2.3.5 字符串连接：+

2.3.6 条件/三目： ？ ：

2.4 分支结构

2.5 循环

2.5.1循环三要素：

2.5.2 循环结构

2.5.2.1 while

2.5.2.2 do..while

2.5.2.3 for结构

2.5.3 嵌套循环

2.6 Scanner

2.7 数组

2.3.6 条件/三目：？：