第一天：
Java开发环境：
-
java编译运行过程:---------常见面试题
1)编译期： .java源文件，经过编译，生成 .class字节码文件
2)运行期：JVM加载 .class并运行 .class(0和1)
特点：跨平台、一次编程到处使用 -
名词解释:-----------常见面试题
1)JVM：java虚拟机
加载 .class并运行 .class
2)JRE：java运行环境
除了包含JVM以外，还包含了运行java程序所必须的环境
JRE=JVM+java系统类库(小零件)
2.3)JDK：java开发工具包
除了包含JRE以外，还包含了开发java程序所必须的命令工具
JDK=JRE+编译、运行等命令工具
说明：
1)运行 java程序的最小环境是JRE
2)开发 java程序的最小环境是JDK
注：
C语言的编译运行过程：--------效率高、区分操作系统的
.c的源文件，经过编译，直接生成可执行文件(0和1)
java程序从开始到运行过程：
第二天：
1.变量：存数的; 代词, 指代的就是它所存的那个数
1)声明：
int a; //声明一个整型的变量,名为a
int b,c,d; //声明三个整型的变量,名为b,c,d
2)初始化：第一次赋值
int a = 250; //声明整型变量a并赋值为250, = 是赋值的意思;
//声明的同时初始化
int a; //声明整型变量a
a = 250; //给变量a赋值为250 //先声明后初始化
a = 360; //修改变量a的值为360
Eg：
① int sum = 0; //声明整型的变量sum,并且赋值为0
Int a = 5; //声明整型的变量a,并且赋值为5
Int b = 6;
Sum = a + b; //修改sum的值为11
② int sum;
Sum = 0;
Sum = sum + 100;
3)使用:
3.1)对变量的操作就是对它所存的那个数的操作
Int a = 5;
Int b = a+10; //取出a的值5,加10后,再赋值给变量b 先读右边
System.out.println(b); //输出变量b的值15,不加引号,计算机认为它是个变量b
System.out.println(“b”); //输出b, 双引号中的原样输出
a = a+10; //取出a的值5,加10后,再赋值给变量a
//在a本身基础上增10
3.2)变量的使用必须与数据类型匹配
int a = 3.14; //编译错误, 数据类型不匹配 ; int是整型变量,只能装整数
3.3)变量在用之前必须声明并初始化
System.out.println(m); //编译错误 , m未声明
int m;
System.out.println(m); //编译错误 , m未初始化
int a,b = 10; //一次声明两个变量，a没有值，b的值为10
Int c = a + b;
System.out.println(c); //编译错误, a未初始化
int m = 5 ;
System.out.println(m); //编译正确
4)命名:
4.1)只能包含字母,数字, _ 和$符, 并且不能以数字开头
4.2)严格区分大小写
4.3)不能使用关键字 代码里紫颜色的, 因为Java里已经占了 eg: package, class
4.4)可以中文命名, 但不建议
int a; //不直观 int年龄; //直观但不专业 int nianling; //既不直观,也不专业
建议“英文的见名知意”: int age; //建议
“驼峰命名法”：
int score, myScore, myJavaScore; //第一个单词首字母小写,其余单词首字母大写, java变量的命名
“帕斯卡命名法”：
int Score, MyScore, MyJavaScore; //所有单词首字母大写, 类的命名 eg: HelloWorld
2. 八种基本数据类型: byte，short，int，long，float，double，boolean，char
1) int：整型，4个字节(32位)， -21个多亿到21个多亿
1.1）整数直接量默认为int型，但不能超出范围，超范围则编译错误
1.2）两个整数相除，结果还是整数，小数位无条件舍弃
1.3）整数运算时超出范围则发生溢出，溢出不是错误，但是是需要避免的
int a = 250; //250为整数直接量，默认为int型
int b = 10000000000; //编译错误，100亿为整数直接量，默认为int型，但超出了int范围了
System.out.println(5/2); //2
System.out.println(2/5); //0
System.out.println(5/2.0); //2.5
int c = 2147483647; //int的最大值
c = c+1;
System.out.println(c); //-2147483648，发生溢出了，需要避免
2) long：长整型，8个字节(64位)，很大很大很大
2.1）长整型直接量需在数字后加L或l
2.2）运算时若有可能溢出,建议在第1个数字后加L
2.3）System.currentTimeMillis()用于获取自1970.1.1零时到此时此刻的毫秒数
long a =25L; //25L为长整型直接量
long b = 10000000000; //编译错误，100亿为整数直接量，默认为int型，但超出int范围了
long c = 10000000000L; //100亿L为长整型直接量
long d = 1000000000*2*10L;
System.out.println(d); //200亿
long e = 1000000000*3*10L;
System.out.println(e); //不是300亿 前两个溢出了，是溢出的那个数*10L
long f = 1000000000L*3*10;
System.out.println(f); //300亿
3) double：浮点型，8个字节(64位)，很大很大很大 浮点数就是小数
3.1)浮点数直接量默认为double型,表示float需在数字后加f或F 小数都用double
3.2)double和float数据在运算时,有可能会出现舍入误差
double a = 3.14159; //3.14159为浮点数直接量，默认double型
float b = 3.14159F; //3.14159F为float型直接量
double c=3.0,d=2.9;
System.out.println(c-d); //0.10000000000000009,有可能会发生舍入误差
4)boolean：布尔型，1个字节(8位)
只能赋值为true和false
boolean b1 = true; //true为布尔型直接量
boolean b2 = false; //false为布尔型直接量
boolean b3 = 25; //编译错误，布尔型只能赋值true或false
5) char：字符型，2个字节(16位)
5.1)采用Unicode字符集编码,一个字符对应一个码,
表现的形式的字符是char,但实质上是码int
(ASCII码:‘a’–97 ‘A’–65 ‘0’–48)
5.2)字符直接量必须放在单引号中,只能有一个
5.3)特殊符号需通过\来转义
char c1 = '女'; //字符女
char c2 = 'f'; //字符f
char c3 = '6'; //字符6
char c4 = ' '; //空格符
//char c5 = 女; //编译错误，字符直接量必须放在单引号中
//char c6 = ''; //编译错误，必须有字符
//char c7 = '25'; //编译错误，只能装一个字符
char c8 = '\'';
System.out.println(c8); //'
char c9 = 65; //0到65535之间
System.out.println(c9); //A 输出时会依据c9的数据类型来做对应的输出
补：
够用就行
1G=1024M(兆) 1M=1024KB(千字节) 1KB=1024B(字节) 1B=8Bit(位)
1G=1024*1024*1024字节------------------1073741824字节
int a = 10000000000; //编译错误 直接量超范围为编译错误
int a = 10000000000*10 //溢出 运算时超范围为溢出
long a = 100000000000; //会有编译错误
long b = 1000000000000L;
20亿(int)
long a =1000000000*2*10L;
System.out.println(a); //200亿(long)
溢出了
long b =1000000000*3*10L;
System.out.println(a); //不是300亿
30亿(long)
long c =1000000000L*3*10;
System.out.println(c); //300亿(long)
3.基本数据类型间的转换：
基本数据类型从小到大依次为：
byte,short,int,long,float,double
char,
1）两种方式：
1.1）自动类型转换：小类型到大类型
1.2）强制类型转换：大类型到小类型
(要转换成为的数据类型)变量
强转有可能溢出或丢失精度
2）两点规则： 整数直接量默认为int型
2.1) 整数直接量可以直接赋值给byte,short,char,但不能超出范围
2.2) byte,short,char型数据参与运算时,系统会一律自动转换为int再运算
int a = 5;
long b = a; //自动类型转换
int c = (int)b; //强制类型转换
long d = 5; //自动类型转换
double e = 5; //自动类型转换
long f = 10000000000L;
int g = (int)f;
System.out.println(g); //强转时有可能会发生溢出
double h = 25.987;
int i = (int)h;
System.out.println(i); //25,强转时有可能会丢失精度
---------------------------------------------------------------------
byte b1 = 5;
byte b2 = 6;
//byte b3 = b1+b2; //编译错误，b1+b2时系统将b1和b2自动转换为int类型再做加法
byte b4 = (byte)(b1+b2); //做运算时就是int型了
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 0=48
System.out.println('2'); //2 //只有做运算时才转换成int型
4.Scanner接收输入：
1)在package下:
import java.util.Scanner;
2)在main中:
Scanner scan = new Scanner(System.in);
3)在第2步之下:
System.out.println("请输入年龄:");
int age = scan.nextInt();
System.out.println("请输入价格:");
double price = scan.nextDouble();
System.out.println("年龄为:"+age+"，价格为:"+price);
第三天：
运算符:
1)算术运算符：+, -, *, /, %, ++, - -
1)%：取模/取余，
2)++/- -：
2.1)单独使用时，在前在后都一样
2.2)被使用时，在前在后不一样
a++的值为a-----------------------(a- -的值为a)
++a的值为a+1---------------------(- -a的值为a-1)
int a=5,b=5;
int c = a++; //1)将a++的值5赋值给c 2)a自增1变为6
int d = ++b; //1)将++b的值6赋值给d 2)b自增1变为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;
int c = a--; //1)将a--的值5赋值给c 2)a自减1变为4
int d = --b; //1)将--b的值4赋值给d 2)b自减1变为4
System.out.println(a); //4
System.out.println(b); //4
System.out.println(c); //5
System.out.println(d); //4
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;
a--; //相当于a=a-1
--b; //相当于b=b-1
System.out.println(a); //4
System.out.println(b); //4
System.out.println(5%2); //1，商2余1
System.out.println(8%2); //0，商4余0----整除
System.out.println(2%8); //2，商0余2
2)关系运算符：>, <, >=, <=, ==(等于), !=(不等于)
关系运算的结果为boolean型，
关系成立则为true，关系不成立则为false
int a=5,b=10,c=5;
System.out.println(c<b); //true
System.out.println(a==c); //true
System.out.println(a!=c); //false
System.out.println(c++>5); //false ---------1)被使用时c++的值为c，所以5>5,为false
// 2)与此同时，c自增1变为6
System.out.println(c++>5); //true ---------1)c此时为6了，又 被使用时c++的值为c，所以6>5,为true
// 2)与此同时，c自增1变为7
System.out.println(++b>10); //true ---------1)被使用时++b的值为b+1，所以11>10，为true
// 2)与此同时，b自增1变为11
3)逻辑运算符：&&, ||, ! boolean型 常常用于连接多个关系运算符
&& ： 短路与(并且)，两边都为真才为真，见false则false
----当第1个数为false时，则发生短路(后面的不执行了)
|| ： 短路或(或者)，有真则为真，见true则true
----第1个数为true时，则发生短路(后面的不执行了)
! ： 逻辑非(取反)，非真则假，非假则真
逻辑运算建立在关系运算的基础之上的
逻辑运算的结果也是boolean型
int a=5,b=10,c=5;
boolean b1 = b>=a && b<c;
System.out.println(b1); //true&&false=false
System.out.println(b<=c && b>a); //fasle&&true=false
System.out.println(a==b && c>b); //false&&false=false
System.out.println(b!=c && a<b); //true&&true=true
System.out.println(b>=a || b<c); //true||false=true
System.out.println(b<=c || b>a); //false||true=true
System.out.println(b!=c || a<b); //true||true=true
System.out.println(a==b || c>b); //false||false=false
boolean b2 = !(a<b);
System.out.println(b2); //!true=false
System.out.println(!(a>b)); //!false=true
/*
int a=5,b=10,c=5;
boolean b3 = a>b && c++>2;
System.out.println(b3); //false
System.out.println(c); //5 ,发生短路了，后面的不执行了
boolean b4 = a<b && c++>2;
System.out.println(b4); //true
System.out.println(c); //6 ,没发生短路
*/
/*
boolean b5 = a<b || c++>2;
System.out.println(b5); //true
System.out.println(c); //5 ,发生短路了，后面的不执行了
boolean b6 = a>b || c++>2;
System.out.println(b6); //true
System.out.println(c); //6，没发生短路
*/
4)赋值运算符：=, +=, -=, =, /=, %=
1)简单赋值运算符：=
2)扩展赋值运算符：+=,-=,=,/=,%=
扩展赋值运算符自带强转功能
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; //两条规则 1.
//s = s+10; //两条规则 2. 编译错误，改为: s = (short)(s+10)
s += 10; //相当于 s = (short)(s+10)
5)字符串连接运算符：+
1.1)若两边为数字，则做加法运算
1.2)若两边出现了字符串，则做字符串连接
int age = 23;
System.out.println("age="); //age=
System.out.println(age); //23
System.out.println("age="+age); //age=23
System.out.println("我的年龄是："+age); //我的年龄是：23
System.out.println("我今年"+age+"岁了"); //我今年23岁了
String name = "LCX";
System.out.println("name"+name); //name=LCX
System.out.println("大家好，我叫"+name); //大家好，我叫LCX
System.out.println("大家好，我叫"+name+",今年"+age+"岁了"); //大家好，我叫LCX，今年23岁了
System.out.println(10+20+""+30); //3030-----------String
System.out.println(10+20+30+""); //60-------------String
System.out.println(""+10+20+30); //102030---------String
6)条件/三目运算符： boolean?数1:数2
执行过程：
整个表达式是有结果的，它的结果要么是?号的数1，要么是:号后的数2
判断boolean的值：
若为true，则整个表达式的结果为?号的数1
若为false，则整个表达式的结果为:号后的数2
int num = 5;
int flag = num>0?1:-1;
System.out.println(flag); //1
int a=8,b=5;
int max =a>b?a:b;
System.out.println(max); //a
char：字符型，单引号中，1个
String：字符串型，双引号中，0个到多个 ----------------------API第一天详细讲它
给a本身增1
a = a+1;
a++;
++a;
a += 1;
分支结构：有条件的去执行某个语句,并非每句必走
1、if结构: 1条路
1) 语法：
if(boolean){
语句块 ------------ 基于条件执行的语句
}
2) 执行过程：
判断boolean的值:
若为true，则执行语句块
若为false，则if结束
eg：
boolean flag = true;
if(flag){
}
Int a = 5;
if(a>2){
}
Int a = 5;
if(a>2 && a<9){
}
偶数的判断
int num = 5; //带数6，5
if(num%2==0){
System.out.println(num+"是偶数");
}
System.out.println("继续...");
满500打8折
double price = 600.0; //消费金额 600.0，300.0
if(price>=500){ //满500
price*=0.8; //打8折
}
System.out.println("最终消费金额为："+price);
2、 if…else结构: 2条路
1）语法：
if(boolean){
语句块1
}else{
语句块2
}
2）执行过程：
判断boolean的值：
若为true，则执行语句块1（整个结束）
若为false，则执行语句块2（整个结束）
3）说明：
语句块1和语句块2，必走其中之一
偶数、奇数的判断：
int num = 6 ;
if(num%2==0){
System.out.println(num+"是偶数");
}else{
System.out.println(num+"是奇数");
}
System.out.println("继续...");
满500打8折，不满500打9折
double price = 300.0; //消费金额------600.0，300.0
if(price>=500){ //满500
price*=0.8;
}else{ //不满500
price*=0.9;
}
System.out.println("最终消费金额为："+price);
3、 if…else if结构： 多条路
1）语法：
if(boolean-1){
语句块1
}else if(boolean-2){
语句块2
} else if(boolean-3){
语句块3
}else{
语句块4
}
2）执行过程：
判断boolean-1，若为true则执行语句块1(结束)，若为false则
再判断boolean-2，若为true则执行语句块2(结束)，若为false则
再判断boolean-3，若为true则执行语句块3(结束)，若为false则执行语句块4(结束)
3）说明：
语句块1/2/3/4，只能走其中之一
package day04;
import java.util.Scanner;
//成绩等级判断
public class ScoreLevel {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入成绩:");
double score = scan.nextDouble();
//888，-56，95，85，65，45
if(score<0 || score>100){
System.out.println("成绩不合法");
}else if(score>=90){ //合法
System.out.println("A-优秀");
}else if(score>=80){
System.out.println("B-良好");
}else if(score>=60){
System.out.println("C-中等");
}else{
System.out.println("D-不及格");
}
}
}
4、switch…case结构： 多条路
优点：效率高、结构清晰
缺点：只能对整数操作、只能判断相等
break：跳出switch 结束
对整数判断相等，首选switch…case
switch…case语句是一种特殊的分支结构，可以根据一个整数表达式的不同取值，
从不同的程序入口开始执行。
public class SwitchCaseDemo {
public static void main(String[] args) {
int num = 2;
switch (num){ //表达式的值的类型：byte,short,int,char,String(JDK1.7开始支持)
case 1: //if(num==1)
System.out.println(111);
break;
case 2: //以此为入口
System.out.println(222);
break; //跳出switch
case 3:
System.out.println(333);
break;
default: //所有case都未匹配时执行
System.out.println(666);
}
}
}
package day04;
import java.util.Scanner;
//命令解析程序
public class CommandBySwitch {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请选择功能: 1.存款 2.取款 3.查询余额 0.退出");
int command = scan.nextInt();
switch(command){
case 1:
System.out.println("存款业务...");
break;
case 2:
System.out.println("取款业务...");
break;
case 3:
System.out.println("查询余额业务...");
break;
case 0:
System.out.println("退出，欢迎下次再来!");
break;
default:
System.out.println("输出错误");
}
}
}
任何复杂的程序逻辑都可以通过三种结构来实现:
1)顺序结构： 从上往下逐行执行,每句必走
2)分支结构:：有条件的去执行某个语句一次, 并非每句必走
3)循环结构： 有条件的去执行某个语句多次, 并非每句必走
分支结构 与 循环结构 的区别：
if(boolean){ //只判断一次
语句块 //最多执行一次
}
while(boolean){ //判断多次
语句块 //执行多次
}
分支结构：
满500打8折
满499减100
打8折-----------------------基于条件的执行
减100------------------------基于条件的执行
满足条件就干事, 不满足条件就不干事--------------------if
满足条件就干事, 不满足条件干另一件事-----------------if…else
满500打8折, 不满500不打折----------------if
满500打8折, 不满500打9折----------------if…else
第四天：
循环结构： while结构 do…while结构 for结构
1、 循环：反复执行一段相同或相似的代码
2、 循环三要素：
1）循环变量的初始化
2）循环的条件 ( 以循环变量为基础 )
3）循环变量的改变 ( 向着循环的结束变 )
循环变量：在整个循环过程中所反复改变的那个数
跑3圈：
圈数为0
够3圈吗？ 不够 跑一圈 圈数为1
够3圈吗？ 不够 跑一圈 圈数为2
够3圈吗？ 不够 跑一圈 圈数为3
够3圈吗？ 够了
循环变量：圈数count
1）int count=0 ;
2）count < 3
3）count++ ;
count=0/1/2/3 时结束
案例一:
输出6次“行动是成功的阶梯”
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
循环变量：次数times
1）int times=0;
2）times < 6
3）times++;
times=0/1/2/3/4/5/6时结束
案例二：
输出9的乘法表：
1*9=9
2*9=18
3*9=27
4*9=36
5*9=45
6*9=54
7*9=63
8*9=72
9*9=81
循环变量：乘数num
1）int num=1;
2）num<=9
3）num++;
num=1/2/3/4/5/6/7/8/9/10时结束
3、 循环结构：有条件的去执行某个语句多次, 并非每句必走
1） while结构： 先判断，后执行，有可能一次都不执行
1.1）语法：
while(boolean){
语句块/循环体 --------- 反复执行的代码
}
1.2）执行过程：
判断boolean的值，若为true则执行语句块，
再判断boolean的值，若为true则再执行语句块，
再判断boolean的值，若为true则再执行语句块，
如此反复，直到boolean的值为false时，while循环结束
int times = 0; //1.循环变量的初始化
while (times<6){ //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
true 输出 times=6
fasle while结束 输出继续...
int num = 1; //3*9=27
while(num<=9){
System.out.println(num+"*9="+num*9);
num++; //num+=2
}
System.out.println("继续...");
执行过程：
num=1
true 输出 num=2
true 输出 num=3
true 输出 num=4
true 输出 num=5
true 输出 num=6
true 输出 num=7
true 输出 num=8
true 输出 num=9
true 输出 num=10
false while循环结束 输出继续...
2） do…while: 先执行，后判断，至少执行一次
要素1与要素3相同时，首选do…while
2.1）语法：
do{
语句块/循环体
}while(boolean表达式)；
2.2）执行过程：
先执行语句块，再判断boolean的值，若为true则
再执行语句块，再判断boolean的值，若为true则
再执行语句块，再判断boolean的值，
如此反复，直到boolean的值为false时，do…while结束
package day04;
import java.util.Scanner;
//猜数字小游戏
public class Guessing {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
System.out.println(num); //作弊
//假设num=250-----300(大),200(小),250(对)
int guess;
do{
System.out.println("猜吧!");
guess = scan.nextInt(); //1+3
if(guess>num){
System.out.println("太大了");
}else if(guess<num){
System.out.println("太小了");
}else{
System.out.println("恭喜你，猜对了!");
}
}while(guess!=num); //2
1到1000之内的随机数
Math.random()------------------0.0到0.999999999999999999...
*1000--------------------------0.0到999.9999999999999999...
+1-----------------------------1.0到1000.999999999999999...
(int)--------------------------1到1000
0到99的随机数：
Math.random()----------------------0.0到0.99999999999999999…
*100-------------------------------0.0到99.9999999999999999…
(int)--------------------------------0到99
0到99不需要加1，直接强转
如果要得1到100，才需要加1
给变量赋值：
1） 赋一个固定的值：
int a = 5;
2） 接收用户输入的值:--------------------Scanner
int a = scan.nextInt();
3） 系统随机的值：------------------------周五讲
Math.random()
案例： 猜数字
int num = 250; //藏起来的数
循环变量：用户猜的那个数guess
1） System.out.println(“猜吧!”);
int guess = scan.nextInt();
2） guess != num
3) System.out.println(“猜吧”);
guess = scan.nextInt();
猜吧！
300
太大了
猜吧！
200
太小了
猜吧！
251
太大了
猜吧！
250
恭喜你，猜对了
1227
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
