JAVA 知识点总结第一周_标识符week怎么定义-CSDN博客

本文链接：https://blog.csdn.net/qq_54073132/article/details/126070152

内容

Java语言的发展历史

Java开发环境搭建

编写Helloworld程序

java 中的注释、关键字、标识符、常量、变量

运算符

键盘录入与流程语言

Java语言的发展历史

JDK的安装
jdk:软件开发工具包----就可以编写JAVA代码------>进入到刚才安装的jdk的安装目录里面bin目录（可执行目录）
javac.exe----->java文件的编译指令
Java.exe------>java文件的运行指

java -version 判断JDK是否安装成功

计算机软件结构划分

C/S结构 (Client-Server):客户端和服务器端的交互典型的特点 : 客户端软件必须升级,才能使用服务器端的高版本的功能典型的应用:QQ客户端 (常见的客户端软件)

B/S结构 (Browser-Server):浏览器端和服务器端的交互典型的特点:只要保证你的计算机上有浏览器即可(无论高版本还低版本都能够访问对应的网站),不需要升级

常用的doc指令

1.盘符切换：不区分大小写d:
2.进入指定的目录cd(change Directory)单级路径或者多级路径
3.cd / :直接回退到当期盘符的根目录
4.cd.. :直接从当期目录回退上一级目录
5.cls :清除屏幕
6.md :创建文件夹 md 目录（文件夹）名称
7.copy con :创建文件 copy con 文件的名称带后缀
8.rd :删除文件夹（前提条件：删除的文件夹必须为空目录）
9.del :删除文件 del 文件的名称：删除单个文件
10.rd的扩展指令:可以删除带内容的目录(循环是否删除) rd /s 文件夹(目录)名称: 询问是否删除这个带内容的目录(文件夹) rd /s /q 文件夹(目录)名称：暴力删除不用询问
11.其他指令：dir:罗列当期目录或者文件夹中的文件名称 ipconfig:查看自己本机的ip地址 ping 域名或者ip地址:查看自己本机是否能够和其他的机器之间通信
Java语言诞生时间:1995年正式推出
Java之父: 詹姆斯·高斯林（James Gosling）
Java开发环境搭建
JVM:java虚拟机是一个假象计算机,运行在操作系统之上,每一个不同的系统都有自己的对应的版本 jvm,所有的Java程序都需要被jvm执行,而jvm依赖于你自己的系统.
JRE:其中包含了Jvm以及运行时所支持的核心类库；（类库:包含很多java类）
JDK:Java development Kit:Java开发工具包 :包含了jre以及一些工具库. JDK > JRE> JVM:三者之间的关系
配置path系统环境变量
在此电脑----右键---属性----->高级系设置------->环境变量----->系统变量------> 点击新建创建新的环境变量变量名输入 JAVA_HOME ，变量值输入JDK的安装目录 d:\develop\Java_jdk\jdk1.8.0_162 选中 Path 环境变量，双击或者点击编辑在变量值的最前面，键入 %JAVA_HOME%\bin; 分号必须要写，必须是英文格式。
编写Helloworld程序
1.先创建一个文本文件, .txt 文件---后缀名改为.java
2.开始编写java程序
3.定义类,是Java中最基本的单元

class HelloWorld{

//main方法:能够被jvm识别,是程序的入口

public static void main(String[] args){

//想在控制台(dos控制台)展示一句话,固定格式,java输出语句

System.out.println("helloworld") ;

}

}

4.配置好了Java系统环境变量,首先要进入到这个java文件所在的目录中
5.javac java源文件 --- 编译过程(jvm校验的语法格式)javac HelloWorld.java
6.编译过程没有问题,产生一个字节码文件: 类名.class
java 中的注释、关键字、标识符、常量、变量
注释
注释:对java代码进行解释说明的文字(提高代码阅读性)

分类：单行注释 //注释文字多行注释 /* 注释文字 * / 文档注释 /** 文档相关文字描述 */

单行注释和多行注释:不会被jvm解析,就是为了代码阅读性

