Java知识点总结

第一周学习总结

• Java的环境概述与环境搭建
• • 概述
  • Java的环境搭建
  • 关键字
  • 标识符
  • 常量的概念以及分类
  • 进制的由来，进制的转换
  • 有符号位数据表示法（符号位+数值位）
  • 变量和数据类型
  • 运算符
  • 控制台输入
  • 流程控制语句：
  • 循环结构

Java的环境概述与环境搭建

概述

1. 什么是程序？

   程序是为了模拟现实世界，解决现实问题而使用计算机语言编写一系列有序的指定集合。

2. Java的特点

   （1）面向对象：贴近人类思维，模拟现实世界，解决现实问题。

   （2）简单性：自动内存管理机制，不易造成内存溢出，简化流程处理，语义清晰。

   （3）跨平台：跨操作系统和跨服务器。

3. 电脑都由哪几部分组成：cpu、主板、内存、电源、主机箱、硬盘、显卡、键盘、鼠标、显示器等。

4. 软件的结构划分：

   （1）C/S结构(Client/Server)：客户端和服务器端的交互。

   特点：服务器端和相应的客户端是一个高版本，客户端的软件必须升级才能使用服务器的高版本功能。

   例举：QQ客户端、阿里巴巴等。

   （2）B/S结构(Browser/Server)：浏览器端和服务端的交互(JavaEE)。

   特点：只要保证电脑存在浏览器，就可以访问服务端程序。

   例举：大型游戏、网易新闻等。

5. 软件的划分

   系统软件：DOS、Linux、Windows、MAC、

   应用软件：客户端软件：QQ、office办公软件

   软件开发：借助第三方开发工具----->写相关代码----->开发一个软件。

   开发工具：notepad++ : 高级记事本。

   eclipse 开发工具（必须使用会！！！），半自动化。

   idea 开发工具（非常智能，联想精确），相对eclispe可以提高开发效率。

6. 人机交互

   方式1：图形界面化，非常简单、直观！

   方式2：命令行的方式（得记住相关的操作指令，计算机能够识别的），需要进入dos控制台输入相关命令。

   例如：

   （1）从系统盘符切换到d盘：win+R，键入cmd，进入dos，输入d: 然后按回车键，即可。

   （2）键入dir并回车，可以罗列出某个盘中的文件。

   （3）进入某个目录，键入cd 目录名称

   例如：cd D:\千峰学习\千峰课程\day3

   （4）回退到根目录 cd\ 回退下级目录 cd .

   （5）创建目录（文件夹） md 目录名称

   （6）创建文件 copy con 输入文件夹名称(xxx.txt) 然后回车，输入文件内容，并ctrl+Z(终止输入文件内容) 再次回车，提示“文件已复制”。

   （7）删除文件

   del 删除单个文件

   rd 删除空目录

   rd /s 目录(文件夹)名称 询问删除（Y/N）

   rd /s /q 目录(文件夹)名称 暴力删除

   （8）清屏 cls 查看ip端口 ipconfig ping其他的ip地址 ping ip地址

Java的环境搭建

