总结
大佬们好,我是一名正在学习Java的一个无名小辈！
至于为什么要学习这个Java有两点
第一点；因为自己比较喜欢这些东西，感觉很神秘很神奇，哈哈哈。
第二点；因为我是一个专科生，想学习一个技术，工资高，轻松的。
然后给你们讲讲我为什么要学习Java吧
在学校里面啥也没有学到，不是我说虽然我上的是专科，但是我想说专科真的是不好，可能这一会有人就说：那是你不好好学什么什么的，嘿嘿没关系，我想说如果，我说如果在大家在一个教室学习，别人都在忙着学习，你觉得你能闲住，如果是正常人的话，可能不会。但是专科学校，在一个教室亲身经历啊，我没有在吹，打游戏，搞暧昧，睡觉干什么的都有。老师呢装作什么都不知道。哈哈此处我笑了，我是一个专科生，说着这些不好的。但是这些都是事实，没有办法去改变。但是我想去改变我自己，怎么去丰富自己，充实自己。大二我找关系好的老师问，了解我出去该干什么。我也在网上了解，然后也就是在大二第一学期恰恰参加了一个比赛，了解到编程这一块的方面，嗯，当初我也接触了一些python，c这些方面的知识，然后我就想学习python这个编程，然后就完整网上搜学习这些方面的教育机构，第一个加我的是千锋给我打电话加微信，紧接着达内给我打电话是什么的，我当时我也不知道我是咋了我就选择了达内，然后就报名了，然后问我学习什么，我说python，她说好，然后也没有说我适合不适合，就这样报名了，当时报名的时候是在19年，然后就这样过了一年。突然千锋老师找我，然后我们就聊起来了，然后给我分析我适合学习什么，并且学习什么出去好找工作，并且我也是专科，不好找工作。然后给我推荐Java，和前端。然后我就心动了，当时她分析的也非常彻底，
真的很有道理，老师说python虽然好但是找工作有点困难，毕竟python面向的是人工智能，学历卡的死死的，而且都是一些有钱的公司。我蒙了我。此时我便吧达内报的名取消了，不是我善变哈哈，说的真的很有道理，达内就知道吧钱一交，万事大吉。虽然千锋那个老师离职了，但是是我应该好好谢谢她。
2020年注定是不平凡的一年，9月21日，千锋JavaEE-2008班开课了，没错我就是其中的一名学员，很荣幸认识这么多比我优秀很多很多的大佬，今天是学习的第一周，对于我一个初学者的总结如下，希望都你们有用。
前两天是对Java环境的安装，开班典礼什么的就不总结了哈哈哈
变量的三要素：
1)数据类型
2)变量名(遵循标识符的规则)
3)初始化值
A)基本数据类型:四类8种：
整数类型:(默认int),
byte:字节类型 占1个字节 取值范围;-128~127
short:短整型 占2个字节
int:整数 占4个字节
long:长整型 占8个字节
浮点类型:默认是double
单精度:float :占4个字节
双精度:double :占8个字节
字符类型
char: 占2个字节
布尔类型
boolean 占1个字节
B)引用数据类型:数组,接口,类(具体类,抽象类)
面向对象讲
JavaWEB/JavaEE:研究引用类型!
定义long类型的注意事项:
需要在当前变量值的加上标记:L或者l(建议大写L):描述当前变量是 长整型
定义float类型的注意事项:
在变量值的后面标记当前是一个单精度变量:F/f
class DataTypeDemo{
public static void main(String[] args){
//测试
//字节类型 byte
byte b = 100 ;
//byte b = 20 ; //重复定义变量 byte已经指定!
b = 20 ;
//字符串+任何数据=字符串
System.out.println("b:"+b) ;//b:值 +:字符串拼接符号
System.out.println("---------------------------------") ;
//short:短整型
short s = 100 ;
System.out.println("s:"+s) ;
System.out.println("---------------------------------") ;
//int:整数 占4个字节
//long:长整型 占8个字节
int i = 10000 ;
System.out.println("i:"+i) ;
System.out.println("---------------------------------") ;
//int i = 100000000000000000000; //过大的整数: 100000000000000000000
//超过了int类型的范围:需要使用long去接收
long ii = 1000000000000000000L ;
//标记当前这个数据是long类型,需要在当前初始值的后面加上标记:L,l(建议L)
System.out.println("ii:"+ii) ;
System.out.println("---------------------------------") ;
//浮点类型:默认double
//单精度:float
//双精度:double
double d = 12.34 ;
System.out.println(d) ;
System.out.println("---------------------------------") ;
//定义float类型
//float f = 12.56 ; //不兼容的类型: 从double转换到float可能会有损失
//需要在单精度的值的后面加上标记:F/f,标记单精度
float f = 12.56F;
System.out.println(f) ;
System.out.println("---------------------------------") ;
//字符变量:char
char ch1 = 'A' ;
char ch2 = '0' ;
char ch3 = 'a' ;
char c = '中' ; //中文存储:默认的编码格式:dos控制台:
//编码格式:
//gbk:中国中文编码表 :一个中文对两个字节
//gb2312:gbk升级版本(包含特殊的中文字符)
//utf-8:一个中文对应三个字节
//iso-8859-1:拉丁文码表
System.out.println(ch1) ;
System.out.println(ch2) ;
System.out.println(ch3) ;
System.out.println(c) ;
System.out.println("---------------------------------") ;
//布尔类型
//boolean
boolean flag = true ;
System.out.println(flag) ;
flag = false ;
System.out.println(flag) ;
//基本类型:四类八种
//引用类型: (重点)
//数组:...
//类
//代表:String :字符串类...
//接口 :有自己的写法规则
}
}
Java中运算符
-
算术运算符
-
赋值运算符
-
比较(关系)运算符
-
逻辑运算符 (使用居多)
-
位运算符(了解)
-
三元(三目)运算符(使用居多)
基本的算术运算符 +,-,*,/(默认:取值),%(取模:求余数) 扩展的算术运算符++，-- 分两种情况: 1)单独使用 结论: 无论++还是--在变量前面还是后面:都是对当前该变量值进行自增1或者自减1 应用场景:结合流程控制语句之循环语句去使用! 2)参与运算使用 如果++或者--在变量前面,先自增1或者自减1,然后运算! 如果++或者--在变量后面,先运算(赋值),然后在自增1或者自减1
class OperatorTest{
public static void main(String[] args){
//1)初始化a,b,c
int a = 10;
int b = 10;
int c = 10;
a = b++; // a=10, b = 11 , c = 10
c = --a; // a = 9 ,b = 11 , c = 9
b = ++a; // a = 10 ,b = 10, c = 9
a = c--; // a = 9 ,b = 10, 8
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
System.out.println("c:"+c) ;
}
}
赋值运算符:
基本的赋值运算符
=
int a = 10 ;
将10这个值赋值给int类型的变量a
注意事项:
=不能写成==:表示比较运算符 ==连接表达式最终true/false
扩展的赋值运算符(细节)
+=,*=,-=,/=,%=
class OperatorDemo{
public static void main(String[] args){
//赋值运算符
int a = 10 ; //将10这个值赋值给int类型的变量a
// int m == 20 ; //==:表示比较运算符 ==连接表达式最终true/false
int x = 20 ;
x += 10 ; //x = x + 10; //x = 30
System.out.println("x:"+x) ;
}
}
比较运算符
概念；无论是简单还是复杂的，最终结果要么true/false
注意；==一定不能写成
=也叫关系运算符
<,>,>=,<=,==（判断）,!=
class OperatorDemo{
public static void main(String[] args){
boolean flag = (x == y) ; //比较x和y是否相等
//boolean flag = x = y ; //y =4 赋值x,x就是4 不兼容的类型: int无法转换为boolean
System.out.println(flag);
}
}
逻辑运算符
基本的逻辑运算符：
逻辑单与 &（相同就相同ture/fakse，不相同就false）
逻辑单或 |（有一个对就对了，有一个错了就错）或
逻辑异或 ^（相同就错，不同就对）
逻辑非 ! （就像前面加-号，你对我就错，就是相当于负号吧）
逻辑双与 && （有false，则false，只要前面出现false就false，
后面不执行了，只是节省了运算资源，按顺序走）（短路效果）
逻辑双或 || （如果连接的表达式左边有true就true，后面也就不执行了按顺序走）
class OperatorDemo{
public static void main(String[] args){
//定义三个变量
int a = 3 ;
int b = 4 ;
int c = 5 ;
//逻辑单与 &
System.out.println((a>b) & (a>c)) ;//false & false = false
System.out.println((a<b) & (a>c)) ;//true & false = false
System.out.println((a>b) & (a<c)) ;//false & true = false
System.out.println((a<b) & (a<c)) ;//true & true = true
System.out.println("----------------------------") ;
//逻辑单或 |
System.out.println((a>b) | (a>c)) ;//false | false =false
System.out.println((a<b) | (a>c)) ;//true | false = true
System.out.println((a>b) | (a<c)) ;//false | true = true
System.out.println((a<b) | (a<c)) ;//true | true = true
System.out.println("----------------------------") ;
//逻辑异或
System.out.println((a>b) ^ (a>c)) ;//false ^ false = false
System.out.println((a<b) ^ (a>c)) ;//true ^ false = true
System.out.println((a>b) ^ (a<c)) ;//false ^ true = true
System.out.println((a<b) ^ (a<c)) ;//true ^ true = false
System.out.println("----------------------------") ;
//逻辑非!
// 应用场景:在登录/校验验证码等等
System.out.println(!(a>b)) ;//! false : true
System.out.println(!!(a>b)) ;
System.out.println(!!!(a>b)) ;
}
}
class OperatorDemo2{
public static void main(String[] args){
//定义三个变量
int a = 3 ;
int b = 4 ;
int c = 5 ;
//逻辑双与 &&
System.out.println((a>b) && (a>c)) ;//false & false = false
System.out.println((a<b) && (a>c)) ;//true & false = false
System.out.println((a>b) && (a<c)) ;//false & true = false
System.out.println((a<b) && (a<c)) ;//true & true = true
System.out.println("-----------------------------") ;
//定义两个变量x,y
int x = 3 ;
int y = 4 ;
System.out.println("x:"+x) ;
System.out.println("y:"+y) ;
System.out.println("-----------------------------") ;
//true && false
//System.out.println(((++x) ==4) && ((--y) == 4) ) ; //false
//false && true
//逻辑双与&&的短路效果
System.out.println(((x++) == 4) && ((y--) == 4)) ;
System.out.println("x:"+x) ;//4
System.out.println("y:"+y) ;//还是4:没有变化
}
}
位运算符（了解）
位与：& （有0则0，不一样就是0）
位或：| （有1则1，有一个1就为1）
位异或：^（相同为0，不同则为1）
~ (反码；按位取反；全部1变0，0变1)；（按位取反（1变0，0变1））
移动符号
将最高符号位d'qi
移动符号
左移:<<左移动,将最高符合位丢弃掉,在右边补齐
特点:将<<符号左边的数据乘以2的移动次幂
右移:>> :
右移动,如果最高符号位为0,左边补0,如果最高符号位为1,左边补齐1
特点:将>>符号左边的数据除以2的移动次幂
无符号右移: >>>
向右移动,无论最高符合位为0还是1,左边补0!
class OperatorDemo{
public static void main(String[] args){
//位与&
System.out.println(3 & 4) ;
//位或|
System.out.println(3 | 4) ;
//位异或
System.out.println(3 ^ 4) ;
//反码~
System.out.println(~3) ;
/*
0
7
7
-4
*/
}
}
/*
3 :11
4 :100
位与:&:有0,则0
3 & 4
00000000 00000000 00000000 00000011
位与& 00000000 00000000 00000000 00000100
-------------------------------------------------- -----
00000000 00000000 00000000 00000000
结果:0
位或:|
有1,则1
3 | 4
00000000 00000000 00000000 00000011
位或| 00000000 00000000 00000000 00000100
------------------------------------------------------------------
00000000 00000000 00000000 00000111
结果:7
位异或:相同则为0,不同则为1
3 ^ 4
00000000 00000000 00000000 00000011
位异或^ 00000000 00000000 00000000 00000100
-------------------------------------------------------------
00000000 00000000 00000000 00000111
结果:7
~3
反码:按位取反 (1变0,0变1)
00000000 00000000 00000000 00000011(原,反,补码)
~
-------------------------------------------------------
11111111 11111111 11111111 11111100 (补码)
- 1
------------------------------------------------------
11111111 11111111 11111111 11111011 (反码)
---------------------------------------------------------------
最高符合位不变,其他数值位按位取反:0变1,1变0
10000000 00000000 00000000 00000100 (原码)
- 4
*/
三元（三目）运算符
三目运算符<------------
计算用int
比较用boolean
%；取余
格式
(表达式) ? 执行true的结果:执行false的结果
执行流程:
1)先判断表达式是否成立,如果成立,执行true的结果
2)如果不成立,执行false的结果
class OperatorDemo{
public static void main(String[] args){
//定义两个变量 (变量写死)
int a = 20 ;
int b = 10 ;
//(表达式) ? 执行true的结果:执行false的结果
//定义变量max
int max = (a > b)? a: b ;
System.out.println("两个数据中的最大值是:"+max) ;
//两个数据中的最大值是:20
System.out.println("--------------------------") ;
//定义两个变量,比较两个数据是否相等 (最终结果类型:boolean)
int m = 100 ;
int n = 100 ;
//boolean flag = (m==n)? true :false ;
//简化:
boolean flag = m==n;
System.out.println("flag:"+flag) ;
}
}
如何去使用文本扫描器（键盘录入）
使用步骤:
1)导包:(目前写在class上面) 固定写法
格式 import java.util.Scanner; (用哪个类,导哪个类)
2)固定格式:
创建键盘录入对象
Scanner 键盘录入的对象名 = new Scanner(System.in) ;
3)友情提示: 输出语句 "请您输入一个数据:"
4)接收数据 (接收int类型数据)
int 接收的变量名= 键盘录入的对象名.nextInt() ; //录入下一个int类型的数据
5)输出/完成业务操作
/*
需求:
键盘录入两个数据,求两个数据中的最大值 (默认int类型)
*/
import java.util.Scanner;
class ScannerTest{
public static void main(String[] args){
//1)导包
//2)创建键盘录入对象
Scanner scanner = new Scanner(System.in) ;
//3)提示并接收数据
System.out.println("请您输入第一个数据:") ;
int num1 = scanner.nextInt() ;
System.out.println("请您输入第二个数据:") ;
int num2 = scanner.nextInt() ;
//4)两个数据中的最大值
//三元运算符进行比较
int max = (num1 > num2) ? num1: num2 ;
System.out.println("两个数据的最大值是:"+max) ;
}
}
6.流程控制语句
if语句的格式:
第一种格式1
if(表达式){
语句;
}
执行流程:
判断表达式是否成立,如果是true,成立,执行语句;
如果不成立,不执行!
if语句整体的注意事项:
1)有if的地方需要有一对{}
有{}的地方不能分号;
if语句整体的注意事项:
1)有if的地方需要有一对{}
有{}的地方不能分号;
2)在一个方法中(main() )定义一个{xxxd代码}---->局部代码块 (了解)
作用:限定局部变量的生命周期
局部变量:在方法定义中的变量---->随着方法的调用完毕而消失!
内存中:GC 垃圾回收器(自动回收这些对象或者变量)
if格式2:
if(表达式){
语句1;
}else{
语句2;
}
执行流程:
1)首先判断表达式是否成立,如果是true,执行语句1
2)如果不成立,执行语句2;
if语句格式2的嵌套:
if(表达式){
//表达式成立
if(表达式1){
语句1;
}else{
语句2;
}
}else{
//不成立
if(表达式11){
语句11;
}else{
语句22;
}
}
执行流程:
首先判断外层if中表达式是否成立,
如果成立,执行表达式2是否成立
如果表达式2成立,执行语句1;否则,执行语句2;
外层if中表达式不成立,就执行else中的语句
首先判断表达式11是否成立,如果成立,执行语句11,
否则执行语句22;
//导包
import java.util.Scanner ;
class IfTest{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示,并接收数据
System.out.println("请输入第一个数据:");
int a = sc.nextInt() ;
System.out.println("请输入第一个数据:");
int b = sc.nextInt() ;
System.out.println("请输入第一个数据:");
int c = sc.nextInt() ;
//操作判断
//方式1:中间变量的方式+三元运算符
int temp = (a>b) ? a: b ;
//使用max变量接收
int max = (temp > c ) ? temp : c ;
System.out.println("三个数据中的最大值是:"+max) ;
System.out.println("---------------------------");
//方式2:三元运算符一步走:
int max2 = (a>b) ? ((a > c) ? a: c) :((b > c) ? b : c) ;
System.out.println("三个数据中的最大值是:"+max2) ;
System.out.println("---------------------------");
//方式3:使用if语句格式嵌套
//定义一个变量max3
int max3 ;
if( a > b){
//a>b成立
if(a > c){
//a比c大
max3 = a ;
}else{
//c比a大
max3 = c ;
}
}else{
//不成立
if(b > c){
//b比c大
max3 = b ;
}else{
//c比b大
max3 = c ;
}
}
System.out.println("三个数据中的最大值是:"+max3) ;
}
}
if语句的第三种结构:
if(表达式1){
语句1;
}else if(表达式2){
语句2;
...
...
...
}else{
语句n+1 ;
}
执行流程:
1)首先判断表达式1是否成立,如果成立,执行语句1,if语句结束!
2)如果表达式1不成立,再次判断表达式2是否成立,如果成立,执行语句2,语句结束!
3)如果上述表达式都不成立,就执行else中的语句,if语句结束!
//导包
import java.util.Scanner ;
class IfDemo4{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示,并接收数据
System.out.println("请您录入学生的成绩: ") ;
int score = sc.nextInt() ;
/*
if(score >= 90 && score <=100){
System.out.println("该学生成绩十分突出...") ;
}else if(score >=80 && score< 90){
System.out.println("该学生成绩优秀...") ;
}else if(score >= 70 && score <80){
System.out.println("该学生成绩良好...") ;
}else if(score >= 60 && score <70){
System.out.println("该学生成绩及格...") ;
}else{
System.out.println("该学生成绩不及格...") ;
}
*/
/*
写好一个程序:自己测试
测试错误数据,正确数据以及边界数据
目的:让程序更符合真实场景,保证用户的体验!
*/
if(score >100 || score < 0){
System.out.println("您录入的是一个非法数据...") ;
}else if(score >= 90 && score <=100){
System.out.println("该学生成绩十分突出...") ;
}else if(score >=80 && score< 90){
System.out.println("该学生成绩优秀...") ;
}else if(score >= 70 && score <80){
System.out.println("该学生成绩良好...") ;
}else if(score >= 60 && score <70){
System.out.println("该学生成绩及格...") ;
}else{
System.out.println("该学生成绩不及格...") ;
}
}
}
switch语句
switch语句的格式
switch(表达式){
case 值1:
语句1;
break ;
case 值2:
语句2;
break ;
...
...
default:
语句n;
break ;
}
执行流程:
1)先判断表达式的值它和case语句值1,是否匹配
如果匹配,执行语句1,遇见break ,switch语句结束了!
2)如果值1不匹配,继续判断值2是否和表达式中的值是否匹配,如果匹配,执行语句2
遇见break,switch语句结束!
3)如果上面的所有case语句都不匹配,执行default语句,执行语句n,直接结束
面试题:
switch表达式可以是byte类型吗?
可以是String类型吗?
可以是char类型吗?
可以是枚举类型吗?
switch(表达式)---->本身可以使用的类型:byte,short,char,int类型
JDK5以后可以枚举enum(引用类型--->定义常量) 后面讲(Java高级部分多线程Thread类: State(枚举类型))
JDK7以后:可以使用String类型
switch注意事项
switch语句使用的注意事项:
1)switch语句中的case语句后面跟的常量值,不能跟变量!
对比:javascript:switch语句 中的case可以是常量也可以变量
2)case语句中的break不能轻易省略,否则就会造成"case穿透"
如果没有写break,跟下面case值不进行比较,直接运行语句,直到遇见break结束!
3)switch中的default语句:书写位置默认是在末尾,但是它也可以在switch语句中的任何位置,但是不影响执行流程
都需要先跟case中的值进行比较,如果都没有匹配,都需要执行default...
如果default在语句的末尾,break可以省略,如果在语句中的话,不建议省略break ;
4)关于switch语句的结束问题:
1)遇见break (中断,结束的意思) ,switch语句结束
break:属于跳转控制语句中一种:两种场景:switch中/循环语句中
2)语句默认执行到末尾!
键盘录入月份的值,判断季节(switch语句完成)
3,4,5 春季
6,7,8 夏季
9,10,11 秋季
12,1,2 冬季
//导包
import java.util.Scanner ;
class SwitchTest2{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收数据
System.out.println("请输入一个月份的值:") ;
int month = sc.nextInt() ;
//方式1:普通方式
/*
switch(month){
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 ;
case 8:
System.out.println("夏季") ;
break ;
case 9:
System.out.println("秋季") ;
break ;
case 10:
System.out.println("秋季") ;
break ;
case 11:
System.out.println("秋季") ;
break ;
case 12:
System.out.println("冬季") ;
break ;
default:
System.out.println("非法数据!!") ;
break ;
}
*/
//方式2:利用case穿透
switch(month){
case 1:
case 2:
case 12:
System.out.println("冬季");
break ;
case 3:
case 4:
case 5:
System.out.println("春季");
break ;
case 6:
case 7:
case 8:
System.out.println("夏季");
break ;
case 9:
case 10:
case 11:
System.out.println("秋季");
break ;
default:
System.out.println("非法数据!!!");
break ;
}
}
}
for循环
循环结构语句分类:
for循环
while循环
do-while循环
for循环的格式:
for(初始化语句;条件表达式;步长语句){
循环体语句;
}
执行流程:
1)初始化语句给变量进行赋值,只执行一次
2)判断这个条件表达式是否成立,
如果成立,就执行循环体语句,在去执行步长语句 (++,--)
3)再次判断条件表达式是否成立,如果成立,继续上面执行方式...
...
...
4)一直循环到条件表达式不成立的时候,for循环结束!
/*
求:1-10之间的和 (求和思想)
分析:
1-10之间的和:
0 + 1 = 1
1 + 2 = 3 ;
3 + 3 = 6;
6 + 4 = 10 ;
10 + 5 = 15 ;
15 + 6 = 21 ....
...
两个加数:
第一个加数:是上一次计算的结果:和
第二个加数:就是当前数据本身(1,2,3,4,5,6...)
步骤:
1)定义一个最终的结果变量 :最终的一个值 int sum = 0 ;
2)将1,..10之间的数据遍历(一一获取出来)
3)将当前sum值一次和数据本身做一个 +=
举例:
int sum = 0 ;
sum += 1 ;--> sum = sum + 1 ;
sum += 2 --->sum = sum + 2
sum =1 + 2 = 3
啥也不说了，上代码
class ForTest2{
public static void main(String[] args){
//原始的做法
System.out.println(1+2+3+4+5+6+7+8+9+10) ;
//上面代码:写麻烦
//求和思想
//定义一个最终结果变量
int sum = 0 ;
for(int x = 1 ; x <= 10 ; x ++){
//x =1,2,3,4,5,6,7,8,9,10
sum = sum + x ; //循环体语句
//sum = 0 + 1 ; //sum = 0,x = 1
//sum = sum + 2 //sum = 1 ,x = 2 --- 3
//sum = sum + 3
//0 + 1 = 1
// 1+ 2 = 3 ;
//3 + 3 = 6
//....
//sum += x ;
}
System.out.println("1-10之间的和是:"+sum) ;
}
}
详情怎么样，请关注我
带你们走进一个专门写bug的程序猿的生活
397
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
