一、Java环境变量的配置
path环境变量:
两种方式
1)jdk的安装目录下bin目录: D:\develop\Java\jdk1.8.0_162\bin
计算机->右键->属性->高级系统设置->环境变量->系统变量
path:D:\develop\Java\jdk1.8.0_162\bin;%system%......
2) 计算机->右键->属性->高级系统设置->环境变量->系统变量
新建一个系统变量:变量名:JAVA_HOME
变量值: D:\develop\Java\jdk1.8.0_162
path:%JAVA_HOME%\bin;（推荐）
二、定义标识符：
在Java中标识符是以字母、下划线或美元符号等开始的一个字符序列，后面可以跟字母，下划线，美元符号或数字。
注意事项:
不能以数字字符开头
针对包(目录)名命名的规则: 字母全部都小写
单级包:
westos
多级包:
org
westos
makename
类,接口命名的规则:
单个单词:第一个字母大写
例: Demo
多个单词:每个单词的首字母都大写
例: HelloWorld
给方法命名的规则:
单个单词:字母全部都系小写
比如:main()
多个单词:一个单词全部小写,从第二个单词每个单词首字母大写
比如:checkUserName()
给常量命名的规则:
单个单词:字母全部大写
HELLO
多个单词:字母全部大写,每个单词用下划线隔开
HELLO_WORLD
三、关键字
关键字:在java中被赋予特定含义的单词
常用关键字
class:java中最基本单元
public:权限修饰符:公开的
private:私有的
四、注释
java中的注释
三种注释:
单行注释： // 内容 快捷键 Ctrl+/
多行注释：/ * 书写注释的文字 */ 快捷键 Shift+Ctrl+/
文档注释：/** 注释的文字 */ 快捷键 Alt+Shift+J
五、常量
常量:在程序的执行过程中,其值不发生改变的量
常用的分类:
a:字符串常量 : 用双引号括起来的内容
"hello"
b:字符常量: 用单引号括起来的单个内容
'A','a','0' ,
'ab'(错误的)
c:整数常量
100
d:小数常量
3.1415926
e:布尔常量:
true(false)
f:空常量
null (在讲面向对象的时候,如果一个对象为null,那么一定要给对象进行非空判断)
g:自定义常量
在类型的前面加上修饰符final
final int MAX=100; (Java中常量标识符全部用大写)
六、变量
变量:在程序的执行过程中,其值发生改变的量
变量的三要素：
1)数据类型 2)变量名 3)初始化值
int j=5;
定义变量的注意事项:
1)定义变量,不能是Java中的关键字
2)不能是以数字开头
3)一个变量名不能重复定义
4)建议:一行定义一个变量
局部变量：局部变量是在方法内部或代码块中声明的变量，它的作用域为它所在的代码块，系统会在栈内存分配存储空间，没有默认的初始化值，必须赋值后才可使用。
成员变量：成员变量是作用在整个类中，系统会在堆内存中分配存储空间，有默认初值。
七、数据类型
数据类型的分类
基本数据类型:4类8中
整数类型: (整数类型默认int类型)
byte :字节类型
short :短整型
int :整数类型
long :长整型
浮点类型:(浮点类型默认double类型)
float :单精度
double:双精度
字符类型:
char
布尔类型
boolean(true/false)
引用数据类型：数组、String
定义long类型的变量
:由于整数类型默认是int类型 ,所以在long类型变量值后面加上一个标记:L或者l ,建议使用L
定义float类型的变量
：由于浮点数类型默认是double型，在浮点数后加标记F或f,表示float型。
各类型之间互相转换：
低------------------------------------------------------->高
byte、short、char--->int--->long--->float--->double
从低级向高级自动发生类型转换，byte、short和char在运算时，首先转换为int型，在进行运算。
强制类型转换：
由高级向低级数据类型转换时需要强制类型转换。
目标数据类型 变量名 = (目标数据类型)(变量值);
int i=40;
float t=4.0F;
t=(float)i;
八、运算符
1）算数运算符
扩展的算术运算符:
++或者--
单独使用:
结论:无论++或者--再数据前还是数据后,都是自增1或者自减1
参与运算使用:
结论:如果++或者--再数据的前面,先自增或者自减,再参与运算
如果++或者--再数据的后面,先运算,再进行自增或者自减
在Java中，%（求模运算符）的操作可为浮点数。如52.3%10=2.3。
关于+的用法
+:可以作为运算符
+ :表示一个数是正整数
+ :可以作为字符串的拼接符
2）赋值运算符
赋值运算符
基本的赋值运算符:=
举例: int a = 10 ; 将10赋值给int类型的变量a
扩展的赋值运算符:
+=,-=,*=,/=,%=
y += 10 ; 把右边的数据赋值给左边,然后在和左边的数据求和（类似 y=y+10；）
3）关系运算符
注意：
==不可写成=，要区分开。
关系运算符的运算结果是boolean型，结果是true或false，而不是1或0,。
4）逻辑运算符
逻辑或|:有true,则true
逻辑异或:^:相同则为false,不同则为true [简单记:(男女关系) 男男 男女 女男 女女]
逻辑非!:非true则false,非false,则true
“&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。
5）位运算符
6)三目运算符
格式
(关系表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
例： int x=任意整数 int a=(x>5)? x : 5 ;
九、流程控制语句
在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对运行结
果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序
来实现我们要完成的功能。
流程控制语句分类
顺序结构
选择结构
循环结构
if语句
分类:
三种格式
1、 if(条件表达式){
语句;
}
执行流程:如果表达式成立,那么执行语句,否则,不执行
应用场景:适合单个条件的判断
if语句的注意事项:
1)if语句中的大括号,可以省略,但是不建议省略
2)有大括号的地方不能有分号,有分号的地方不能有大括号!
3)这种格式的if语句,适合单个条件的判断
例：
public class IfDemo {
public static void main(String[] args) {
//定义一个变量
int x = 10 ;
if(x==10); //if语句,但是这个if语句是一个空语句体
//代码块
{
System.out.println("x等于10");
}
if(x==20) {
System.out.println("x等于20");
}
System.out.println("over");
}
}
显示：
x等于10
over
2、 if(条件表达式){ 条件表达式:无论是简单的表达式还是复杂的表达式 值都是boolean类型
语句1;
}else{
语句2;
}
执行流程
判断条件表达式是否成立,成立,就执行语句1;
如果不成立,就执行语句2;
例:
public class IfDemo2 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//接收数据
System.out.println("请输入一个数据x:");
int number = sc.nextInt() ;
if(number >=5 && number <=10) {
System.out.println("小于等于5或者x大于等于10");
}else {
System.out.println("输入的数据不在这个范围值内");
}
System.out.println("over");
}
}
显示：
请输入一个数据:
8
x小于等于5或者x大于等于10
over
3、if(条件表达式1){
语句1;
}else if(条件表达式2){
语句2;
}else if(..){
语句3;
}else{
语句n+1;
}
执行流程:
先判断条件表达式1是否成立,成立,则执行语句1
不成立,判断条件表达式2是否成立,
成立,执行语句2
...
如果都不成立,最终执行else中的语句
例：
public class IfDemo3 {
public static void main(String[] args) {
//创建键盘录入数据
Scanner sc = new Scanner(System.in) ;
/**
* 用户输入数据,假设是不合法的数据,应该考虑进去!
* 对程序进行测试的时候,测试错误数据,正确数据,边界数据
*/
System.out.println("请输入一个成绩（0到100）：");
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("该学生挂科了...");
}
}
}
显示：
请输入一个成绩（0到100）：
89
该学生成绩较好...
switch语句
switch语句的格式
switch(表达式){
case 值1:
语句1;
break ;
case 值2:
语句2;
break;
case 值3:
语句3;
break;
....
default:
语句n+1;
break;
}
执行流程:
case语句中的值1和表达式中的值比较,如果一致,执行语句1
如果不一致,走case 值2,再进行比较,如果椅子,执行语句2
....
如果上述都不一致,执行default中的语句
格式的解释:
switch:当前是一个选择结构语句,它的作用和if语句是一样
case语句:它后面的值是和表达式进行比较
break:表示结束当前switch语句
default:是和if语句中的else意识时候一样的,如果条件都不成立,执行default中的语句
switch语句后面的表达式:能跟的类型:byte,short,intchar
jdk5以后,可以跟枚举
jdk7以后,可以String类型
关于switch语句中的注意事项:
1)case语句的后面只能跟常量(根据具体的需求),不能跟变量!
2)default语句可以在switch语句中的任何位置,不影响代码执行,如果是在语句中,那么break最好带上
3)建议把break带上,否则会造成一个现象:case穿透!
4)switch语句的结束条件:
（1)语句break语句结束
（2)执行默认执行到末尾语句结束
5)case语句的后面是冒号,表示和switch语句中的表达式进行比较
例：
根据月份来判断季节
12,1,2 冬季
3,4,5 春季
6,7,8 夏季
9,10,11秋季
public class SwitchTest4 {
public static void main(String[] args) {
//键盘录入数据
Scanner sc = new Scanner(System.in) ;
//接收数据
System.out.println("请你输入月份的值:");
int month = sc.nextInt() ;
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 ;
}
}
}
显示：
请你输入月份的值:
6
夏季
for语句
for(初始化语句;条件语句;步长语句){
循环体语句;
}
执行流程:
初始化语句:给当前变量进行赋值,如果满足条件语句,那么执行循环体语句
执行步长语句,对变量进行自增或自减---->在对条件语句进行判断,如果满足条件,再次执行循环体---->步长语句
直到不满足条件为止,循环语句结束...
循环语句的注意事项:
1)条件语句,不管是一个简单的表达式还是复杂的表达式,都是boolean类型
2)初始化语句,和条件表语句后面都要带上分号;
for循环嵌套:
for(){
for(){
}
}
例：
九九乘法表
public class Test04three {
public static void main(String[] args) {
for(int i=1;i<10;i++) { //第一层for循环，控制行数
for(int j=1;j<i+1;j++) { //第二层for循环，控制列数
System.out.print(j+"*"+i+"="+(i*j)+"\t");
}
System.out.println(" ");
}
}
}
显示：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
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
while与do-while语句
while循环
基本格式:
while(条件表达式){
循环语句体;
}
扩展格式:(优于基本格式)
初始化语句 ;
while(条件表达式){
循环体语句;
步长语句;
}
执行流程:
初始化语句对变量进行赋值,如果满足条件表达式,那么执行循环体语句,执行步长语句---->继续判断是否满足条件
--->满足条件,继续执行循环体语句,步长语句---->当满足不足条件为止结束
do-whle循环
基本格式
do{
循环体语句
}whiel(判断条件语句) ;
扩展格式:
初始化语句;
do{
循环体语句;
控制体语句;(步长语句)
}while(条件判断语句) ;
do-while循环总是先执行循环体，然后再执行条件表达式。
例：
public class WhileDemo {
public static void main(String[] args) {
int sum2 = 0 ;
//初始化语句
int j = 1 ;
while(j<=100) {
sum2 += j ;
j ++ ;
}
System.out.println("1~100之间的和是:"+sum2);
}
}
显示：
1~100之间的和是:5050
跳转控制语句:
break语句
break表示中断,结束的意思,结束语句，不能单独使用,一般在switch语句,或者循环语句中使用。
continue语句
continue表示跳出当前循环,直接进入下一次循环 ，可以接着运行剩下的循环。一般配合条件语句在循环语句中使用。
例：
public class Text {
public static void main(String[] args) {
//输出1到10的偶数
for(int i=1;i<=10;i++) {
if(i%2!=0) {
continue;
}
System.out.print(i+" ,");
}
}
}
显示：
2 ,4 ,6 ,8 ,10 ,
return语句
return用来带回方法的返回值 ,会带回一个结果。也就是说，return语句使程序返回到调用它的方法。
方法
Java方法是语句的集合，它们在一起执行一个功能。是解决一类问题的步骤的有序组合，包含于类或对象中。方法在程序中被创建，在其他地方被引用。
方法的有点：1. 使程序变得更简短而清晰。2. 有利于程序维护。3. 可以提高程序开发的效率。4. 提高了代码的重用。
1）方法的定义
格式：
[修饰符] 返回值类型 方法名（[参数列表]）
｛
方法体
｝
*返回值类型，return语句会返回一个返回值，返回值类型可以是任何数据类型，若不需要返回一个数据类型，则用void表示。
public class Text {
public static int aa(int a,int b) {//有参数
int f=0;
f=a+b;
return f;//返回一个int类型的数
}
public static void bb() {//无参数，无返回值
System.out.println("Helloworld");
}
}
2）方法调用
格式：方法名（）；
当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。 当方法返回一个值的时候，方法调用通常被当做一个值。
public class Text {
public static void main(String[] args) {//主方法
int a=3;
int b=5;
int sum=aa(a,b);//赋值调用aa方法
bb();//直接调用bb方法
System.out.println("sum="+aa(a,b));//输出调用aa方法
}
public static int aa(int a,int b) {//有参数
int f=0;
f=a+b;
return f;//返回一个int类型的数
}
public static void bb() {//无参数，无返回值
System.out.println("Helloworld");
}
}
显示：
Helloworld
sum=8
方法的重载
如果你调用一个方法时传递的是int型参数，则 int型参数的方法就会被调用，如果传递的是double型参数，则double类型的方法体会被调用，这叫做方法重载； 就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。 Java编译器根据方法签名判断哪个方法应该被调用。 方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。 重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。
public class Text {
public static void main(String[] args) {//主方法
int a=3;
int b=5;
int c=2;
double x=4.5,y=7.7;
aa();
int sum1=aa(a,b);
double sum2=aa(x,y);
int sum3=aa(a,b,c);
System.out.println(sum1+" "+sum2+" "+sum3);
}
public static void aa() {//无参数，无返回值
System.out.println("方法的重载");
}
public static int aa(int a,int b) {//int类型的参数
int f=0;
f=a+b;
return f;//返回一个int类型的数
}
public static double aa(double a,double b) {//double 类型的参数
double f=0;
f=a+b;
return f;//返回一个double类型的数
}public static int aa(int a,int b,int c) {//3个参数
int f=0;
f=a+b+c;
return f;//返回一个int类型的数
}
}
显示：
8 12.2 10
3808
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
