Java.exe 解释器
Javac.exe 编译器
HelloWorld 程序编写
源代码
public class HelloWorld {
public static void main(String[] args){
System.out.println("Hello,World!");
}
}
1 第一行的第三个单词必须和文件名完全一致，包括大小写
2 第二行内容是固定的，表示程序执行的起点
3 第三行打印输出语句（即在屏幕上显示的东西，希望屏幕上显示什么，就在小括号中填写什么）
// 单行注释信息
/*
多行信息
*/
关键字的特点
1 完全小写的字母
2 在增强版的记事本中有特殊颜色
字符的命名(标识符)
1 不能以数字开头
2 不能是关键字
3 可以是英语，数字，符号
建议
1 首字母大写，后面每个首字母均大写
2 变量名，方法名命名建议 ：首字母小写，后面首字母大写
常量：程序运行期间，固定不变的量
1 字符串常量：用""引起来的部分即是字符串常量 举例 "123","Hello","abc"
2 整数常量：直接写上的数字，没小数点 举例 100,200，-20
3 浮点数常量：直接写上的数字，有小数点 举例 2.3
4 字符常量：用' '引起来的单个字符 举例 'A','6','中'
5 布尔常量：只有两种取值 true ,false
6 空常量：null,代表没有任何数据
基本数据类型
1 整数型 byte，short，int，long
2 浮点型 float，double
3 字符型 char，string（字符串）
4 布尔型 boolean
数据类型的注意事项
1 字符串不是基本类型，是引用类型
2 浮点型可能只是近似值而不是精确值
3 数据范围与字节数不一定相关 举例 float和long
4 浮点数当中默认类型是double，如果使用float，则应在后面加后缀F
如果是整数默认类型是int，如果使用long，则应在后面加后缀L
变量：程序运行期间，内容可以发生改变的量
创建变量： 数据类型 变量名称；
变量名称 = 数据值；（将右边的数据值赋值给左边）
也可以一步到位
数据类型 变量名称 = 数据值；（创建一个变量值，同时立刻将右边数据值赋值给左边）
变量注意事项：
1 如果创建多个变量，变量之间的名字不能重复
2 对于float和long类型，后缀F和L不能丢掉
3 如果使用byte和short类型变量，右侧数据值范围不能超过左侧类型范围
4 没有进行赋值的变量不能直接使用
5 变量使用不能超过作用域的范围
作用域：从定义变量的一行开始，一直到直接所属的大括号为止
当数据类型不一样时，将会发生数据转换
自动类型转换（隐式）
1 特点：代码不需要进行特殊处理，自动完成
2 规则：数据范围从大到小（从左向右）
强制类型转换
1 特点：代码需要进行特殊的格式处理，不能自动完成
2 格式：范围小的类型 范围小的变量名 = （范围小的类型） 范围大的数据
注意事项
1 强制类型转换不推荐使用，有可能精度损失，数据溢出
2 byte/short/char这三个类型都可以发生数学运算
3 byte/short/char这三个类型在运算的时候，都会被首先提升位int类型，然后再计算
4 布尔类型不能发生数据转换
ASCII码表（美国信息交换标准代码）
需要记得
48---0 65---A 97---a
算术运算符
运算符：进行特定操作的符号 例如：+
表达式：用运算符连起来的式子叫表达式 例如：20+5，a+b
四则运算：加 + 减 - 乘 * 除 / 取模（取余数，仅对整数除法有意义）：%
首先计算得到表达式结果，然后输出这个结果
两个变量，常量之间均可以数学运算，变量和常量也可以混合使用
对于整数的表达式，除法用整除，整数除以整数，结果仍为整数，只看商，不看余数
注意事项：一旦运算中有不同类型的数据，结果是数据类型范围大的那种
加号（+）的多种用法
1 对于数值来说，这就是加法
2 对于char来说，计算之前，char会被变成int，然后再计算 （关系参考ASCII）
3 对于字符串String（首字母大写，并不是关键字），加号（+）代表字符串连接操作
小括号的运算优先级最高！！！
自增运算符：++
自减运算符：--
基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
使用格式：写在变量名字之前，或者写在变量名字之后
使用方式：
1 单独使用：不和其他操作混合，自己独立成一个步骤
2 混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合
使用区别：
在单独使用的时候，前++和后++没有任何区别 比如 ++num和num++是一样的
在混合使用的时候，前++：立刻+1，先加后用
后++：先用原本变量的值，然后再+1，先用后加
只有变量才能使用自增自减符，常量不能发生改变，不能使用！！
赋值运算符
基本赋值运算符：=，代表将右侧数据赋值给左边的变量
复合赋值运算符：
+= a+=b a=a+b
-= a-=b a=a-b
*= a*=b a=a*b
/= a/=b a=a/b
%= a%=b a=a%b
只有变量才能用赋值运算符！常量不能写在赋值运算符的左边！
比较运算符
>
<
>=
<=
==（两个=连写才是相等，一个=代表的是赋值）
!=（不相等）
注意事项：比较运算符的结果一定是个布尔值，成立就是true，不成立就是false
如果进行多次判断，不能连着写 举例：1<x<3，书写错误！！
逻辑运算符
与（并且） && 全是true，才是true，否则就是false
或（或者） || 只要一个是true，就是true，全false才是false
非（相反） ！ 本来是true，现在是false，本来是false，现在是true
与（&&）和或（||）具有短路效应，如果根据左边已经可以判断出最终结果，那么右边代码将不再执行，从而节省一定的性能
注意事项：逻辑运算符只能用于布尔值（？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？）
与，或需要左右各有一个布尔值，但取反（！）只需要一个
对于与，或两个运算符，如果有多种条件可以连续写 举例：A && B && C
一元运算符：只需要一个数据就可以操作的运算符 举例：取反！，自增++，自减--
二元运算符：两个数据可以操作的运算符
三元运算符：三个数据可以操作的运算符
格式
数据类型 变量名称 = 条件判断 ？ 表达式A ：表达式B;
流程：
首先判断条件是否成立
如果成立为true，那么将表达式A的值赋给左侧的变量
如果不成立为false，那么将表达式B的值赋给左侧的变量
注意事项：必须同时保证表达式A和表达式B都符合左侧数据类型的要求
三元运算符的结果必须被使用
定义一个方法的格式
public static void 方法名称 （）{
方法体
}
方法名称的命名规则和变量一致
方法体：大括号中可以包含任意条语句
注意事项：方法定义的先后顺序无所谓
方法定义不能产生嵌套包含关系！！
方法定义好后，不会执行，如果需要执行方法，一定要进行方法的【调用】！
如何调用方法：
方法名称（）；
对于byte/short/char三种类型来说，如果右侧赋值的数值没有超过范围
那么javac编译期将会自动隐含的为我们补上一个（byte）（short）（char）
注意：1 如果没有超过左侧的范围，编译器补上后继续
2 如果右侧超过左侧范围，编译器会直接报错
再给变量赋值的时候，如果右侧的表达式全是常量，没有变量，那么编译器javac将会直接将常量计算得到结果
顺序结构
顺序下来，一条路走到黑
判断语句
1 if if （关系表达式）{
执行句式；
}
2 if...else if (关系表达式) {
执行句式1；
} else {
执行句式2；
}
3 复合语句 if (判断条件1) {
执行语句1；
} else if （判断条件2）{
执行语句2；
}
...
else if （判断条件n）{
执行语句n；
} else {
执行语句n+1；
}
选择语句
1 switch语句
switch（表达式）{
case 常量值1：
语句体1；
break；
case 常量值1：
语句体1；
break；
...
default:
语句体n+1；
break；
}
注意事项：
1 多个case后面的数值不可以重复！
2 switch下面小括号中只能是下列数据类型
基本数据类型：byte/short/int/char
引用数据类型：String字符串，enum枚举
3 switch语句格式灵活：前后顺序可以颠倒，而且break语句还可以省略（匹配到哪个case就从哪个case向下执行，直到遇到break或者整体结束）
循环结构的基本组成部分，一般为四部分
1 初始化语句：在循环开始最初执行，而且只做唯一一次
2 条件判断：如果成立，则循环继续;如果不成立，则循环退出
3 循环体：重复要做的事情内容
4 步进语句：每次循环后都要进行的扫尾工作，每次循环结束后都要执行一次
for循环语句
for （初始化表达式；条件判断；步进语句）{
循环体
}
while循环语句
标准格式：
while （条件判断）{
循环体
}
扩展格式：
初始化语句；
while （条件判断）{
循环体；
步进语句；
}
do-while循环的标准格式
初始化表达式
do {
循环体
步进语句
} while （条件判断）；
三种循环的区别：
1 如果条件从来没满足过，for和while循环将执行0次，但是do-while循环至少执行1次
2 for循环的变量在小括号中定义，只有在循环内部才能使用，while循环和do-while循环初始化语句本来就在外面，所以出来循环后还可以继续使用
3 循环次数确定适合用for循环，其他情况适合while循环
break关键字的用法
1 可以用在switch语句，一旦执行，整个switch语句立刻打断
2 可以用在循环语句中，一旦执行，整个循环立刻结束，打断循环
continue关键词的用法、
1 一旦执行，立刻跳过当前次循环，同时进入下一次循环
死循环 永远停不下来的循环
死循环的标准格式
while（true）{
循环体
}
循环嵌套
IDEA，是一款专门用于提升Java开发效率的软件
IDEA 快捷键
Alt+Enter 自动修正代码
Ctrl+Y 删除光标所在行
Ctrl+D 复制光标所在行的内容，插入光标位置下面
Ctrl+Alt+L 格式化代码（建议经常使用）
Ctrl+/ 单行注释，再按取消注释
Ctrl+Shift+/ 选中代码注释，多行注释，再按取消注释
Alt+Ins 自动生成代码
Alt+Shift+上下箭头 移动当前代码行
Ctrl+D 重复选中区域
println 中的“ln”代表换行 1
1
1
print 不换行 111
for循环的快捷方式 次数.fori
定义方法的注意事项
1 定义方法的先后顺序无所谓
2 定义方法必须挨着，不能在方法内部定义另一个方法
3 定义方法后不会自动执行，如果希望执行，一定要进行方法的调用：单独调用，打印调用，赋值调用
4 如果方法有返回值，必须写上“return 返回值；”，不能没有
5 return后面的返回值数据，必须和方法的返回值类型对应起来
6 对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己
7 对于方法中最后一行的return可以省略
定义格式
修饰符 返回值类型 方法名称（参数类型 参数名称，。。。）{
方法体
return 返回值
}
修饰符：现阶段固定为 public static
返回值类型：方法产生的数据结果是什么类型
方法名称：方法的名字，规则和变量一样
参数类型：进入方法的数据是什么类型
参数名称： 进入方法的变量的名称 参数如果有多个，用逗号隔开
方法体：方法需要做的事，（若干行代码）
return：两个作用，第一个，停止当前方法，第二个，将后面的值返还给调用处
返回值：方法执行后得到的结果
return后面的返回值必须和前面的返回值类型一致！！
方法的三种调用格式
1 单独调用 方法名称（参数）；
2 打印调用 System.out.println(方法名称（参数）)；
3 赋值调用 数据类型 变量名称 = 方法名称（参数）；
注意事项：此前学习的方法，固定类型为void，这种方法只能单独调用，不能打印调用和赋值调用
有参数：当一个方法需要一些数据条件才能完成任务的时候
无参数：小括号留空，一个方法不需要任何条件就能独立完成任务
方法的重载（overload） 多个方法的名称一样，但参数列表不一样
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能
方法重载与下列因素有关
1 参数个数不同
2 参数类型不同
3 参数多类型顺序不同
方法重载与下列因素无关
1 参数名称
2 与方法的返回值类型无关，
数组
是一种容器，可以存放多种数据值
特点
1 数组是一种引用数据类型
2 数组中的多个数据的类型必须统一
3 数组长度在运行期间不可被修改
数组的初始化：在内存中创建一个数组，并且向其中赋予一些默认值
两种常见初始化方式
1 动态初始化（指定长度）：创建数组的时候，直接指定数组中数据元素的个数
2 静态初始化（指定内容）：创建数组的时候，不直接指定数据个数的多少，而是根据具体的数据内容指定
动态初始化数组的格式
数据类型【】数组名称 = new 数据类型 【数组长度】；
解释：
左侧数据类型：代表数组中保存的数据，统一是什么类型
左侧【】：代表数组中储存的数据
左侧数组名称：给数组起的名字
右侧的new：代表创建数组的动作
右侧数据类型：必须和左侧数据类型保持一致
右侧数组长度：数组中到底可以保存多少个数据，是个int数字
静态初始化数组的格式
数据类型【】数组名称 = new 数据类型 【】{元素1，元素2，。。。}；
静态初始化数组的省略格式
数据类型【】数组名称 = {元素1，元素2，。。。}；
注意事项：
1 静态数组初始化没有直接指定长度，但仍会自动推算得到长度
2 静态数组初始化标准格式可以拆分为两个步骤
3 静态数组初始化省略格式不能拆分
访问数组元素的格式：数组名称【索引值】
索引值：就是一个int数字，代表数组当中元素的编号
【注意】 引值从0开始，一直到数组的长度-1为止 =
使用动态初始化数组的时候，其中元素会自动拥有一个默认值，规则如下
如果是整数类型，那么默认为0
如果是浮点类型，那么默认为0.0
如果是字符类型，那么默认为‘\u0000’
如果是布尔类型，那么默认是false
如果是引用类型，那么默认是null
【注意】：静态初始化也有默认值的过程，只不过程序立刻将默认值替换为大括号中的具体数值
Java的内存需要划分为5个部分：
1 栈(Stack):存放的都是方法中的局部变量
局部变量：方法的参数，或者是方法{}内部的变量
作用域：一旦超过作用域，立刻从栈内存中消失
2 堆（Heap）：凡是new出来的东西，都在堆当中
堆内存里面的东西都有一个地址值：16进制
堆内存里面的数据，都有默认值，规则：
如果是整数类型，那么默认为0
如果是浮点类型，那么默认为0.0
如果是字符类型，那么默认为‘\u0000’
如果是布尔类型，那么默认是false
如果是引用类型，那么默认是null
3 方法区（Method Area）：储存class相关信息，包含方法的信息
4 本地方法栈（Native Method Stack）：与操作系统相关
5 寄存器（pc Register）：与CPU相关
数组索引越界异常 ArrayIndexOutOfBoundsException
原因：索引编号有误
解决：修改成为存在的正确索引编号
空指针异常 NullPointerException
原因：没有进行new创建
解决：创建new
public class Main {
public static void main(String[] args) {
A:for(int i=1;i<=100;i++){
B:for (int m=2;m<=i-1 && i%m!=0;m++){
if(m<i-1){
continue B;
}else{
System.out.println(i);
}
}
}
}
}
通常情况下，一个类不能直接使用，需要根据类创建一个对象，才能使用
1 导包：指出需要使用的类，在什么位置
import 包名称，类名称；
2 创建，格式：
类名称 对象名 = new 类名称 （）；
3 使用，分为两种情况
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名（参数）
注意事项：
如果成员变量没有进行赋值，那么就会有一个默认值，规则和数组一样
局部变量和成员变量
1 定义的位置不一样 【重点】
局部变量：在方法的内部
成员变量：在方法的外部，直接写在类当中
2 作用范围不一样 【重点】
局部变量：只有方法当中才可以使用，除了方法就不能再使用
成员变量：整个类全部可以通用
3 默认值不一样【重点】
局部变量：没有默认值，如果想使用，必须手动进行赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样
4 内存的位置不一样
局部变量：位于栈内存
成员变量：位于堆内存
5 生命周期不一样
局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
面向对象三大特准：封装，继承，多态
封装性在Java中的体现
1 方法就是一种封装
2 关键字private也是一种封装
封装：就是将一些细节信息隐藏起来,对于外界不可见
一个标准的类通常要拥有下面四个组成部分
1 所有的成员变量都要使用private关键字修饰
2 为每一个成员变量编写一对Getter/Setter方法
3 编写一个无参数的构造方法
4 编写一个全参数的构造方法
Scanner类的功能：可以实现键盘输入数据，到程序当中
引用类型的一般使用步骤
1 导包
import 包路径，类名称；
如果使用的目标类，和当前类处于同一个包下，则可以省略包语句不写
只有java.long包下的内容不需要导包，其他的包都需要import语句
2 创建
类名称 对象名 = new 类名称（）；
3 使用
对象名.成员方法名（）
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