1. jdk的安装（运行jdk-8uXXX-windows-x64.exe） 默认路径为：C:\Program Files\Java

   2.配置 java环境变量

   第一步：右击“此电脑”----->“属性”------>“高级系统设置”----->“环境变量”

   第二步：“系统变量中点击新建”------>“变量名：JAVA_HOME 变量值：C:\Program Files\Java\jdk1.8.0_121”

   第三步：“找到path 点击编辑 进入到path变量中 点击新建 输入%JAVA_HOME%\bin”

   第四步：进入dos命令，输入 java/javac，不报错，则说明环境变量配置成功。

   注意：classpath:临时环境变量（早期使用） 系统变量名：classpath 变量名：指定某个盘符下的某个目录的路径

   3.编写第一个java程序（HelloWorld）

   （1）创建.java文件：右击新建一个文本文档，改名为HelloWorld.java，在改名时，弹出警告框时，并点击“是”，才更名成功。

   class HelloWorld{ //类

   public static void main(String[] args){ //main主函数

   System.out.println(“HelloWorld”); //控制台输出语句

   }

   }

   注意：类名和文件名保持一致。

   4.编译

   进入dos------>进入.java文件存在的盘------>cd 文件夹名称----->javac HelloWorld.java---->回车----->java HelloWorld---->回车

   5.类的阐述

   （1）同一个源文件中可以定义多个类

   （2）编译后，每个类对应一个.class文件

   （3）一个类中，只能有一个主函数，每个类都可以有自己的主函数

   （4）public修饰的类称为公开类，要求类名必须和文件名保持一致，包括大小写。

   （5）一个源文件中，只能有一个公开类。

   6.JDK JRE JVM的含义和关系

   JDK：java的运行环境 JRE:java的开发工具，包含了lib目录，存储了一些jar包，一些java的核心类库。

   JVM：java虚拟机

   关系：JDK>JRE>JVM

   7.注释

   单行注释 // 给代码加上解释说明的文字，可以提高代码的阅读性,不可以换行

   多行注释 生成外部文档：javadoc -d . TestAnnotation.java

   注：注释不参与编译

关键字

1.定义：被Java语言赋予特定的含义单词,单词字母全部都是小写。

2.组成关键字的单词都小写，例如：class、public、static、void、interface、extends、abstract，数据类型:基本类型数据都是关键字,流程控制语句中相关选择结构/循环结构语句…等。

注意：goto,const这两个单词不是关键字，作为保留字使用。

标识符

1.定义：给类、接口、变量、方法起名字的字符序列。

2.标识符的组成规则:

1)英文大小写字母 2)数字字符 3)$和_下划线

注意：不能以数字开头、不能与关键字和保留字重名、严格区分大小写。

3.包（package）：文件夹（目录） 组成规则：包名全小写，只可以使用特殊字符"."，并且不以“.”开头或结尾。

例如：包名：com.qf.teach; com.qf.tech.bj;(全小写、不以.开头或结尾)

4. （1）给类、接口起名字：一个单词，首字母大写；多个单词，每个首字母大写。

（2）给变量、方法起名字：一个单词，全部小写；如果是多个单词，第一个单词小写，其余每个单词的首字母大写

(3)给常量起名字：一个单词，全部大写；多个单词，每个单词大写且每个单词之间使用下划线_连接。

常量的概念以及分类

1.定义：在程序的执行过程中，其值发生改变的量。

2.分类：

（1）字面值常量

a.字符串常量：使用双引号括起来的内容。 例如：“HelloWorld”

b.字符常量：使用单引号括起来的单个内容。 例如：‘A’ ‘a’

c.整数常量：默认为十进制 例如：100 200

d.小数常量：所有的小数。例如：3.1415 12.56

e.布尔常量：只有两个值 false,true

f.空常量：null

（2）自定义常量（跟final关键字有关，面向对象中讲）

注意：如果字符参与运算，需要在ASCII码表中寻找对应的一个整数值。例如：

‘A’=65 ‘a’=97 ‘0’=48

进制的由来，进制的转换

1.进制：就是进位制，是人们规定的一种进位方法。 对于任何一种进制–X进制，就表示某一位置上的数运算时是逢X进一位。二进制就是逢二进一，八进制是逢八进一，十进制是逢十进一，十六进制是逢十六进一。

2. 不同进制的组成规则

二进制：由0，1组成。以0b开头

八进制：由0，1，…7组成。以0开头

十进制：由0，1，…9组成。整数默认是十进制的

十六进制：由0，1，…，9，a，c，d，e，f组成。以0x开头

3. 进制转换

1byte=8bit;1k=1024byte;1M=1024K;1G=1024M;1T=1024G

（1）其他进制转到十进制：

系数：就是每一位上的数据。

基数：X进制，基数就是X。

权：在右边，从0开始编号，对应位上的编号即为该位的权。

结果：把系数基数的权次幂相加即可。

例如：将0b100、0100、0x100转换成十进制

0b100---------->12^2+02+02=4

0100------------>18^2=64

0x100----------->116^2=256

（2）十进制转到其他进制

规律：除积取余，直到商为0，余数取反。