文档注释:特殊注释,后期能够jvm解析

关键字
关键字：组成关键字的字母都是小写;
class: 表示在定义一个类 (Java中最基本的单元) 格式:class 类名{}
public:权限修饰符 (公共的/公开的/访问权限足够大)
static:静态修饰符 (基本的概念:共享/共用)
void : (Java中的方法(函数),就是一个{}代码块
标识符
给类起名字---->遵循"大驼峰命名法" 每一个单词的首字母都大写,其余单词小写
给变量起名字---->遵循 "小驼峰命名法" 单个单词:字母全部小写
多个单词:第一个单词的字母全部小写,从第二个单词开始每个单词的首字母都是大写,其余小写
给常量起名字单个单词: 单词字母全部大写
多个单词每一个单词字母大写,单词和单词之间下划线隔开
标识符的组成规则

1.26个英文字母(大小写都可以) 2.0-9的数字

3.$或者_下划线 4.Java定义标识符:严格区分大小写
注意事项:

1.定义标识符(类名/接口名/方法名/常量/变量名):名字都不能以数字开头 2.定义标识符:起名字,不要出现Java中的关键字
常量
常量的分类:
字面值常量：

字符串常量 ,它使用使用""括起来的内容 "helloworld"
字符常量 ,它使用单引号'' 括起来的单个内容 'a','A','0'
注意事项:当字符单独使用时候,---代表对应的字符'a','A','0'

当字符参与运算的时候,键盘每一键'字符'---找ASCII码表中字符对应的整数值 'a'---- 97 'A'---- 65 '0'---- 48
整数常量：25,100,...
小数常量：3.154......
布尔常量：true,false
空常量：默认值就是null

自定义常量----跟面向对象中 "final"关键字有关系
变量
在程序执行过程,其值在不断变化--称为变量
变量的三要素：
1)限定范围---就是限定变量的数据类型

2)变量名---满足标识符的规范(见名知意)

3)初始化值----必须要限定的数据类型要一致!
类型分类
基本数据类型

整数类型：

字节类型 byte 占1个字节范围:-128~127(重点) 短整类型 short 占2个字节

整数(默认类型) int 占4个字长整型 long 占8个字节
浮点类型：

单精度类型 float 占4个字节

双精度类型 double 占8个字节
字符类型：char 占2个字节
boolean类型：Java语言中不会参与运算的,仅仅是在实际开发中,逻辑判断的 boolean 占1个字节

引用数据类型
注意事项:long x = 10000000000L ; //L或者l float f = 12.56F ; //F或者f
隐式转换:基本数据类型的默认类型提示 byte,short,char三者之间不转换,一旦参与运算,优先提升为int类型,---long---float---double;
显示转换:强制类型转换(强转)就是将的大的数据类型---小的数据类型格式目标数据类型变量名 = (目标类型)(表达式或者初始化值) ;
运算符
算术运算符：

+,-,*,/,%(模:求余数) 注意事项: / 是取整 % 是求余数的
扩展的算术运算符:++,--

单独使用:比较简单无论++或者--在数据的前面还是后面,都是对这个变量本身自增1或者自减1
参与运算使用：1）如果++或者--在数据的前面,先进行自增或者自减,然后参与运算; 2）如果++或者--在数据的后面,先运算,然后进行自增或者自减

赋值运算符的扩展赋值运算符的特点：隐藏了强制类型转换

class OperatorDemo2{
	
	public static void main(String[] args){
		
		
		//定义变量
		short s  = 1; 
		 //不兼容的类型: 从int转换到short可能会有损失
		//s = s + 1  ;//会编译失败,=右边,s---先提升int,然后进行计算--->结果为int
		//=左边short,无法接收=右边的int类型
		
		//强制类型转换
		//s = (short)(s+1) ;
		//System.out.println(s) ;
		
		s += 1 ;//等价于 s = (short)(s + 1); 隐藏了强制类型转换
		//相当于这个s = (short)(s+1) ;
		System.out.println(s) ;
		
		
	}
}

