Java入门的基础学习

前言

Java 语言最初由 Sun Microsystems 公司的 James Gosling(Java之父） 和他的团队在 1991 年开始开发，当时名为 Oak，目的是用于嵌入式设备编程。但由于 Oak 名称已被注册，1995 年正式更名为 Java。2006 年，Sun 公司将 Java 开源，进一步推动了其发展。2010 年，Oracle 公司收购 Sun，Java 的开发和维护权也随之转移到 Oracle。
java最新版本网站

一 初始Java

我们先来了解java的第一个第一个代码,打印出hello world

public class test {public static void main(String[] args) {System.out.println("hello world");}
}

输出结果如下

源⽂件（扩展名为*.java)：源⽂件带有类的定义。类⽤来表⽰程序的⼀个组件，⼩程序或许只会有⼀个类。类的内容必须包含在花括号⾥⾯。
类：类中带有⼀个或多个⽅法。⽅法必须在类的内部声明。
⽅法：在⽅法的花括号中编写⽅法应该执⾏的语句。
分析我们第一个代码

可以看出Java的main函数和打印函数都比较长
当然这个都是快捷键的
我们的main方法直接输入main + 按一下ENTER回车键就可以直接出来
输出的话我们直接输入sout + 按一下ENTER回车键就可以直接出来
这样的话我们在编写代码时间会大大降低
下面我们介绍Java的数据类型

二 Java数据类型和变量

1.字面常量

上面我们输出hello world的的程序中System.out.println(“hello world”)；
这里输出中"hello world"就是字面常量。
常量就是在运行期间，无法改变的量

public class test {public static void main(String[] args) {System.out.println("hello world");System.out.println(100);System.out.println(3.14);System.out.println('a');System.out.println(true);System.out.println(false);}
}

1.字符串常量：必须要用 " " 括起来的，⽐如"12345"、"hello"等。
2. 整型常量：程序中直接写的数字，⽐如：10，20
3. 浮点数常量：程序中直接写的⼩数，⽐如：3.14、5.21
4. 字符常量：由单引号括起来的当个字符，⽐如：‘A’、'C'
5. 布尔常量：只有两种true和false
等等

上面的字符串、整型、浮点型、字符型以及布尔型，在Java中都是数据类型

2.数据类型

Java有自己的数据类型，主要分为基本数据类型和引用数据类型

基本数据类型

基本数据类型，主要分四类：整型、浮点型、字符型和布尔类型
八种类型：

数据类型	关键字	占用空间	范围
字节型	byte	1个字节	-128~ 127
整型	int	4个字节	-2^31 ~ 2^31-1
短整型	short	2个字节	-32768 ~ 32767
长整型	long	8个字节	-2^63 ~ 2^63-1
单精度浮点型	float	4个字节	一般不关注
双精度浮点型	double	8个字节	一般不关注
字符型	char	2个字节	0 ~ 65535
布尔类型	boolean	没有明确规定	true和false

这里的浮点型数字在存储的时候比较复杂，所以我们不关注
整型默认为int型，浮点型默认为double

引用数据类型

在Java中字符串就是引用数据类型，那在Java中字符串如何定义呢
需要使用String来定义，注意这里的S是大写

public class test {public static void main(String[] args) {String str = "hello world";System.out.println(str);}
}

输出结果如下

3.变量

除了常量以为，也有变量，就像生活中的温度，体重等等会变化的量，在Java中这些被称为变量

数据类型    变量名    =    初始化；

例如：