例如：十进制52转换为二进制、八进制、十六进制

二进制：0b110100 八进制：064 十六进制：0x34

1. 8421编码

   是一种快速转换法，针对二进制和十进制

   1 1 1 1 1 1 1 1

   128 64 32 16 8 4 2 1

   例如：x进制---->y进制

   方式一：分布走

   （1）x进制------>十进制

   （2）十进制----->y进制

   方式二：二进制转八进制

   将二进制每三位分开，左边补零，分别求出来再组合。

有符号位数据表示法（符号位+数值位）

1.步骤：先将这个十进制数据-------->换算成二进制数据-------->写出原码------>反码------>得到补码

2.正数的原码、反码、补码都相同。最高符号位为0。

3.负数的最高符号位为1。求负数的反码时，最高符号位不变，数值位按位取反。求负数的补码时，最高符号位不变，在反码的末尾+1。

4.如果知道负数的补码求其原码时，最高符号位不变，末尾-1，即求得它的反码，在反码的基础上，符号位不变，数值位按位取反，即可得到对应的原码。

变量和数据类型

1.变量概念：在程序的执行过程中，其值发生改变的量。

2.变量的三要素：（1）数据类型（2）变量名（3）初始化值

3.针对java语言数据类型的划分：

（1）基本数据类型：

整数数据类型：byte 占1字节 取值范围为（-128~127）

short 占2字节

int 占4字节（默认类型）

long 占8字节

浮点类型： float 占4字节

double 占8字节（默认类型）

字符型： char 占2字节

布尔类型： boolean 占1字节

（2）应用数据类型：数组、类（具体类、抽象类）、接口

4.定义变量的注意事项：

(1).要遵循变量的三要素：

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

(2).先定义，但是在使用前必须对其先赋值。

(3).Java是一种强类型语言，不能重复定义变量。

(4).同一行上可以定义多个变量，开发过程中不建议使用。

5.类型提升

进行算数运算时：

（1）两个操作数有一个为double，计算结果提升为double

（2）如果操作数中没有doubl，有一个float，计算结果提升为float

（3）如果操作数中没有float，有一个long，计算结果提升为long

（4）如果操作数中没有long，有一个为int，计算结果提升为int

（5）如果操作数中没有int，均为short或byte，计算结果仍旧提升为int

特殊：任何类型与String相加（+）时，实为拼接，其结果自动提升为String

6.Java中强制类型转换：

语法格式： 目标数据类型 变量名 = （目标数据类型）（变量值）；

注意：强类型转换尽量不要使用，会损失数据的精度。

7.变量相加，先判断类型，然后看是否存在默认类型的提升，最终接收的类型是什么类型，判断是否符合，不符合强转。

常量相加，先相加，然后看其结果是否符合在接收的范围内，在范围内正确！不在范围内，利用二进制补码截取的方式进行计算。

运算符

1.运算符

I. 算术运算符：两个操作数进行计算

+（加、求和） -（减、求差） *（乘、求积） /（除、求商） %（模、求余）

II. 扩展算数运算符：一元运算符（只求一个操作数）

++（递增，变量值+1） --（递减，变量值-1）

情况一：单独使用：无论操作数在++或–的前面还是后面，都是自增或自减。

情况二：参与运算：如果++或–在操作数的前面，先自增或自减，再运算；如果操作数在++或–的前面，先运算，再自增或自减。

2.赋值运算符：等号右边赋值给等号左边

=（直接赋值） +=（求和后赋值） -=（求差后赋值） =（求积后赋值） /=（求商后赋值） %=（求余后赋值）

3.关系运算符：两个操作数进行比较

>(大于) <（小于） >=(大于等于) <=(小于等于) ==（等于） ！=（不等于）

特点：使用比较复合连接的表达式，无论是简单还是复杂，结果都是boolean类型。

4.逻辑运算符：

基本逻辑运算符： 逻辑单与（有0则0，同1则1） 逻辑单或（有1则1，同0则0）

逻辑异或（相同为0，不同为1） 逻辑单非（非真为0，非假为1）

扩展逻辑运算符：&&（语义：与/并且 描述：两个操作数，同时为真，结果为真）

