基础内容
1.如何高效的学好java
多写代码，多写笔记，多写文章
多练交流，多练思维，多练技能
多分享，多提问，多思考
最重要（坚持）
2.计算机应用领域
1）科学计算
2）数据处理
3）自动控制
4）计算机辅助设计
5）人工智能
…
3.计算机硬件组成
cpu，主板，内存，电源，主机箱，硬盘，显卡，键盘鼠标，显示器…
io设备(input/oupput)：输入输出设备
4.计算机软件
计算机软件分为系统软件与应用软件
系统软件：DOS，Windows,Linux,Unix,IOS,Android,Mac
#应用软件：WPS,QQ,微信，英雄联盟，绝地求生…
5.DOS命令
DOS命令：
| 命令 | 用法 |
|---|---|
| exit | 退出当前DOS命令窗口 |
| DOS复制： | 窗口中任意位置点击鼠标右键 |
| dir | 列出当前目录下的所有子文件/子目录 |
| cd | （ change directory【改变目录】） |
| cd … | 回到上级目录 |
| cd \ | 直接回到根部路径 |
| c:回车 d:回车 e:回车 f:回车 | 切换盘符 |
| Ipconfig | 查看IP地址 |
| Xxx -version | 查看版本 |
| Del * | 删除 |
| md | 创造一个文件夹 |
| rd | 删除文件夹（必须为空） |
| rd /s /q | 强制删除 |
| rd /s | 带内容的目录(文件夹):询问是否删除这个目录 |
| cls | 清楚屏幕 |
6.Java的特性与优点
1.简单性
2.面向对象
3.可移植性（跨平台性）
4.高性能
5.分布式
6.动态性
7.多线程
8.安全性
9.健壮性
7.Java的三大版本
JavaSE：标准版（桌面程序，控制台开发…)
JavaME（手机，小家电…）
JavaEE（Web端，服务器开发…）
8.java的基本含义：
JDK：（Java Development Kit）java开发工具包
JRE：（Java Runtime Envirment）java运行环境
JVM:（Java Virtual Machine）java虚拟机
下载地址：https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html
安装jdk完成之后:进入dos，输入java -version:查看当前本地的jdk的版本信息
安装好jdk之后:需要在安装目录的bin目录去使用的编译命令和执行命令
javac.exe 编译命令
java.exe 运行命令
path环境（系统配置）：
配置path环境变量的原因:### 三级标题
我们需要在任何目录下使用javac和java对Java源文件进行编译和运行
方式1:(存在弊端)
win10/win8---->此电脑---->右键属性---->高级系统设置---->环境变量---->系统变量 找到path将jdk安装目录的bin路径复制到path里面即可!
path: jdk\bin的路径
弊端:
1)当jdk版本升级了,开发者需要手动更改path:可能造成的path其他变量更改了,所以不好!
2)二阶段使用tomcat服务器(使用java编写的),启动的时候会寻找计算机中系统变量中的path是否存在
JAVA_HOME,如果找不到,服务器启动时候出现"闪屏";
使用方式2:（推荐)：
win10/win8---->此电脑---->右键属性---->高级系统设置---->环境变量---->系统变量
新建变量名:
JAVA_HOME
变量值:
jdk路径
优点:
1)不需要手动更改path
2)tomcat服务器启动的时候,找到JAVA_HOME变量,就不会出现闪屏
path环境变量的执行流程:
写好了java文件,对java文件进行编译和运行;
1)首先需要在dos中找到java文件的目录,如果找不到
2)就会在path环境变量中找%JAVA_HOME%\bin
3)如果path中都没有这个文件,那么久会提示 找不到文件…
classpath:临时环境变量(了解)：
classpath执行流程:先在系统变量中寻找是否存在classpath的路径
如果存在优先的是这里面的xxx.class文件
基础语法
1.注释
单行注释
//注释当前行
多行注释
/*
注释内容
注释内容
...
*/
文档注释（javadoc）
Javadoc命令是用来生成自己的API文件
参数信息 ：
1.@author：作者名
2.@version：版本号
3.@since：指明需要最早的jdk版本
4.@param:参数名
5.@return：返回值情况
6.@throws：异常抛出情况
/**
*\javadoc注释
*\javadoc注释
*\javadoc注释
*\javadoc注释
...
*/
2.标识符与关键字
2.1标识符
什么是关键字？
被Java语言赋予特定含义的单词!
| 用于定义数据类型的关键字 | 名称 |
|---|---|
| class | interface,byte,short,int |
| long | float,double,char,boolean |
| void | |
| 用于定义数据类型值的关键字 | |
| true | false,null |
| 用于定义流程控制的关键字 | |
| if | else,switch,case,default |
| while | do,for,break,continue |
| return |
2.2关键字
什么是标识符
在Java原程序当中凡是程序员有权利自己命名的单词都是标识符（黑色字体）
可以标识的元素：类名、方法名（main）、变量名、接口名、常量名（srgs）…
标识符的组成:
一个合法的标识符只能由“数字、字母、下划线_、$”组成，不能含有其他符号
开头不能是数字
严格区分大小写
关键字（蓝色的）不能做标识符
理论上无长度限制，最好不要太长
如果是单个单词:
字母全部小写
举例：
main()
int price=100;
如果是多个单词:
第一个单词字母全部小写,从第二个单词开始每个单词首字母大写,其余小写(小驼峰命名法)
举例:
cheacUserNmae()
int applePrice=100;
给常量命名的规则:
如果是单个单词:字母全部大写(推荐多个单词)
举例:
HELLO=100;
如果是多个单词:每个单词字母大写,单词和单词使用下划线隔开
举例:
HELLO_WORLD=100;
3.数据类型
3.1基本数据类型
3.1.1数值类型
整数类型
1.byte占一个字节的位置，取值范围是：-127-128，默认值为0；
2.short占两个字节的位置，取值范围是：-32768-32767，默认值为0；
3.int占四个字节的位置，取值范围是：-2147483648-2147483647，默认值为0；
4.long占八个字节的位置，取值范围是：-9223372036854775808-9223372036854775807，默认值为0
浮点类型
1.float占四个字节的位置，默认值为0.0f；
2.double占八个字节的位置，默认值为0.0d
字符类型
char占两个字节的位置，取值范围是：0-65535，默认值为false（0）
3.1.2boolean类型
占一个位的位置，其值只有True和False两个
字节
字节：是计算机中处理数据的基本单位，习惯用B。
1 byte = 8 bit（1bit表示一个二进制位）
1 KB = 1024 byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB
整数型当中的byte类型，占用1个字节，所以byte类型的数据占用8个比特位。
3.2引用数据类型
数组 ，类，接口
3.3数据类型拓展
进制
二进制：0b
八进制：0
十进制
十六进制：0x
3.4数据类型的转换
由低到高
byte,short,char–>int–>long–>float–>double
public calss 练习{
public static void main(String[] args){
/*
100L是long类型字面值
x是long类型变量
不存在类型转换，直接赋值
*/
long x=100L;
/*
x是long类型，8个字节
y是int类型，4个字节
编译报错，大容量不能直接变一个小容量
int y=x;
大容量转换小容量，需要进行强制类型转换
强制类型转换需要加“强制类型转换符”
加上强制类型转换符之后编译通过了，但是运行阶段可能损失精度
随意强制类型转换谨慎使用，因为损失精度之后损失很严重
强制转换原理
原始数据 00000000 000000000 00000000 00000000 0000000 0000000 00000000 01100000
强制转换之后：00000000 0000000 00000000 01100100
将左边的二进制砍掉！
*/
int y=(int)x;
System.out.println(y);
/*
原始数据：00000000 000000000 00000000 00000000 10000000 00000000 00000000 000000000
强制转换之后的数据：10000000 00000000 00000000 00000000(补码形式）
以上补码转换到原码就是最终结果
*/
long k=2147483648L;
int e=(int)k;
System.out.println(e);//损失精度非常严重，结果是负数【-2147483648】
/*
依据目前内容，以下程序无法编译
理由：50是int类型的字面值，b是byte类型的变量
显然是大容量int转换成的小容量byte
大容量转换成小容量是需要添加强制转换符的，一下程序没有添加强制转换符号，所以编译报错
但是，实际编译时，以下代码通过了，盖子面值可以直接赋值给byte类型的变量
*/
byte b=50;//可以
byte c=127;//可以
//编译报错，128这个int类型的字面值超出了byte类型的取值范围，不能直接赋值给byte类型的变量
//byte b1=128;
byte b1=(byte)128;//-125
/*
纠正错误,需要使用强制类型转换符，但是一定会损失精度
原始数据：00000000 00000000 00000000 10000000
强制转换之后10000000【这是储存在计算机内部的，这是一个补码，】
System.out.println(b1);
*/
}
}
注意：
1.有多种数据类型混合运算时，系统首先自动将所有数据转换为容量最大的那种数据类型，然后再进行计算
2.当我们把容量大的数据类型赋值给容量小的数据类型时就会报错，反之则会自动转换
3.byte（short）和char之间不会相互自动转换
4.byte，short，char它们三者可以计算，在计算时首先转换为int类型
5.boolean不参与转换
6.自动提升原则：表达式结果的类型自动转换为操作数中最大的类型。
4.变量
变量是什么？
变量就是可以变化的量
变量本质上来说是内存中的一块空间，这块空间数据类型、有名字、有字面值
变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域
变量的声明/定义变量名的格式
数据类型 变量名（合法标识符）
注意事项
1.每个变量都有类型，类型可以是基本类型也可以是引用类型。
2.变量名必须是合法的标识符。
3.变量声明是一句完整的语句，因此每一个声明都要以分号结束
变量的赋值：
语法格式：变量名=字面值（“=”是赋值运算符 ）
Int i=10;//声明和赋值可以放在一起完成
/*
变量赋值之后，可以重新赋值（变量值可变）
有了变量的概念之后，内存空间得到后可重复使用
*/
int i=10;
System.out.println(i);//10
int i=100;
System.out.println(i);//100
...
...
变量的作用域
作用域：变量的有效范围，在什么范围之内是可以被访问的，只要出了这个范围，变量就不会被访问了。出了{}就不认识了。
变量的分类：
根据变量声明的位置来分类：
局部变量：在方法体中声明的变量
成员变量：在方法体外，类体之内声明的变量
（不同作用域中，变量名可以重名；同一作用域中，变量名不能重名）
变量的命名规范
1）所有变量，方法，类名：见名知意
2）类成员变量：首字母小写和驼峰原则，mounthSalary
3）局部变量：首字母小写和驼峰原则
4）常量：大写字母和下划线，MAX_VAULE
5）类名：首字母大写和驼峰原则，Man，GoodMan
6）方法名：首字母小写和驼峰原则，run（），runRun()
5.常量
初始化之后不会再改变值
1）字面值常量
整数常量：所有的整数
小数常量：所有的小数
字符常量：单引号引起来，只有一个字符，必须有内容
字符串常量：双引号引起来的内容，可以写多个，也可以不写
布尔常量：只有两个值，true和false
空常量;只有一个值
**字符串常量:**使用双引号包裹起来的内容:称为"字符串常量"
举例:
“我爱高圆圆”
“HelloWorld”
**字符常量:**使用单引号包裹起来的内容
举例:
‘a’,‘A’,‘0’
‘我’
‘abc’ 非法数据(只能单引号括起来的单个内容)
整数常量:
100 包含"进制" 整数----默认十进制
64
…
小数常量:
3.14
12.56
布尔常量:true false
空常量:null
引用数据类型默认值null
2)自定义常量
(面向对象后面讲:关键字:final:状态修饰符)
6.运算符
运算符有优先级，一个表达式当中有过多个运算符，不确定的加（），优先级得到提升
++出现在变量后，先做赋值运算，在对变量中保存的值进行自加1
int a=100;
int b=a++;
//a=a+1;
System.out.println(a);//101
System.out.println(b);//100
int e=100
System.out.println(e++);//100
System.out.println(e);//101
++出现在变量前，先进性自加1，在进行赋值
int n=200;
//n=n+1;
int m= ++n;
System.out.println(n);//201
System.out.println(m);//201
int n=200;
System.out.println(++n);//201
System.out.println(n);//201
关系运算符
关系运算符的运算结果一定是布尔类型：true/false
逻辑运算符
& 逻辑与 （两边的算子都是真，结果才为真）
| 逻辑或 （两边算子只有一个是真，结果就是真）
! 逻辑非 （取反）
^ 逻辑异或 （两边算子不一样（真假/假真），结果就是真）
&& 短路与 （与逻辑与运算结果相同，不过短路与存在短路现象）
前半被判为false，整句便是false，后半便不再执行（比逻辑与更智能）
|| 短路或 （与逻辑或运算结果相同，不过短路或存在短路现象）
前半为真，整句为真，后半不再执行
逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型
赋值类运算符
基本的赋值运算符：
=
扩展的赋值运算符：
+= -= *= /= %=
字符串连接运算符
关于java中的“+”运算符
1.加法运算（数字+数字）
2.字符串的连接运算（字符串+字符串）
3.在一个表达式当中可以出现多个“+”，在没有添加小括号的前提下，遵循自左向右依次运算
int a=1;
int b=2;
System.out.println(a+“+”+b+“=”+(a+b));//1+2=3
System.out.println(""+a+b);//12
System.out.println(a+b+"");//3
三元（三目/条件）运算符
语法规则：
布尔表达式？表达式1：表达式2
执行原理：
当布尔表达式结果为真时，选择表达式1作为整个表达式的执行结果
当布尔表达式结果为假时，选择表达式2作为整个表达式的执行结果
boolean sex=true;
Char c =sex ? ‘男’:‘女’;//男
原码，反码，补码
1.二进制的最高位是符号位：0表示正数，1表示负数
2.正数的原码，反码，补码都是一样的（三码合一）
3.负数的反码等于它的原码符号位不变，其他位取反
4.负数的补码等于它的反码+1，负数的反码等于负数的补码-1
5.0的反码和补码都是0
6.在计算机运行的时候，都是以补码的方式来运算的
7.当我们看运算结果的时候，要看它的原码。
位运算符
| 位运算符 | 含义 |
|---|---|
| << | 乘2的n次幂 |
| “>>” | 除2的n次幂 |
| “>>>” | 被移位二进制最高位无论是0还是1，空缺位都用0补。 |
A=00111100;
B=00001100;
A&B：按位比较，全1为1，有零为零：00001100
A|B：按位比较，有1为1，全零为零：00111100
A^B：按位比较，相同为0，不同为1：00110000
~B：比较上面的值，按位取反：11110011
包机制
为了更好的组织类，Java开发了包机制，用于区别类名的命名空间。
包语句的语法格式：
package pkg1[.pkg2[.pkg3…]];
一般运用公司类名的倒置用作包名
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包，使用“import”语句
可以完成此功能。
import package1[.package2…].(classname|*);
Import com.xue.base.*//*代表会导入包中的所有类
流程控制
1.用户交互Scanner
我们可以通过Scanner来获取用户的输入。
基本语法：
Scanner s=new Scanner(System.in);
通过Scanner类的next（）与nextLine（）的方法获取输入的字符串，在读取前我们一般需要使用hasNext（）与hasNextLine（）判断是否还有输入的数据。
next():
1.一定要读取到有效的字符后才可以结束输入；
2.对输入有效的字符之前遇到的空白，next（）方法会自动的将其去除掉；
3.只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符；
4.next（）不能得到带有空格的字符串
nextLine（）：
1.以Enter为结束符，也就是说，nextLine（）方法返回的是输入回车之前的所有字符；
2.可以获得空白
eg：输入一些数，可以计算出这些数的平均值及和，每输入一个数字用回车确认，通过输入非数字 来结束程序并执行结果。
2.顺序结构
3.选择结构
3.1if语句
if语句的语法结构：四种编写方式
/*PS.对于java中的if语句来说，只要有一个分支执行，整个if语句全部结束。*/
//第一种：
if（布尔表达式）{
/*
java语句；
java语句；
java语句；
java语句；
...
*/
}
//第二种：
if(布尔表达式){
/*java语句；
java语句；
...
*/
}else{
/*
java语句；
java语句；
...
*/
}
//第三种：
if(布尔表达式){
/*
java语句；
java语句；
...
*/
}else if(布尔表达式）{
/*
java语句；
java语句；
...
*/
}else if(布尔表达式）{
/*
java语句；
java语句；
...
*/
}.....
//第四种：
if(布尔表达式){
/*
ava语句；
java语句；
...
*/
}else if(布尔表达式）{
/**
java语句；
java语句；
...
*/
}else if(布尔表达式）{
/*
java语句；
java语句；
*/
...
}else{
/*
java语句；
java语句；
...
*/
}
第二种编写方式和第四种编写方式都带有else分支，这两种方式可以保证100%会有分支执行。
所有的控制语句是可以相互嵌套使用的。只要河里嵌套就行。
嵌套使用时，代码格式保持完美。【该缩进时，必须缩进】
if语句的分支中只有一条java语句时，大括号可以不写。
3.2switch语句
switch语句的语法结构：
switch(int或String类型的字面值或变量){
case int或string类型的字面值或变量：
java语句；
...
break；
case int或string类型的字面值或变量：
java语句；
...
break；
case int或string类型的字面值或变量：
java语句；
...
break；
Default：
java语句;
....
}
执行原理：
1 switch后面小括号当中的“数据”和case后面的“数据”进行一一匹配，匹配成功的分支执行。
2 按照自上而下的顺序依次匹配。
3 匹配成功的分支执行，分支当中最后有“break”语句的话，整个switch语句终止。
4 匹配成功的分支执行，分支当中没“break”语句的话，直接进入下一个分支执行（不进行匹配），这种现象被称为case穿透现象（提供break语句可以避免穿透现象）
5 所有分支都没有匹配成功的话，当有default语句时，会执行default语句中的
6 switch后面和case后面只能是int或string类型的数据，不能是其他类型
当然byte short char也可以直接写到switch和case后面，因为他们可以进行自动类型转换转换成int类型。
7 case可以合并：
int i=10;
switch(i){
case1:case2:case3:
System.out.println(“test code!”);
}
4.循环结构
4.1 while循环
while循环的语法结构：
while（布尔表达式）{
循环体；
}//表达式为true时，执行循环体
while循环的循环次数：0到N次，while循环的循环体可能一次都不执行
//输出0-10：
public class ArrayOutPut {
public static void main(String[] args){
int i=0;
while (i<10){
System.out.print(i+"\t");
i++;
}
}
}
4.2do…while循环
\do…while循环的语法结构：
do{
循环体；
}while（布尔表达式）；
do…whlie循环体代码片段执行次数是：1-N次（至少一次）
do…while循环的注意事项：do…while循环语句最终有一个分号
4.3 for循环
for语句的语法结构：
for(初始化表达式；布尔表达式；更新表达式）{
//是需要重复执行的代码片段【循环体：由java语句构成】
}
eg：
public class JavaApplication5 {
public static void main(String[] args) {
for(int i=1;i<=10;i+=2 ){
System.out.println("i="+i);
}
for(int j=2;j<=10;j+=2 ){
System.out.println("j="+j);
}
for(int k=10;k>0;k-- ){
System.out.println("k="+k);
}
for(int z=100;z>0; ){
System.out.println("z="+z);
z-=10;
}
}
}
循环语句和条件判断语句嵌套使用
最好不要想太多，即使循环体当中是一个for循环，不要将这个for特殊化，
【for和if的嵌套】
eg2：
//100以内的所有质数
public class ForFor嵌套求质数 {
public static void main(String[] args) {
//给范围
for(int i=2;i<=100;i++){
//求素数
boolean sushu = true;
for(int j=2;j<i;j++){
if(i%j==0){
sushu = false;
break;
}
}
//输出
if(sushu){
System.out.print(i+"\t");
}
}
}
}
eg3：
//10000以内的所有质数，每八个数字换一行
//方法①
public class ForFor嵌套求质数 {
public static void main(String[] args) {
int count=0;
//给范围
for(int i=2;i<=10000;i++){
//求素数
boolean sushu = true;
for(int j=2;j<i;j++){
if(i%j==0){
sushu = false;
break;
}
}
//输出
if(sushu){
count++;
System.out.print(i+"\t");
if(count%8==0){
System.out.println();
}
}
}
}
}
//方法②
public class 求质数升级版 {
public static void main(String[] args){
int count=0;
for(int i=1;i<10000;i++){
boolean sushu = true;
for(int j=2;j<i;j++){
if(i%j==0){
sushu = false;
break;
}
}
//输出
if(sushu){
count++;
System.out.print(i+"\t");
if(count==8){
System.out.println();
count=0;
}
}
}
}
}
增强for循环
语法格式：
for（声明语句：表达式）{
代码句子
}
eg:数组中输出 数组中的所有元素
public class forZengQiang {
public static void main(String[] args){
int[] numbers = {10,20,30,40,50};
for(int x:numbers) {
System.out.println(x);
}
}
}
4.4跳转语句
4.4.1break
break是Java语句中的关键字，翻译为“中断/折断”
break+“；”可以成为以单独的完整java语句：break；
break语句使用在switch语句当中，用来终止switch的语句执行。
break语句同样可以使用在循环语句当中，用来终止循环的执行
break语句使用在for、while、do…while循环语句当中用来跳出循环，终止玄幻的执行。因为当程序循环到某个条件的时候，后续循环没必要执行，在执行也是耗费资源，所以可以终止循环，这样可以提高程序的执行效率。
在默认情况下，break终止的是离他最近的循环语句：
4.4.2continue
continue表示是：继续/下一个
continue的java语句：continue;
break和continue的区别：
break：跳出循环
continue:进入下一循环
扫一扫
1161
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