比较运算符：无论这些符号连接的表达式是简单的还是复杂,结果应该布尔类型,true/false

/*
	比较运算符(关系运算符)
	
	<,>,<=,>=,==,!= 
	
	这些运算符:无论这些符号连接的表达式是简单的还是复杂,结果应该布尔类型,true/false
	
	表达式:
			这些运算符号--连接起来多个变量
			
	注意:
			==不能写成 =
			
			数学表达式:
					3<=x<=5,在计算机语言中,无法这样书写,需要逻辑符号连接起来
									x>=3 &(逻辑单与) x <=5 
*/
class OperatorDemo{
	
	public static void main(String[] args){
		
		
		//<,>,<=,>=,==,!= 
		//定义三个变量
		int a = 3 ;
		int b = 4 ;
		int c = 5 ;
		
		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)<=(b+c)) ;
		System.out.println(a!=b) ;
		System.out.println(a==c)  ;
		
		
		System.out.println("---------------------------------") ;
		//==不能写成 =
		
		int m = 10 ;
		int n = 20 ;
		
		//两个数据比较:使用boolean接收
		boolean flag  = (m==n) ; 
		//int无法转换为boolean
		//boolean flag  = (m=n) ;//将n的值赋值给m,将m的值留下来赋值给flag,而flag变量是boolean 
		System.out.println(flag) ;
	}
}

逻辑运算符
基本的逻辑运算

逻辑单与& ----并列关系特点:有false,则false;
逻辑单或| ----或的关系特点:有true,则true
逻辑异或^ 特点:相同则为false,不同则为true
逻辑非! 非true,则false;非false,则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("------------------------------") ;
		
		//逻辑非!
		//非true,则false;非false,则true;偶数给非是它本身
		System.out.println(!(a>b)) ;
		System.out.println(!!(a>b)) ;
	}
}

扩展的逻辑运算符
逻辑双与&& ---并列关系,必须同事满足条件,才成立;

逻辑双或|| --- 或的关系:有一个满足条件成立;
逻辑双与&&和逻辑单与&的区别?

共同点:有false,则false

不同点:逻辑双与&&:具有"短路"效果,当&&连接的表达式如果左边为false,则右边不执行了!

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变量赋值3
		int x = 3 ;
		int y = 4 ; 
		
		System.out.println("x:"+x) ;//x:3
		System.out.println("y:"+y) ;//y:4
		
							//false
							//x ++ = 4
		//System.out.println((x++)==4 && (--y)==3 ) ;//false //&&的左边表达式false,则右边不执行了
		
		//System.out.println("x:"+x) ;//4
		//System.out.println("y:"+y) ;//4
		
		
		//逻辑单与&,左边表达式为false,右边依然要执行,开发中不用它,效率太低
		System.out.println((x++)==4 & (--y)==3 ) ;//false 
			
		System.out.println("x:"+x) ; //4
		System.out.println("y:"+y) ;// 3 
		
		
	}
}

三元运算符
格式:简单或者复杂的表达式)? 执行成立的结果:执行不成立的结果;

执行流程:先判断表达式是true还是false,如果是true,执行成立的；如果是false,执行不成立的结果。

class OperatorDemo{
	
	public static void main(String[] args){
		
		//定义了两个变量
		int x = 20 ;
		int y = 5 ;
		
		//求x,y这两个数据的最大值;
		//定义一个结果变量,接收结果
		//(简单或者复杂的表达式)? 执行成立的结果:执行不成立的结果;
		int max  = (x>y)? x:y ;
		System.out.println("两个数据中的最大值是:"+max) ;
		System.out.println("---------------------------------") ;
		//求x,y的最小值
		int min = (x<y)?x:y ;
		System.out.println("两个数据中的最小值是:"+min) ;
		
		System.out.println("---------------------------------") ;
		
		//比较x,y的值是否相等 
		//boolean接收
		//boolean flag = (x==y)?true:false ; 
		// 优化
		
		boolean  flag = (x==y) ; //==本身就是比较
		
		System.out.println("flag:"+flag) ;


		//练习
		//有三个数据,a,b,c int类型,
		//int a = 20 ;
		//int b  = 50 ;
		//int c  = 15 ; 
		
		//使用三元运算符:完成三个数据比较,获取最大值?
		
		
	}
}