||（语义：或/或者 描述：两个操作数，有一个为真，结果为真）

！（语义：非/取反 描述：意为“不是”，真即是假，假即是真）

逻辑&&和逻辑&的区别：

相同点：都是并列关系，有假则假

不同点：逻辑&&存在短路效果，逻辑&&连接的表达式，左边如果为false，右边的表达式就不执行了。但是逻辑&两边都执行。

逻辑||和逻辑|的区别：

相同点：有真则真。

不同点：逻辑||存在短路效果，逻辑 ||连接的表达式，左边如果为true，右边的表达式就不执行了。但是逻辑|两边都执行。

5.位运算符：

（1）位异或（^）：一个数据对另一个数据位异或两次，结果是它本身。

（2）移动符号：<<（左移） >>（右移） >>>（无符号右移）

<<（左移）：右边补齐0，最高符号位舍弃。

结论：将该符号左边的数据乘以2的移动次幂。

例： 2乘以8 等价于： 2<<3 即：22^3

>>（右移）：如果是正数，左边补齐0，右边数值位舍弃；如果是负数，左边补齐1，右边数值位舍弃。

结论：该数除以2的移动次幂。

例：24>>2 即： 24/2^2

>>>（无符号右移）：无论最高位是0还是1，左边都补齐0。

6.三目（三元）运算符：

格式：(表达式)?执行true的结果:执行false的结果;

控制台输入

1.程序运行中，可在控制台（终端）手动录入数据，再让程序继续运行。

2.导包语法：import 包名.类名；//将外部class文件功能引入到自身文件中。

3.使用顺寻：

①导入 java.util.Scanner。

JDK提供的类库位置：C:\Program Files\Java\jdk1.8.0_121\jre\lib

当前使用java.util.Scanner

②声明Scanner类型的变量。

格式：Scanner input = new Scanner(System.in);

//提示并接收

System.out.println(“请您输入：”);

数据类型 变量名 = 对象名.nextInt();

③使用Scanner类中对应的函数（区分类型）

.nextInt(); //获得整数

.nextDouble(); //获得小数

.nextLine(); //获得字符串

.next().charAt(0); //获得单个字符（这个是先接收为字符串，再将字符串转为字符）

注意：如果输入不匹配的数据，会产生java.util.InputMismatchException异常。

流程控制语句：

基本if、if else、多重if

选择结构：

概念：根据已知条件进行逻辑判断，满足条件后执行相应操作。

1、基本if选择结构

I.语法：

If(布尔表达式){

//代码块

}

后续代码……

II.执行流程：

（1）对布尔表达式进行判断。

（2）结果为true，则先执行代码块，再执行后续代码；结果为false，则跳过代码块，直接执行后续代码。

2、if …… else选择结构

I.语法：

if(布尔表达式){

//代码块1

}else{

//代码块2

}

后续代码……

II.执行流程：

（1）对布尔表达式进行判断。

（2）结果为 true，则先执行代码块1，再退出整个结构，执行后续代码；结果为false，则先执行代码块2，再退出整个结构，执行后续代码。

3、多重if选择结构

I.语法：

If(布尔表达式1){

//代码块1

}else if(布尔表达式2){

//代码块2

}else if(布尔表达式3){

//代码块3

}else{

//代码块4

}

II.执行流程：

（1）表达式1为true,则执行代码块1，再退出整个结构。

（2）表达式2为true，则执行代码块2，再退出整个结构。

（3）表达式3为true，则执行代码块3，再退出整个结构。

（4）以上均为false，则执行代码块4，再退出整个结构。

注意：相互排斥，有一个为true，其他均不再执行，适用于区间判断（区间条件，遵循从大到小或者从小到大）。

4、嵌套if选择结构

I.语法：

If(外层表达式){

If(内层表达式){

//内层代码块1

}else{

//内层代码块2

}

}else{

//外层代码块

}

II.执行流程

当外层条件满足时，在判断内层条件。

III.注意：

（1）一个选择结构中，可嵌套另一个选择结构。

嵌套格式正确的情况下，支持任意组合。