public class test{public static void main(String[] args) {int a = 10;a=100;//修改数值char ch = 'c';double c = 3.14;boolean d = true;//输出，快捷键soutSystem.out.println(a);System.out.println(ch);System.out.println(c);System.out.println(d);}
}

运行结果

整型变量

int整形

public class test{public static void main(String[] args) {int a = 10;a = 100;System.out.println(a);//int 数据的范围//-2147483648 - 2147483647System.out.println(Integer.MIN_VALUE);System.out.println(Integer.MAX_VALUE);
}

这里打印出了int类型所能存储数据的范围，我们在初始化时候不能超过其范围
int 类型占4个字节
变量在使⽤之前必须要赋初值，否则编译报错
int的包装类型为Integer

short和long类型

public class test{public static void main(String[] args) {long a = 10l;//我们同长在后面加上l，//long类型System.out.println(a);//-9223372036854775808 - 9223372036854775807System.out.println(Long.MIN_VALUE);System.out.println(Long.MAX_VALUE);short b = 20;//short类型System.out.println(b);//-32768 - 32767System.out.println(Short.MIN_VALUE);System.out.println(Short.MAX_VALUE);}
}

短整型short 占2个字节，长整型long占8个字节
short范围-32768~32767  long范围 -2^63~(2^63)-1
short包装类型为Short  long包装类型为Long
我们在创建long类型变量时候通常需要在变量后加上l或者L

浮点型变量

单精度浮点型和双精度浮点型

public class test {public static void main(String[] args) {//浮点型数据//浮点型默认是double类型double d = 1.2;//创建float类型时候，必须在数据后面加上ffloat c = 1.4f;//float a = 1.2;这个是错误的System.out.println(d);System.out.println(c);System.out.println(Float.MIN_VALUE);System.out.println(Float.MAX_VALUE);}
}

运行结果如下

这里float 类型的数据后面没有加f，直接报错了

double占8个字节，float占4个字节
浮点数与整数在内存中的存储⽅式不同，不能单纯使⽤的形式来计算
double的包装类型为Double，float的包装类型为Float
我们创建浮点型数据是默认为double的，如果需要创建float类型数据，需要在后面加上f
我们一般优先使用double，因为float对应的范围精度较小

字符型变量

字节型和字符型

public class test {public static void main(String[] args) {byte a =3;System.out.println(a);System.out.println(Byte.MIN_VALUE);System.out.println(Byte.MAX_VALUE);//字符类型char c1='C';char c2='L';System.out.println(c1);System.out.println(c2);//这里的字符是占两个字节char c3 = '三';//我们知道汉字是占两个字节，我们使用char来存储汉字并没有出错//并且还是可以打印的//所以char是占两个字符System.out.println(c3);}
}

我们使用了一个汉字在存储时候占2个字节，所以这里没有报错，可以知道char在Java中占2个字节

byte在任何系统下都占1个字节,char在任何系统下都占2个字节
byte的范围是：-128~127，char的范围为：0 ~ 65535
byte的包装类型为Byte，char的包装类型为Character

布尔型变量

我们生活中有真假的存在，Java中也存在这种数据类型就是boolean类型

public class test {public static void main(String[] args) {boolean a = true;boolean b = false;//boolean c = 1;//这会直接报错System.out.println(a);System.out.println(b);}
}

运行结果如下

boolean类型只有true表示真 和 false表示假 这两种结果
不存在1为真 ，0 为假的情况，因为int和boolean两种类型不能相互转化

就像下面这个代码是错误的
int和boolean不能进行转化

4.类型转化和提升

类型转化

自动类型转化
自动类型转化就是在编译器编译代码时候会自动处理，两个不同类型的数进行计算会自动将小范围向大范围转化，不会自动向小范围转化。

public class test {public static void main(String[] args) {int a = 10;long b = 20;b = a;//nt-->long，数据范围由⼩到⼤，隐式转换//a = b;//错误的，不可以long - int 转换//只能小转化为大System.out.println(b);}
}        

这里我们在进行赋值的时候 int 转化为了 long 进行赋值
但是我们不可以long 向 int 类型转化，大范围不可以自动转化为小范围
就像下面是编译的时候会出错

强制类型转化
自动类型转化不可以小范围转化为大范围，而强制类型转化，可以将大范围转化为小范围

public class test {public static void main(String[] args) {int a = 10;long b = 100L;b = a; // int-->long，数据范围由⼩到⼤，自动类型转化a = (int)b; // long-->int, 数据范围由⼤到⼩，需要强制类型转化，否则编译失败float f = 3.14F;double d = 5.21;d = f; // float-->double，数据范围由⼩到⼤，自动类型转化f = (float)d; // double-->float, 数据范围由⼤到⼩，需要强制类型转化，否则编译失败byte b1 = 100; // 100默认为int，没有超过byte范围，自动类型转化byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显⽰转换，否则报错}
}

自动类型转化在进行赋值的时候，可将小范围的数赋值给大范围的
强制类型转化通常用于，将大范围转化为小范围，但这可能会有数据的丢失
强制类型转化不一定成功，两个毫不相干的两个数不能相互转化

类型提升

int 和 long 之间的提升

public class test {public static void main(String[] args) {int a = 10;long b = 20;//int e=c+d;//这样是错误的//在进行运算的时候，会转化为类型较大的那一个long e = c+d;System.out.println(e);}
}

这里可以用long类型的数据来接收，这两个整数的相加，但是不可以用int 类型的数据来接收，除非强制类型转化
不同类型的数据混合运算,范围⼩的会提升成范围⼤的

byte的提升

public class test {public static void main(String[] args) {byte a = 1;byte b = 2;//byte c =a+b;//错误int d = a + b;byte c = (byte)(a+b);//但不可以超过范围System.out.println(c);System.out.println(d);}
}

这里的byte的运算不可以简单认为这两个字节运算结果还是byte字节，这两个数在进行运算的时候，会先将a和b转化为int类型在进行运算。
因为我们的计算机在存储时候，是4个字节存储的，所以低于4个字节的像short和byte低于4个字节的类型,会先提升成int,再参与计算。

三 运算符

1.算数运算符

基本的四种运算符：加减乘除取模（+ - * / %)

public class test {public static void main(String[] args) {int a = 20;int b = 10;System.out.println(a+b);System.out.println(a-b);System.out.println(a*b);System.out.println(a/b);System.out.println(a%b);}
}

这里我们知道这里的所有都是二元操作符，都是必须需要两个操作数
这里我们的int / int的结果还是int类型

/ 和 %运算符只有操作数中有浮点数结果才会是浮点数，否则结果就只能是整数，可能会导致数据的丢失
但我们的%运算符通常使用整数

public class test {public static void main(String[] args) {int a = 3;int b = 2;double c = 2.0;System.out.println(a/b);System.out.println(a/c);System.out.println(a%b);System.out.println(a%c);}
}

做除法和取模时，右操作数不能为0
如果右操作数为0的话，编译器会报错

增量运算符+= -= *= /= %=

public class test {public static void main(String[] args) {int a = 3;a += 3;//相当于a=a+3;System.out.println(a);//输出6a -= 3;System.out.println(a);//输出3a *= 3;System.out.println(a);//输出9a /= 3;System.out.println(a);//输出3a %= 3;System.out.println(a);//输出0}
}

这里的 a+=3;相当于a=a+3;其他的操作符同理
那这两种写法有什么区别呢

public class test {public static void main(String[] args) {int b = 3;double c = 2.3;b+=c;System.out.println(b);//b=b+c;//编译器会报错}
}

我们使用两种类型进行计算，发现并没有报错，但是数据有所丢失
输出结果如下

就像换成b = b+c的话，编译器会报错

增量运算符在计算的时候，可以不进⾏强制类型转换，使用这种运算符可以不强制类型转化就可以运算，但是结果可能会有所丢失

⾃增/⾃减运算符 ++ –

public class test {public static void main(String[] args) {int a = 3;a++;//4System.out.println(a++);//4System.out.println(a);//5++a;//6System.out.println(++a);//7}
}

我们有前置++，-- 和后置++,–
这两种有所区别前置++先将数值赋给它，在进行++，后置++是先++操作，在进行赋值
就像这里的输出a++的话，先输出a的值在进行++,输出++a的话，是先将a的值加1在进行输出

2.关系操作符

关系运算符主要有六个: == != < > <= >= ,返回的结果只有true和false两种类型

public class test {public static void main(String[] args) {int a = 10;int b = 20;// 在Java中 == 表⽰相等System.out.println(a == b); // falseSystem.out.println(a != b); // trueSystem.out.println(a < b); // trueSystem.out.println(a > b); // falseSystem.out.println(a <= b); // trueSystem.out.println(a >= b); // false}
}

我们要注意=是赋值运算符，==才是判断两边是否相等的
如果我们需要判断一个数 3<a<5，在Java中如何表示呢

3.逻辑运算符：&&，||，！

逻辑与&&

表达式1&&表达式2

表达式1	表达式2	运行结果
真	真	真
真	假	假
假	真	假
假	假	假

语法规则：表达式1&&表达式2，左右表达式必须是boolean类型的结果。返回只有true和false两种类型
两个表达式都为真，结果才是真，只要有⼀个是假，结果就是假。
逻辑或||

表达式1 || 表达式2 

表达式1	表达式2	运行结果
真	真	真
真	假	真
假	真	真
假	假	假

表达式中只要有一个为真，结果就是真。
逻辑非！

!表达式

表达式	结果
真	假
假	真

表达式为真，结果为假
表达式为假，结果为真

下面我们代码来演示一下

public class test {public static void main(String[] args) {int a = 10;int b = 20;System.out.println(a<=10&&b==20);//都为真才为真System.out.println(a>10||b<20);//一个为真就为真System.out.println(!true);//!true就为falseSystem.out.println(a!=10&&b==20);System.out.println(a!=10||b==20);}
}

运行结果如下

逻辑与&&两边都为真才为真
逻辑或||两边都为假才为假
逻辑非！真变假，假变真

短路问题
我们上面的&&和||都有短路问题
我们来分析下面的代码

public class test {public static void main(String[] args) {System.out.println(10>20&&10/0==0);System.out.println(10<20||10/0==0);}
}

我们看上面的代码，肯定有人说这个代码错误，上面刚说过 / 的右操作符不可以为0，除数不可以为0，实则不然，这个代码是可以正常运行的。
运行结果如下

我们要注意：

逻辑与&&在运算的时候，如果左边表达式为假，右边的表达式不会进行计算
逻辑非||在运算的时候，如果左边表达式为真，右边的表达式不会进行运算
就像上面的10>20为假，并且是逻辑与&&运算符，那右边不计算
10<20为真，并且是逻辑或||运算符，那右边不计算

&和|
存在&与|这两个操作符，如果他们返回值为boolean类型，也就是只有true和false两种结果的话，它们可以像逻辑&&和逻辑||参与逻辑运算

public class test {public static void main(String[] args) {System.out.println(10>20&&10/0==0);System.out.println(10<20||10/0==0);System.out.println(10>20&10/0==0);//运算出错System.out.println(10<20|10/0==0);//运算出错}
}

&和|并不会出现短路问题，两边的表达式都会计算，不论左边为真还是为假，通通都要计算

4.条件操作符(三目操作符）

 表达式1 ? 表达式2 : 表达式3如果表达式1为真，返回表达式2,反之返回表达式3

public class test {public static void main(String[] args) {int a = 10;int b = 20;int max = a>b? a:b;System.out.println(max);}
}

输出结果如下

但我们这里要注意表达2和表达式3必须是相同类型，否则程序会报错，如果是自动类型转化的话不会报错

public class test {public static void main(String[] args) {int a = 10;double b = 20.0;//int max = a>b?a:b;//这里程序是错误的double max = a>b?a:b;System.out.println(max);}
}

输出结果如下

这里如果我们可以发生小范围转化为大范围的话，这样的自动类型转化是不会报错的，但是如过这里使用int类型来接收的话，程序是错误的。

所以我们在使用表达式的时候都要注意其类型是否相符

四 分支语句

Java中存在if，swith用于分支语句，while ，for，do-while用于循环

1. if语句

if(布尔表达式）{表达式1；
}else{表达式2；
}
这里的话如果布尔表达式为真(true)，执行表达式1，反之则执行表达式2

例如这里小明，如果小明这次考试考了90分及以上就奖励他，如果没有没奖励

public class test {public static void main(String[] args) {int score = 90;if(score>=90){System.out.println("奖励");}else{System.out.println("没奖励");}}
}

输出结果如下

嵌套if - else（if和else相匹配）

if(布尔表达式1){// 语句1 
}else if(布尔表达式2){// 语句2 
}else{
表达式1成⽴，执⾏语句1，否则表达式2成⽴，执⾏语句2，否则执⾏语句3

我们可以多层嵌套，例如我们给学生成绩分等级
• 分数在[90,100]之间的，为优秀
• 分数在[80,90)之前的，为良好
• 分数在[70,80)之间的，为中等
• 分数在[60, 70)之间的，为及格
• 分数在[ 0, 60)之间的，为不及格
• 其他的分数为错误数据

public class test {public static void main(String[] args) {int score = 90;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 if (score >= 0 && score < 60) {System.out.println("不及格");} else {System.out.println("数据错误");}}
}

例题：闰年判断
口诀：四年一闰，百年不闰，四百年再闰
1.世纪年能被400整除的是闰年。(如2000年是闰年，1900年不是闰年)
2.普通年能被4整除；且不能被100整除的为闰年。（如2004年就是闰年，1901年不是闰年）

//闰年判断
public class test {public static void main(String[] args) {int year = 2000;if (year % 100 == 0) {// 判定世纪闰年if (year % 400 == 0) {System.out.println("是闰年");} else {System.out.println("不是闰年");}} else {// 普通闰年if (year % 4 == 0) {System.out.println("是闰年");} else {System.out.println("不是闰年");}}}
}

上面代码较长，我们可以使用逻辑与&&与逻辑或||进行简化
我们已经知道就两种情况是闰年，我们直接放入

public class test {public static void main(String[] args) {int year = 2000;if((year%4==0&&year%100!=0)||(year%400==0)){System.out.println("是闰年");}else {System.out.println("是闰年");}}
}

if和else语句后面必须加上大括号吗？

public class test {public static void main(String[] args) {int x = 10;int y = 20;if (x == 10)if (y == 10)System.out.println("aaa");elseSystem.out.println("bbb");}
}

我们可以看到，这里的else是与第二个if对齐的，因为这里我们满足第一个条件x=10，但是第二个条件不满足，但是打印了bbb，如果和第一个对齐的结合的话就不会打印了，else是和最接近的if匹配
如果我们不写大括号的话，这里只能写一条语句，并且我们的逻辑关系也不清楚
不建议这么写，最好加上⼤括号

2. switch语句

switch(表达式){case 常量值1:语句1;[break;]case 常量值2:语句2;[break;]...default:内容都不满⾜时执⾏语句;[break;]
}

1.我们是先算出表达式的值
2.在进行和case的值比较，一旦有符合的语句就执行，知道遇到break结束
3.如果没有满足的就会执行default语句下面的内容
例题：我们输出星期几

public class test {public static void main(String[] args) {int day = 1;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("输入错误");break;}}
}

我们要注意这里的case语句中不可以出现两个相同的数值
并且这里case后面的类型可以为常量值是基本类型：byte、char、short、int
引⽤类型：String常量串、枚举类型
但是不可以使用long ，float和double类型

使用了double类型报错了
我们这里的break虽然可以省略，但是我们一般不会省略，因为这样可能会出多分支选择的情况

public class test {public static void main(String[] args) {int  day = 1;switch (day){case 1:System.out.println("星期一");case 2:System.out.println("星期二");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("输入错误");break;}}
}

这里如果我们省略了break的话，我们先找到语句，找到对应语句后，直到遇到break才截止，在没遇到break之前的语句都会执行，这样可能会导致结果输出错误

五 循环语句

循环语句，就是一直重复做一件相同的事情，直到遇到截止未知2

1. while循环

基本语法格式

while(循环条件) {循环语句;
}

这里的循环条件为true,则执⾏循环语句;否则结束循环
使用时要注意这里如果不加大括号的化和if语句一样只能放一条语句
所以我们在使用的时候，建议不要省略大括号
例题：打印1~ 10之间的数

public class test {public static void main(String[] args) {int num = 1;//初始化while(num<=10){//判断System.out.println(num);num++;//调整}}
}

运行结果如下

例题：计算1 ~ 100的和

public class test {public static void main(String[] args) {int num = 1;int sum = 0;while(num<=100){sum+=num;num++;}System.out.println(sum);}
}

运行结果如下

2. for循环

for(表达式1;布尔表达式2;表达式3){表达式4;}

表达式1:⽤于初始化循环变量初始值设置，在循环最开始时执⾏，且只执⾏⼀次
表达式2:循环条件，满则循环继续，否则循环结束
表达式3:循环变量的调整

例题：输出1~10的数

 public class test {public static void main(String[] args) {for (int i = 1; i <= 10; i++) {System.out.println(i);}}}

运行结果如下


使用时要注意这里如果不加大括号的化和if语句一样只能放一条语句
所以我们在使用的时候，建议不要省略大括号。
我们要注意括号内的之间要用分号分开（；）,不可以使用其他符号隔开

3.do while 循环

do{循环语句;
}while(循环条件);

与while循环不同，这里是先执行循环语句，然后执行判断条件
例题 ：打印1 ~ 10

public class test {public static void main(String[] args) {int num = 1;do {System.out.println(num);num++;}while (num<=10);}
}

运行结果如下


do while 循环最后的分号不要忘记
由于do while循环这种先执行循环条件，在进行判断这种特性，我们只有在特定的情况下才会使用do while循环，我们大多数使用的是while和for循环

4.continue与break语句

break是跳出整个循环，结束循环，而continue是结束本次循环在while和for循环中有所差异，下面是一些例子

while循环下的break和continue

public class test {public static void main(String[] args) {int num = 1;//初始化while(num<=10){//判断if(num==3){break;//continue;}System.out.println(num);num++;}}
}

break跳出整个循环，循环直接截止，这里num的值3时候，跳出循环

换成continue 的话，只会跳出后面语句，并不会退出循环，当num==3的时候，这里不进行打印和num++操作，但这里并不跳出出循环，一直进行判断，判断条件一直为真，在判断中num的数值一直为3，并没有逐渐接近循环截止条件，导致一直进行判断，导致死循环

for循环下的continue和break

 public class test {public static void main(String[] args) {for (int i = 1; i <= 10; i++) {if(i==3){break;//continue;}System.out.println(i);}}
}

break这里和while循环效果一样，直接退出循环

continue，但是这里的结果和while循环中有所不同
这里当i的值为3的时候，跳出下面打印语句，继续执行后面的判断和++操作，
这样3后面的数还是正常打印，这里除了3没有打印其他数全部都打印了

到这里就结束，希望这对大家有所帮助，欲知后事如何，请听下回分解。