键盘录入与流程语言
键盘录入数据
没有提示数据类型,默认录入的都是int类型

Java中的键盘录入---Jdk提供的类:Scanner :它不能直接录入字符类型 char

Scanner的使用步骤---

导包---以后经常用到jdk提供的类或者第三方(阿里支付宝支付/微信支付/短信验证...)的类只要这个类不是java.lang包下的类,都需要导包;只要将包导入进来,才能使用这个类在class的上面使用import (关键字:导包)

import java.util.Scanner;
创建一个文件扫描器(创建键盘录入数据对象)

Scanner sc = new Scanner(System.in); //sc:就是代表文本扫描器对象(变量名,可以随便起---见名知意)
友情提示,"请您输入一个数据:"
录入一个int类型的数据了int 变量名 = sc.nextInt();//就是使用文本扫描器对象调用这个类的功能(录入int类型) nextInt():是Scanner这个类提供的一个功能
使用这个变量名完成一些操作,要么直接输出,要么逻辑判断....

import java.util.Scanner ; //1)导包
class ScannerTest{
	
	public static void main(String[] args){
		
		//1键盘录入两个数据,比较两个数据最大值
		
		
		//2)创建键盘录入对象(文本扫描器)
		Scanner scanner = new Scanner(System.in) ;
		
		//3)提示并录入数据
		System.out.println("请输入第一个数据:") ;
		int a = scanner.nextInt() ;  //int a = 10 ; //10写死的
		
		System.out.println("请输入第二个数据:") ;
		int b = scanner.nextInt() ;
		
		//4)完成判断
		//三元运算符
		int max = (a>b)?a:b ;
		System.out.println("最大值是:"+max) ;
		
		
		System.out.println("-------------------------------------------") ;
		
		//2 键盘录入两个数据,比较两个数据是否相等
		
		//提示并录入数据
		System.out.println("请输入第一个数据:") ;
		int firstNum =  scanner.nextInt() ;
		
		System.out.println("请输入第二个数据:") ;
		int secondNum = scanner.nextInt() ;
		
		//比较两个数据是否相等----接收boolean类型数据
		boolean  flag =  (firstNum == secondNum) ; // ==本身就比较
		//boolean  flag =  (firstNum == secondNum)?true:false ;
		
		System.out.println("flag:"+flag) ;
		
		
		System.out.println("-------------------------------------------") ;
		
		
		//3 键盘录入三个数据,比较三个数据中的最大值
		
		//提示并录入数据
		System.out.println("输入第一个数据:") ;
		int m = scanner.nextInt() ;
		
		System.out.println("输入第二个数据:") ;
		int n = scanner.nextInt() ;
		
		
		System.out.println("输入第三个数据:") ;
		int z = scanner.nextInt() ;
		
		
		//使用中间变量的方式记录:m和n的值
		//使用三元运算分步完成
		int temp = (m>n)?m:n;
		//temp和z进行比较
		int max2 = (temp>z)?temp:z ;
		System.out.println("三个数据中的最大值是:"+max2);
		
		
		System.out.println("-------------------------------------------") ;
		
		//使用三元运算符一步走:三元运算符的嵌套:效率低
		int max3 = (m > n)?((m>z)?m:z):((n>z)?n:z) ;  
		System.out.println("三个数据中的最大值是:"+max3);
		
		
		
	}
}

流程控制语句
顺序结构---->所有的计算机语言都是遵循顺序结构:代码依次从上而下加载(从程序入口:java中的main方法)
选择结构语句
第一种格式 if(表达式){语句;}

第一种格式的执行流程 if( 语句;}