5、分支结构

I.语法：

Switch(变量|表达式){//变量：byte、short、int、char、String(JDK7+)或者表达式

case 值1:

逻辑代码1;

case 值2:

逻辑代码2;

case 值n:

逻辑代码n;

default:

未满足时的逻辑代码;

}

II.可判断的类型：

byte、short、int、char、String(JDK7+)

III.执行流程：

（1）如果变量中的值等于值1，则执行逻辑代码1.

（2）如果变量中的值等于值2，则执行逻辑代码2.

（3）如果变量中的值等于值n，则执行逻辑变量n。

如果变量中的值没有匹配的case值时，执行default中的逻辑代码。

循环结构

1.for循环

（1）语法：

for(初始部分：循环条件；迭代部分){

//循环操作

}

（2）执行流程：

I.首次执行初始部分（仅一次）。

II.对布尔表达式进行判断，结果为true，则执行逻辑代码。

III.本次执行完毕后，执行迭代部分，再次判断，结果仍旧为true，则继续执行

IV.直至布尔表达式的结果为false时，才会退出循环结构，执行后续代码。

（3）适用场景：明确循环次数或者明确使用范围。

（4）案例：打印水仙花数

class ForTest10{
	public static void main(String[] args){
	//统计所有的水仙花数
	int count=0;
	int X = 100;
	while(X<1000){
		int ge = X%10;
		int shi = X/10%10;
		int bai = X/10/10%10;
		int Y=ge*ge*ge+shi*shi*shi+bai*bai*bai;
		if(X==Y){
			count++;
			System.out.println(X);
			}
			X++;
		}
		System.out.println("水仙花数共有："+count);
	}
}
           

2.while循环

（1）语法：

while(布尔表达式){

//逻辑代码（循环操作）；

//步长语句；

}

（2）执行流程：

①先对布尔表达式进行判断，结果为true，则执行逻辑代码。

②本次执行完毕后，再次进行判断，结果仍旧为true，则再次执行逻辑代码。

（3）循环的组成部分

I.初始部分:用以判断的变量

II.循环条件：决定是否继续循环的依据

III.循环操作：单次执行的逻辑代码或任务

IV.迭代部分：控制循环条件改变的增量

（4）while的特点：

首次即有入口条件，先判断、再执行，适用于循环次数明确的情况。

（5）扩展格式：

初始化语句；

while(条件表达式){

循环体语句；

步长语句；

}

（6）案例：猜拳游戏

/*
需求：猜数字游戏
	1.java.lang.Math类：数学运算的类
	2.方法：获取随机数
		public static double redom()    取值范围[0.0-1.0)
键盘录入:
	1.手动录入一个数据，与随机数比较
	2.若比随机数大，输出"猜的大了，重新猜！"
	3.若比随机数小，输出"猜的小了，重新猜！"
	4.若和随机数一样，输出"恭喜你，猜对了！"
统计猜的次数：
	定义一个计数器count
*/
//导包
import java.util.Scanner;
class WhileTest{
	public static void main(String[] args){
		//获取一个随机数
		int count = 0;
		int number = (int)(Math.random()*100+1);
		//录入一个随机数
		while(true){
			Scanner input = new Scanner(System.in);
			//提示并获取
			System.out.println("请您输入一个数：");
			int guess = input.nextInt();
			//随机数和录入数据比较
			if(guess>number){
				System.out.println("猜的大了，重新输！");
			}else if(guess<number){
				System.out.println("猜的小了，重新猜！");
			}else{
				System.out.println("恭喜你，猜对了！");
				break;
			}
			count++;
		}
		System.out.println("总共猜了:"+count);
	}
}
           

3.do while循环

（1）语法：

do{

//逻辑代码（循环操作）

}while(布尔表达式)

（2）执行流程：

I.先执行一次循环操作之后，再进行布尔表达式的判断。

II.如果结果为true，则再次执行循环操作。

III.如果结果为false，才会退出循环结构，执行后续代码。

（3）特点：

首次没有入口条件，先执行，再判断。

（4）do while 的应用场景

应用场景：适用于循环次数不明确的情况。