优秀是一种习惯
Java 语言背景
- JavaSE 其他两个版本的基础 用来做桌面的开发 主要为今后从事大数据开发 打基础
- JavaME 嵌入式消费类型的电子设备
- JavaEE web开发 做web页面和后台功能实现
Java语言跨平台的原理
-
Java语言 一次编译到处运行
-
Java开发
-
编写Java
- JRE Java运行环境 包括JVM和核心类库
- JVM 虚拟机 本身不可以跨平台 允许跨平台的是Java程序
-
编译Java
- .java文件 属于 源文件 ，无法被JVM所识别执行的
- 使用Java提供的JDK中的翻译工具
-
运行Java
JDK 是Java语言你的软件开发工具包，包含代码的编译工具和运行工具
-
JVM，JRE，JDK关系
JDK =JRE ＋开发工具
JRE＝JVM＋核心类库
DOS命令
为了使用Javac和Java命令
- 盘符: 切换到某盘
- cd 进入
- dir 显示当前目录下所有文件
- cd / 进入根目录
- exit 退出
HelloWorld详解
public class HelloWrold{
public static void main(String[] args){
System.out.println("helloworld");
}
}
- public 限定类名和文件名保持一致 记
- class 定义一个类
- hellowrld 类型
- main 主方法 JVM 只会调用main方法 Java程序的入口
- System.out.println(""); 输出语句
编程中可能会出现的问题
- bug 程序中的缺陷问题
- 单词写错 没区分大小写
- 使用中文字符
- 类名和文件名不一致
注释
给程序员看的 并不会给JVM看
- 单行注释 //
- 多行注释 /* */
- 文档注释 /** */
关键字
Java赋予了特殊含义的单词
- 全小写 字母
- 在一些代码编辑工具中会有颜色标记
常量
作用:在代码运行期间 其值不会发生变化的数据
-
整数常量
例如:1,2,3,11,33,212
-
小数常量
例如:1.22,12.13
-
字符常量
例如:‘A’,‘a’,‘1’
-
字符串常量
例如:“黑马”,“abc”
-
布尔常量
例如:true,false
-
空常量
只有一个:null
不能单独打印
变量
作用:使用变量记录一些经常发生变化的数据
变量是什么:内存中一小块存储区域 这个区域中的值经常发生变化
变量的定义格式: 数据类型 变量名=初始化值;
变量的使用:拿变量名使用 拿变量名获取这个变量对应的值
注意事项:
-
变量名不可以重名
-
一行上可以定义同类型的数据
例如:int a,b,c;
int a=11,b=22,c=33;
-
变量使用前,必须要有一个初始化
-
定义float与long 对应初始化值后面加上F/f和L/l;
-
变量的作用范围 变量所在的大括号中
数据类型
分为基本数据类型和引用数据类型。
基本数据类型 四类八种：
- 整数类型: byte short int long
- 浮点类型: float doublee
- 布尔类型: boolean
- 字符类型: char
引用数据类型：
- 数组
- String
- 接口interface
- 类
整数类型:
字节Byte 范围
byte 1B -128~127
short 2B -2^15~2^15-1
int 4B -2^31~2^31-1 默认
long 8B
浮点类型
float 4B
double 8B 默认
字符
char 2B
布尔类型
boolean 1B
定义float类型变量时 后面必须加上F或f;
定义double类型变量时 后面可以不加D或d;
定义long类型变量时 后面必须加上L或l;
int类型和float类型所占都是4个字符,那种数据类型所储存的数据大呢?
float在数据结构中存在的方式是用指数表示的 采用科学技术法
所以float表示的数据范围要比int大
数据类型转化
自动转换/隐式转换
要求:
-
将数据范围小的 赋予一个数据范围大的
-
一个小的和一个大的计算时 小的提升为大的 然后计算
byte–>short–>int–>long–>float–>double
char–>int–>long–>float–>double
byte、short、char 参与计算时 会提升为int 记
例如:将数据范围小的 赋予一个数据范围大的 int a=222; long b=a; 例如：一个小的和一个大的计算时 小的提升为大的 然后计算 int a=222; double b=10.2; double c=a+b; //a int自动提升为double 例如：byte、short、char计算时 会提升为int byte a=10; short b=20; int c=a+b; //byte、short、char计算时提升为int byte d=(byte)(a+b) //强转 byte f=10+20; //常量的优化机制 相当于byte f=30,将一个这个数复制个欸一个类型时，jvm会判断当前值是否在范围内；
强制转换
要求:
-
将数据范围大的 赋予一个数据范围小的
-
小数转为整数 只保留整数位
例如: 将数据范围大的 赋予一个数据范围小的 int a=222; byte b=(byte)a; 例如：小数转为整数 只保留整数位 double a=10.95; int b=(int)a; sout(b); //10
基础面试题
键盘录入一个小数，输出一个四舍五入的整数
方法1：键盘录入一个小数，输出一个四舍五入的整数
Scanner sc= new Scanner(System.in);
double num=sc.nextDouble();
int result=(int)(num+0.5);
sout(result);
方法2：键盘录入一个小数，输出一个四舍五入的整数
Scanner sc= new Scanner(System.in);
double num=sc.nextDouble();
sout(Math.round(num));
拓展：
向下取整
Math.floor(num);
例如:
Math.floor(11.7)=11;
Math.floor(-11.2)=-12;
向上取整
Math.ceil(num)
例如：
Math.ceil(11.4)=12;
Math.ceil(-11.6)=-11;
键盘录入
用键盘录入数据 为了让我们的数据更加灵活
- 导包
- 位于类上方
- import java.util.Scanner;
- 创建对象
- Scanner sc=new Scanner(System.in);
- 接收数据
- int i=sc.nextInt();
例如：
import java.util.Scanner;
public class Demo{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int i=sc.nextInt();
Sysyem.out.println(i);
}
}
标识符
用来给变量 类 方法取名的符号
硬性规范
- 数字,下划线,字母,美元符号$
- 不能以数字开头
- 不可以使用关键字
- 严格区分大小写
江湖规矩
- 小驼峰
- 作用在 变量 方法 上
- 一个单词时 首字母小写
- 多个单词时 第一个单词首字母小写,其他单词首字母大写
- 大驼峰
- 作用在 类 上
- 一个单词时 首字母大写
- 多个单词时 每个单词首字母都要大写
运算符
-
运算符 用来连接常量或者变量的符号
-
表达式 使用运算符连接常量或者变量的一种符合Java语法的式子
分类
-
算术运算符
-
赋值运算符
-
比较(关系)运算符
-
逻辑运算符
-
三元运算符
算数运算符
| 算数运算符包括： | 作用 |
|---|---|
| + | 加法运算，字符串连接运算 |
| - | 减法运算 |
| * | 乘法运算 |
| / | 除法运算 |
| % | 取模运算，两个数字相除取余数 |
例如：求三位数的各位数字，十位数字，百位数字是多少？
public class Demo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位的整数");
int num = sc.nextInt();
int ge=num%10;
int shi=num/10%10;
int bai=num/100%10;
// int qian = num / 1000 % 10;
// int wan = num / 10000 % 10;
System.out.println(ge+" "+shi+" "+bai);
}
}
字符参与运算：ASCII
作用：字符和byte对应关系 为了让我们方便使用字符
byte、short、char 参与计算时 会提升为int
| 字符 | 数值 |
|---|---|
| 0 | 48 |
| 9 | 57 |
| A | 65 |
| Z | 90 |
| a | 97 |
| z | 122 |
例如：
int a=1;
char b='a';
sout(a+b); //b默认提升为int类型 1+97=98
自增自减运算符
| 符号 | 作用 | 说明 |
|---|---|---|
| ++ | 自增 | 变量的值加1 |
| – | 自减 | 变量的值减1 |
单独使用时，a++，++a，a–，--a相同。
参与运算时，a++ 先拿值在++，++a先++再拿值。
a-- 先拿值在–，--a先–再拿值。
例如：
int a=5;
int b=a++ + ++a +5; // 5 7 5
// 6
sout(b); //17
字符串参与加法运算
字符串参与加法运算得到的结果 也是一个字符串 也叫字符串拼接
从左往右执行 如果有括号先算括号内的
加号两边只要有字符串 结果就是字符串 例如:“你好” + 3 + 4 要考虑到 “你好” + 3结果是一个字符串 所以第二个加号两边存在字符串
sout(2+"你好"); //2你好
sout("你好"+3); //你好3
sout(2+3+"你好"); //5你好
sout(2+"你好"+3); //2你好3
sout("你好"+2+3); //你好23
sout("你好"+(2+3); //你好5
赋值运算符
| 符号 | 作用 | 说明 |
|---|---|---|
| = | 赋值 | a=10，将10赋值给变量a |
| += | 加后赋值 | a+=b，将a+b的值给a |
| -= | 减后赋值 | a-=b，将a-b的值给a |
| *= | 乘后赋值 | a*=b，将a×b的值给a |
| /= | 除后赋值 | a/=b，将a÷b的商给a |
| %= | 取余后赋值 | a%=b，将a÷b的余数给a |
扩展的赋值运算隐含了强制类型转换 记
例如：
short s = 1;
s+=1; //一次运算 相当于 s=(short)(s+1)
sout(s);
比较(关系)运算符
关系运算符就是用来描述两个变量或者常量之间的关系的。
| 符号 | 说明 |
|---|---|
| == | a==b，判断a和b的值是否相等，成立为true，不成立为false |
| != | a!=b，判断a和b的值是否不相等，成立为true，不成立为false |
| > | a>b，判断a是否大于b，成立为true，不成立为false |
| >= | a>=b，判断a是否大于等于b，成立为true，不成立为false |
| < | a<b，判断a是否小于b，成立为true，不成立为false |
| <= | a<=b，判断a是否小于等于b，成立为true，不成立为false |
逻辑运算符
注意: 假设下表中的a和b， 都是boolean类型的值。
| 符号 | 作用 | 说明 |
|---|---|---|
| & | 逻辑与 | a&b，并且的意思. 有false则整体为false, 都为true, 则整体为true. |
| | | 逻辑或 | a|b，或者的意思, 有true则整体为true, 都为false, 则整体为false. |
| ! | 逻辑非 | !a，取反的意思, 以前为true, 取反后为false, 以前为false, 取反后为true. |
| ^ | 逻辑异或 | a^b，异同的意思, 相同为false, 不同为true. |
短路逻辑运算符
在实际开发中, 并且, 或者这样的操作是非常多的, 但是上述的&(逻辑与), !(逻辑或)运算符没有短路效应, 所以效率相对较低, 针对这种情况, 我们可以使用&&(短路与), ||(短路或)来优化.
| 符号 | 作用 | 说明 |
|---|---|---|
| && | 短路与 | 作用和&相同，但是有短路效果, 前边出现false, 后边不执行. |
| || | 短路或 | 作用和|相同，但是有短路效果, 前边出现true, 后边不执行. |
解释
-
在短路与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与运算符就有这样的效果，可以提高效率。
-
同理在短路或运算中，一旦发现值为true，右边的表达式将不再参与运算。
短路和非短路之间的区别
- 逻辑与 和 短路与之间的区别
– 逻辑与&(也叫单与): 无论左边真假，右边都要执行。
– 短路与&&(也叫双与): 如果左边为真，右边执行；如果左边为假，右边不执行。
- 逻辑或 和 短路或之间的区别
– 逻辑或|(也叫单或): 无论左边真假，右边都要执行。
– 短路或||(也叫双或): 如果左边为假，右边执行；如果左边为真，右边不执行。
记忆: 在实际开发中, 我们用的最多的逻辑运算符就是: &&, ||, ! 记
例如：
public class Demo {
public static void main(String[] args) {
boolean x = true;
boolean y = false;
short z = 42; //真 假 42
if ((z++ == 42) && (y = true)) //真 真 43
z++; //真 真 44
if ((x = false) || (++z == 45)) //假 真 45
z++; //假 真 46
System.out.println("z=" + z);
}
}
三元运算符
三元运算符也叫三目运算符，即由三部分组成，格式如下：
(关系表达式) ? 表达式1：表达式2；
执行流程:
先执行关系表达式, 看其结果是true还是false.
如果是true, 则执行表达式1
如果是false, 则执行表达式2
例如：三个数字找出最大值
int num1=100;
int num2=111;
int num3=222;
int temp=num1>num2?num1:num2;
int max= temp?num3?temp:num3;
sout(max);
或：//可嵌套 不推荐
int max= (num1>num2?num1:num2)?num3?(num1>num2?num1:num2):num3;
流程控制语句
分类：
• 顺序结构
• 选择结构(if语句, switch.case语句)
• 循环结构(for循环, while循环, do.while循环)
顺序结构
顺序结构指的是代码是按照从上往下，从左往右的顺序,，依次逐行执行的,，且顺序结构也是Java程序的默认结构。
例如：
public class Demo {
public static void main(String[] args) {
sout("a");
sout("b");
sout("c");
sout("d");
sout("e"); // abcde
}
}
选择结构(if语句, switch.case语句)
主要分为以下三种:
if语句(也叫: 单分支)
if…else语句(也叫: 双分支)
if…else if语句(也叫: 多分支)
单分支
结构一般用来判断一种情况, 格式如下:
格式
if(关系表达式) {
//语句体;
}
执行流程:
先执行关系表达式，看其结果是true还是false。
如果是true，则执行大括号中的语句体。
如果是false， 则大括号中的语句体不执行。
例如：
public class Demo {
public static void main(String[] args) {
sout("开始了");
int time = 5;
if(time >= 0 && time <= 8) {
sout("早上好");
}
sout("其他语句");
}
}
双分支
双分支结构指的是if. else语句, 一般用来判断两种情况, 格式如下:
if(关系表达式) { //if的意思: 如果
//语句体1;
} else { //否则…
//语句体2;
}
执行流程:
先执行关系表达式， 看其结果是true还是false。
如果是true，则执行语句体1。
如果是false，则执行语句体2。
例如：
public class Demo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个整数: ");
int num = sc.nextInt();
if (num % 2 == 0) {
System.out.println(num + "是偶数");
} else {
System.out.println(num + "是奇数");
}
}
}
多分支
多分支结构指的是if. else if语句, 一般用来判断多种情况, 格式如下:
if(关系表达式1) {
//语句体1;
} else if(关系表达式2){
//语句体2;
} else if(关系表达式3){ //这里可以根据需求, 有多个else if语句
//语句体3;
} else {
//语句体n;
}
执行流程
先执行关系表达式1，看其结果是true还是false。
如果是true， 则执行语句体1, 整个if语句结束。
如果是false，则判断关系表达式2, 看其结果是true还是false。
如果是true， 则执行语句体2, 整个if语句结束。
如果是false， 则判断关系表达式3， …以此类推。
如果所有的关系表达式都不成立,，则执行else语句的语句体n，整个if语句结束。
例如：键盘输入小明考试成绩，
如果小明考试成绩为95~100奖励山地自行车一辆。
如果小明考试成绩为90~94奖励去游乐园一次。
如果小明考试成绩为80~89奖励变形金刚玩具一个。
如果小明考试成绩为0~79男女混合双打。
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入小明的考试成绩: ");
int score = sc.nextInt();
if (score >= 95 && score <= 100) {
System.out.println("奖励小明: 山地自行车一辆");
} else if(score >= 90 && score < 95) {
System.out.println("奖励小明: 游乐场玩儿一次");
} else if(score >= 80 && score < 90) {
System.out.println("奖励小明: 变形金刚玩具一个");
} else if(score >= 0 && score < 80){
System.out.println("奖励小明: 男女双混组合拳 + 扫帚棒法");
} else {
System.out.println("考试成绩录入有误.");
}
}
}
例如：键盘输入狗子年龄，狗子前两年每年相当于人类10.5年，之后每增加一年就增加四岁，那么狗子五岁相当于人类多少年龄？
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入狗狗的年龄：");
int dogAge = sc.nextInt();
if (dogAge==1){
System.out.println("相当于人类10.5岁");
}else if (dogAge==2){
System.out.println("相当于人类"+(int)(10.5*2)+"岁");
}else if (dogAge>2){
int temp=dogAge-2;
double age=temp*4+(int)(10.5*2);
System.out.println("相当于人类"+age+"岁");
}else {
System.out.println("输入有误，请重新上输入");
}
}
}
switch(byte,short,char,int,枚举,String)…case 值:…
格式：
switch(表达式) {
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
…
default：
语句体n+1;
[break;]
}
执行流程：
首先计算表达式的值。
依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉。
例如：键盘录入星期数，显示今天的减肥活动。
周一：跑步
周二：游泳
周三：慢走
周四：动感单车
周五：拳击
周六：爬山
周日：好好吃一顿
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
System.out.println("请输入星期数，显示今天的减肥活动");
Scanner sc = new Scanner(System.in);
int day = sc.nextInt();
switch (day) {
case 1:
System.out.println("跑步");
break;
case 2:
System.out.println("游泳");
break;
case 3:
System.out.println("慢走");
break;
case 4:
System.out.println("动感单车");
break;
case 5:
System.out.println("拳击");
break;
case 6:
System.out.println("爬山");
break;
case 7:
System.out.println("好好吃一顿");
break;
default:
System.out.println("输入有误，请重新输入");
}
}
}
循环语句
for循环
解决什么问题: 当一些需要重复执行的代码 可以循环
格式：
for(①初始化语句；②条件语句，③循环控制语句){
④循环语句体；
}
执行顺序：
1. 初始化语句①
2. 条件语句② 为true 继续往下执行，false循环结束
3. 循环语句体④
4. 循环控制语句③
5. 条件语句② 返回顺序第2步执行
例如：打印输出所有水仙花数。
public class Demo {
public static void main(String[] args) {
for (int i = 100; i <= 999; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
//int qian = num / 1000 % 10;
//int wan = num / 10000 % 10;
if (i == ge * ge * ge + shi * shi * shi + bai * bai * bai) {
System.out.println(i);
}
}
}
}
需求：在控制台输出所有的“水仙花数”，要求每行打印2个
public class Demo1 {
public static void main(String[] args) {
int count=0;
for (int i = 100; i <= 999; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
//int qian = num / 1000 % 10;
//int wan = num / 10000 % 10;
if (i == ge * ge * ge + shi * shi * shi + bai * bai * bai) {
System.out.print(i+" "); //print 不换行输出
count++;
if (count%2==0){
System.out.println(); //printlin 不换行输出
}
}
}
}
}
需求：求1-5之间的数据和，并把求和结果在控制台输出
public class Demo {
public static void main(String[] args) {
int sum=0;
for (int i = 1; i <= 5; i++) {
sum+=i;
}
System.out.println(sum);
}
}
需求：求1-100之间的偶数和，并把求和结果在控制台输出
public class Demo1 {
public static void main(String[] args) {
int sum=0;
for (int i = 1; i <= 100; i++) {
if (i%2==0){
sum+=i;
}
}
System.out.println(sum);
}
}
while循环
完整格式：
初始化语句①;
while (条件判断语句②) {
循环体语句③;
条件控制语句④;
}
执行流程：
1. 执行初始化语句①
2. 执行条件判断语句②，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
3. 执行循环体语句③
4. 执行条件控制语句思
5. 回到2继续
例如：需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
public class Demo {
public static void main(String[] args) {
int zf = 8844430;
double paper = 0.1;
int count = 0;
while (paper < zf) {
paper *= 2;
count++;
}
System.out.println(count);
}
}
在控制台打印10次HelloWorld
public class Demo {
public static void main(String[] args) {
int i = 0;
while(i < 10) {
System.out.println("Hello World!");
i++;
}
}
}
do…while循环
完整格式：
初始化语句①;
do {
循环体语句②;
条件控制语句③;
}while(条件判断语句④);
执行流程：
1. 执行初始化语句①
2. 执行循环体语句②
3. 执行条件控制语句③
4. 执行条件判断语句④，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
5. 回到2继续
例如：需求 通过do.while循环, 在控制台打印10次Hello World!
public class Demo {
public static void main(String[] args) {
int i = 1;
do{
System.out.println("Hello World! " + i);
i++;
}while(i <= 10);
}
}
三种循环之间区别
-
do…while循环和其他两个循环之间的区别
-
do…while循环是先执行一次, 后判断。
-
而其他两个循环都是先执行判断条件, 然后决定是否执行循环体。
-
-
for循环和其他两个循环之间的区别
- for循环执行结束后, 初始化条件就不能继续使用了。
- 而其他两个循环执行结束后, 初始化条件还可以继续使用.
死循环
在Java中, 死循环的写法格式主要有以下3种:
-
for(;