一、数据存储相关知识点：
计算机最小的信息单元是bit（比特位）
计算机最小的存储单元是Byte（字节）
1Byte=8bit
1KB=1024Byte
1MB=1024KB
1GB=1024MB
1TB=1024GB
二、计算机的常见的快捷键：
##########################注意事项：不区分大小写
注意先切换盘符才能够进行对应文件夹的操作；
cd后面跟上空格
1.MS-DOS :Microsoft Disk Operating System 微软磁盘操作系统
2.win+r → cmd 命令提示符的启动方式
3.cd :change directory 改变目录
4.单级路径的进退操作：cd <文件夹名称>：进入对应文件夹 cd.. :退回至上一路径 在磁盘的根目录下使用无效
5.多级路径的进退操作：cd d:\igpSoft\bak cd\退回至根目录下
6.注意tab键的使用，可以进行模糊查询的轮番切换
7.cmd窗口下输入dir directory 目录
8.cls = clear screen 清空屏幕
9.exit =退出
三、JAVA语言的跨平台特性
java语言的跨平台特性是通过不同平台的JVM（JAVA VIRTUAL MACHINE）来实现的：
WINDOWS LINUX MAC 不通版本的JVM，上面运行同一java程序源码；
跨平台的定义：一次编写，随意运行
LINUX发行版本：centos ubantu
JRE:JAVA RUNTIME ENVIRONMENT java运行环境，包含jvm和java程序所需的核心类库
JDK:JAVA DEVELOPMENT KIT JAVA开发工具包：
工具包：
编译工具 complier编译器 编译生成.class字节码文件
运行工具 explain 翻译成机器所能识别的语言
JRE:java runtime environment java运行环境
JVM java虚拟机
JAVA所需的核心类库
四、环境变量的配置：
JAVA_HOME 系统环境变量的配置
Path 配置jdk的路径，%<引用地址的意思>%\bin
五、java程序三步走：
1.编写.java文件
2.通过jdk的工具包之编译工具（complier编译器）编译生成字节码文件（.class字节码文件） javac.exe
3.通过jdk的工具包之运行工具（explain解释器） 通过java.exe运行工具运行.class文件， 运行程序 java.exe
注意：javac命令需要先进入.java文件所在路径后，然后方能通过cmd，javac <文件名称.java>
java命令需要 java<文件名称>
注意：标识符的规范：
关键字全部小写；
对于variable变量首单词字母小写，剩余首字母大写；
对于project项目名称标识符首单词字母小写，剩余首字母大写；
对于moudle模块名称？
对于package包的名称，全部小写，多级包用点隔开，本质是folder路径；
对于class文件，单词首字母全部大写；
六：注释的说明
三种格式：
1.单行注释：//<后面的内容都是注释>
2.多行注释：/*<中间都是注释>*/
3.文档注释：/**<中间都是注释>*/
public --权限修饰符
class --java程序的基本组成单位
class 后面跟上类名，和.java的文件名保持一致，大小也保持一致
void --空
main --main方法是程序的入口，主方法
七：关键字
JAVA关键字的：被JAVA赋予了特定含义的，不能被随意使用的标识符；
关键字的特征：
1.完全小写的字母；
2.增强版的编辑器深色显示；
标识符：
标识符的概念：自己定义的内容；
标识符可以包含：英文26个字母， 0-9数字，下划线_ ,美元符号$(不建议使用$为标识符组成部分)
硬性要求：不能数字开头，不能使用java的关键字（保留字）
建议规范：
1.类名：首字母大写，后面的每个单词的首字母也要大写（UpperCamelCase大驼峰式）
2.变量名：首个单词的首字母小写，后面的单词首字母全部大写（lowerCamelCase小驼峰式）
3.方法名和变量名的建议规则一致；
七：常量和变量的概念：
常量：在程序运行期间，其值不发生变化的量称之为常量；
分类：
字符串常量：1.字符串常量:"abcd";
2.整数常量:1;
3.浮点数常量:1.11;
4.字符常量：'a'; 注意：两个单引号中间必须有且仅有一个字符；
5.boolean（布尔）常量：true / false;
6.空常量：null;没有任何数据; 注意：不能直接打印输出；
变量：在程序的运行过程中，其值发生变化的量称之为变量；
八：数据类型的分类
数据类型的分类：1：基本数据类型 (4类八种)
整型值
byte ：1Byte=8bit (-128~+127)
short: 2Byte=16bit (-32768~+32767)
int : 4Byte=32bit (-21,4748,3648~+21,4748,3647)
long : 8Byte=64bit (-922,3372,0368,5477,5808~+922,3372,0368,5477,5807)
浮点型
float 单精度：4Byte=32bit
double双精度：8Byte=64bit
字符型
2Byte=16bit ; char(0-65535)
布尔型
boolean
大小：1 2 4 8 4 8 2 1 个字节
注意：
1.字符串不是基本数据类型：字符串是引用数据类型
2.浮点数可能只是一个近似值，并非精确值；
为什么说浮点数是一个近似值而非精确值？
数据在计算机中都是以二进制的形式存储的；
A:十进制整数转换为二进制
除2取余，逆序排列；
B:负的十进制整数转换为二进制
源码：绝对值 求二进制
反码：绝对值的二进制数按位取反
补码：反码+1 ；
tips:十进制正数的补码是源码本身；
3.数据的精度（取值范围）和占用的字节数不一定正相关，因为还和表示法有关，科学计数法省空间；
例如float的数据范围比long更加广泛，但是float占用的字节数是4，但是long类型占用的是8个字节；
4.浮点数中默认类型是double类型，如果一定要使用float类型，建议加上F
整数类型默认为int类型，如果要使用long类型，建议加上L；
2：引用数据类型：
1.接口（inerface）
2.数组（array）
3.类（）
4.字符串
九：变量的概念和定义：
变量：在程序运行过程中，内容可以发生变化的量； --相当于容器；
定义：
第一种格式：
1.<数据类型><变量名称><;> 其实分为2步：1.变量申明; 2. 初始化（赋值）;
2. 变量的赋值：<变量名称>=<数据值>； 赋值：将右边的数据值，赋值交给左边的变量；
第二种格式：
或者：数据类型 变量名=数据值； 在创建一个变量的同时，立刻放入指定的数据值；
十：变量的基本使用：（基本数据类型：输出的是变量的内容） 可以进行数据值的传递；int num1=100; int num2=num1;
（引用数据类型：输出的是变量的地址）
定义变量过程中注意：
1. 如果创建多个变量时，那么变量之间的名称不能重复
2. 定义long或者float类型的变量时数据值后需要加上L或者F；
long num1=100L;
float num2=2.33F;
3. 定义byte类型或者short类型变量时需要注意右侧的数据值不要超过变量的取值范围；
4. 没有赋值的变量不能直接被使用；
5. 变量的作用域：从定义的位置开始，到所属的那对大括号截止；
十一：
byte数据类型的比特位：8
byte数据类型的取值范围：-128~127
-----------------------
short数据类型的比特位：16
short数据类型的取值范围：-32768~32767
-----------------------
int数据类型的比特位：32
int数据类型的取值范围：-2147483648~2147483647
----------------------
long数据类型的比特位：64
long数据类型的取值范围：-9223372036854775808~9223372036854775807
------------------------
float类型数据的比特位：32
float数据类型的取值范围：1.4E-45~3.4028235E38
-------------------------
double类型数据的比特位：64
double数据类型的取值范围：4.9E-324~1.7976931348623157E308
-------------------------
char数据类型的比特位：16
char数据类型的取值范围：0~65535
---------------------------
boolean数据类型的比特位：8
boolean数据类型的取值范围：true false
package my.java;
public class PrimitiveTypeDemo {
public static void main(String[] args) {
//byte类型的数据比特位，最小，最大
System.out.println("byte数据类型的比特位："+Byte.SIZE);
System.out.println("byte数据类型的取值范围："+Byte.MIN_VALUE+"~"+Byte.MAX_VALUE);
System.out.println("-----------------------");
//short类型的数据比特位，最小，最大
System.out.println("short数据类型的比特位："+Short.SIZE);
System.out.println("short数据类型的取值范围："+Short.MIN_VALUE+"~"+Short.MAX_VALUE);
//输出int类型的数据比特位，最小，最大
System.out.println("-----------------------");
System.out.println("int数据类型的比特位："+Integer.SIZE);
System.out.println("int数据类型的取值范围："+Integer.MIN_VALUE+"~"+Integer.MAX_VALUE);
//输出long数据类型的数据比特位，最小，最大
System.out.println("----------------------");
System.out.println("long数据类型的比特位："+Long.SIZE);
System.out.println("long数据类型的取值范围："+Long.MIN_VALUE+"~"+Long.MAX_VALUE);
//输出float类型的数据比特位，最小，最大
System.out.println("------------------------");
System.out.println("float类型数据的比特位："+Float.SIZE);
System.out.println("float数据类型的取值范围："+Float.MIN_VALUE+"~"+Float.MAX_VALUE);
//输出double类型的数据比特位，最小，最大
System.out.println("-------------------------");
System.out.println("double类型数据的比特位："+Double.SIZE);
System.out.println("double数据类型的取值范围："+Double.MIN_VALUE+"~"+Double.MAX_VALUE);
//输出char类型的数据比特位，最小，最大
System.out.println("-------------------------");
System.out.println("char数据类型的比特位："+Character.SIZE);
System.out.println("char数据类型的取值范围："+(int)Character.MIN_VALUE+"~"+(int)Character.MAX_VALUE);
//输出boolean数据类型比特位，最小，最大
System.out.println("---------------------------");
System.out.println("boolean数据类型的比特位："+"8");
}
}
一、
流程分类：顺序结构:
代码执行顺序：从上至下依次执行;
判断语句（选择结构/分支结构）:
1. 单 if 语句:
if(关系表达式/判断条件){
语句体;
}
2. 标准的 if else 语句格式if else：
if(关系表达式/判断条件){
语句体1;
}
else{
语句体2;
}
应用：判断奇偶性
if(number%2==0){
System.out.println("偶数");
}
else{
System.out.println("奇数");
}
int a=10;
String str=a%2==0?"偶数":"奇数";
System.out.println(str);//偶数;
三元运算符：
数据类型 变量名=关系表达式?表达式1:表达式2;
注意：在某些简单的应用中， if else 语句可以和三元运算符等价，可以根据实际的情况予以选择;
3. if...else if...else;
扩展的if else语句格式：（if else的扩展格式）
if(判断条件1){
语句体1;
}
else if(判断条件2){
语句体2;
}
...............
else if(判断条件n){
语句体n;
}
else{
语句体n+1;
}
案例演示：
public class IfElseExtDemo {
public static void main(String[] args) {
while (true) {
System.out.println("请输入成绩：");
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
//开始使用if else语句的扩展格式进行成绩判断
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("成绩不及格");
}
}
}
}
注意：当 if else 语句执行到第一个关系表达式结果为true时，后面的不再执行，如果所有的判断条件都是false那么，程序将执行else对应的语句体n+1;
选择语句 格式：---switch语句的标准格式：
switch(表达式){
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
break;
.
.
.
default:
语句体n+1;
break;//break可以省略，但是不建议；
}
执行流程：首先计算表达式的值-->然后拿表达式的结果与case后面跟的常量值进行匹配，一旦有对应的值与之匹配，那么程序将执行对应的语句体，直到遇到break就结束;
如果所有的case后面的常量值与表达式的值都不匹配，那么程序将执行default(默认)：后面的语句体: n+1 ，直到遇到break或者switch语句结束为止;
注意：程序遇到第一个break或者switch语句整体结束，那么程序就结束了;
案列演示：
import java.util.Scanner;
public class DayTest{
public static void main(String []args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入数据值：");
int number=sc.nextInt();
switch(number){
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;
}
}
}
注意事项：
1. 多个case后面的常量值不可以重复; //报错，case标签重复;
2. switch 后面的小括号当中只能是以下数据类型:
基本数据类型：byte short char int
引用数据类:
jdk5以后支持enum枚举类型;
jdk7以后支持字符串类型;
3. switch语句的格式可以很灵活：前后的顺序可以颠倒(甚至default也可以不在最后面)，而且break可以省略;
匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者代码整体结束为止;
switch 语句中 case 的穿透原理;没有遇到break且代码整体没有结束，穿透：*****
在switch语句中，如果case后面没写break，那么将出现case穿透现象，解释：程序将继续执行，而不判断下一个case后面的常量值是否与表达式匹配，直到遇到break，或者整体switch语句结束;
循环结构：
循环语句的三种形式：
1. for(<①初始化语句>;<②判断条件语句>;<④控制条件语句/步进语句>){
<③循环体>;
}
解释：
1. 初始化语句：在循环开始最初执行，而且只做唯一一次；
2. 判断条件语句：如果true则执行循环体，否则循环结束；
3. 循环体：需要计算机重复做的代码块;
4. 控制条件语句（步进语句(单步动作/步进)）;
public class Test{
public static void main(String []args){
int sum=0;
for(int i=1;i<=100;i++){
sum+=i;
}
System.out.println("sum="+sum);
}
}
2. while 循环:
标准的while语句格式：
while(<①判断条件语句>){
<②循环体>;
}
扩展的while语句格式：
<①初始化语句>;
while(<②判断条件语句>){
<③循环体>;
<④步进语句/控制条件语句>;
}
for循环可以转换为while循环;
public class Test{
public static void main(String[]args){
int i=1;//初始化语句
int sum=0;
while(i<=100){//判断条件语句
sum+=i;//循环体
i++;//控制条件语句/步进语句/步进/单步动作
}
}
}
3. do_while 循环：
标准格式：
do{
循环体;
}while(判断条件语句);
扩展格式:
初始化语句;
do{
循环体;
步进语句(控制条件语句);
}while(判断条件语句);
注意：do while循环的循环体至少被执行一次;
案例练习：
//求1-100之间的偶数和 for循环格式求和
public class getSum{
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="+sum);
}
}
//求1-100之间的偶数和 while循环格式求和
public class getSum{
public static void main(String []args){
int i=1;
int sum=0;//累和变量初始为0;
while(i<=100){
if(i%2==0){
sum+=i;
}
i++;//控制条件语句/步进语句
}
System.out.println("sum="+sum);
}
}
//求1-100之间的偶数求和 do_while循环格式求和
public class getSum{
public static void main(String[]args){
int sum=0;//累和变量初始为0;
int i=1;//初始化语句
do{
if(i%2==0){
sum+=i;
}
i++;//控制条件语句/步进语句
}while(i<=100);//判断条件语句
System.out.println("sum="+sum);
}
}
三种循环的区别：
1. 如果判断条件语句从来都没有成立过，那么for循环和while循环执行的次数0,但是do while循环至少执行一次;
2. for 循环的变量在小括号当中定义，只有循环内部才可以使用。while/do_while循环的初始化语句定义在循环体外面，那么出了循环之后，初始化语句中定义的变量仍可以被访问;
推荐使用：如果有固定的次数，推荐使用for循环;
如果循环次数不确定，推荐使用while循环;
其它使用do_while循环，使用优先级最低;
六、流程（跳转）控制语句：
break;
1. 可以用在switch语句当中，一旦执行，整个switch语句立刻结束；
2. 还可以用在循环语句当中，一旦执行，整个循环语句立刻结束，打断循环；（结束（中断/打断/打破）整个循环）
continue;
1. 结束本轮循环，下一轮循环还要继续;
一旦执行，立刻跳过当前次循环剩余内容（部分），马上开始下一次循环;(但是步进语句/控制条件语句还需要执行)
案例：
public class Test_02 {
public static void main(String[] args) {
for(int i=1;i<=10;i++){
if(i==4){
continue;
}
System.out.println(i+"楼到了");
}
}
}
死循环:
public class DemoDeadLoop{
public static void main(String[]args){
for(int i=1;i<=10;i++){//步进语句/控制条件语句没有被执行，那么就是死循环
System.out.println("i="+i);
}
}
}
死循环的标准格式:
格式1：
while(true){//死循环
循环体;
if(关系表达式){
break;//死循环的跳转控制语句之break，跳出死循环;
}
}
格式2：
for(;;){
循环体;//for 循环格式的死循环;
}
循环的嵌套：
for(int h=0;h<24;h++){
for(int m=0;m<60;m++){
System.out.println(h+":"+m);
}
}
循环的嵌套，可以理解为内嵌套循环为循环体即可;
|
|
收藏
淘帖
踩