1)判断表达式是否成立,如果成立,则执行语句,否则不执行;

//需求:键盘录入一个数据int类型,判断这个数据是否大于等于10


/*注意事项:
		if()后面不能带分号
		记住:有分号的地方就不能{,有{的地方,不能有分号;
*/

//导包
import java.util.Scanner ;

class IfDemo{
	
	public static void main(String[] args){
			
			//创建键盘录入对象
			Scanner sc = new Scanner(System.in) ;
			
			//提示并录入数据
			System.out.println("请输入一个数据x:") ;
			int x = sc.nextInt() ;
			
			//判断
			if(x >=10){
				System.out.println("x大于等于10") ;
			}
			System.out.println("over") ;
		
	}
}

第二种格式 if(表达式){ 语句1 ...; }else{ 语句2...; }

执行流程:1.首先判断表达式是否成立,如果成立,则执行语句1... 2.如果不成立,执行语句2...

/*需求:
		键盘录入两个数据,比较两个数据最大值;
		
		

*/
//导包
import java.util.Scanner ;
class IfDemo2{
	
	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() ;
		
		//if...else... 流程语句
		
		
		//方式1:直接使用变量接收 (推荐第一种)
		//定义一个变量
		int max ;
		if(a>b){
			//将a的值赋值给max
			max = a ; 
			
			//System.out.println(a+"是最大值") ;
		}else {
			//将b的值赋值给max
			max = b ;
			//System.out.println(b+"是最大值") ;
		}
		
		System.out.println("max:"+max) ;
		
		System.out.println("----------------------------------") ; 
		
		//方式2:直接输出了
		if(a>b){
			System.out.println(a+"是最大值") ;
		}else {
			System.out.println(b+"是最大值") ;
		}
	}
}

第三种格式
:

           if(表达式1){

               语句1 ...;
           }else if(表达式2){
               语句2...;
               ...
           }else{
               语句n...;

           }

   执行流程 1)先判断表达式1是否成立,成立,执行语句1
2)如果不成立,继续判断表达式2是否成立,成立,则执行语句2,,,
.........
如果上面的表达式都不成立,执行else中的语句n..

/*需求: 
     键盘录入学生的成绩(int类型),满分100分,控制输出学生成绩的等级
			90-100    优秀 
			80-90     较好
			70-80     良好
			60-70     及格
			60以下    不及格
*/
//导包
import java.util.Scanner ;
class IfDemo4{
	
	public static void main(String[] args){
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并录入数据
		System.out.println("请输入学生的成绩:") ;
		int  socre = sc.nextInt() ;
		
		
		/*
			90-100    优秀 
			80-90     较好
			70-80     良好
			60-70     及格
			60以下    不及格
		*/
		//if格式3
		/*
		if(socre>=90 && socre<=100){
			System.out.println("优秀") ;
		}else if(socre>=80 && socre<90){
			System.out.println("较好") ;
			
		}else if(socre>=70 && socre<80){
			System.out.println("良好") ;
		}else if(socre>=60 && socre<70){
			System.out.println("及格") ;
		}else{
			System.out.println("不及格") ;
		}
		*/
		
		
		//学习任何计算机语言:程序---最终给客户去用的,考虑开发完成之后,自测
		//测试 :正确的数据 ,错误数据,边界数据
		
		//优化:最终版:加入一些非法数据的提示
		if(socre>100 || socre<0){
			System.out.println("您输入的数据不合法") ;
		}else if(socre>=90 && socre<=100){
			System.out.println("优秀") ;
		}else if(socre>=80 && socre<90){
			System.out.println("较好") ;
		}else if(socre>=70 && socre<80){
			System.out.println("良好") ;
		}else if(socre>=60 && socre<70){
			System.out.println("及格") ;
		}else{
			System.out.println("不及格") ;
		}
		
		
		//jvm:java虚拟机 校验你的语法的时候,需要校验语法的整个结构,考虑如果if的里面都不成立,这个程序没有结束;
		//就出现问题;
		
	}
}