流程控制语句
流程控制语句分为顺序、选择和循环三部分。
顺序：
顺序语句就是从上往下执行
选择：
第一种：
if(条件表达式){
语句;
}
条件表达式成立,则执行语句,否则不执行;
第二种：
if(条件表达式){
语句1;
}else{
语句2;
}
执行流程:
1)首先判断条件表达式是成立,如果成立,则执行语句1
2)否则,不成立,则执行语句2
注意:else后面不能带()
第三种：
if(条件表达式1){
语句1;
}else if(条件表达式2){
语句2;
...
...
}else{
语句n;
}
流程:
1)先判断表达式1是否成立,成立,则执行语句1
2)不成立,则判断表达式2是否成立,成立,执行语句2;
否则依次...进行判断
...
3）如果上面都不成立,则执行else语句,最终结束;
if...else...三种格式的区别：
三元运算符只是一种运算符号，它不是流程控制语句，使用三元运算符得到的是运算出的结果数据，而if...else可以在进行条件判断后进入下一个流程，范围比三元运算符大很多。
switch语句
switch(表达式){
case 值1:
语句1;
break ;
case 值2:
语句2;
break ;
...
...
default:
语句n;
break ;
}
执行流程:
1)表达式中的值先和case值1比较,如果匹配,执行语句1,语句break,语句结束;
2)case值1不匹配,继续和case值2进行比较,如果一致,执行语句2,swich结束;
...
...
3)如果上面的case的值和表达式中的结果值都不匹配,执行default语句,
执行语句n,switch语句结束;
case穿透：
如果执行case语句之后没有break,那么会一直向下执行，知道遇见break才会停止。
循环：
for循环：
for(初始化语句;条件表达式;控制体语句或步长语句){
循环体语句;
}
执行流程:
1.先初始化语句进行赋值。
2.判断条件表达式是否成立,如果成立,执行循环体语句。
2.1继续执行控制台语句或者步长语句 对初始化语句的变量进行自增或者自减。
2.2继续判断条件表达是否成立,如果成立,按照上面 这种方式执行;
2.3如果变量自增或者自减到条件表达式不成立为止,循环语句结束!
while循环：
while(条件表达式){
循环体语句；
控制体语句或者步长语句
}
扩展格式：
初始化语句；
while(条件表达式){
循环体语句；
控制体语句或者步长语句
}
执行流程:
1)初始化语句进行变量赋值
2)判断条件表达式是否成立,
成立,执行循环体语句,依次执行控制体语句(对变量控制)
继续回到2)进行判断
...
...
3)条件表达式不满足,循环结束!
for循环和while循环都可以使用死循环来解决一些问题，for循环更适合使用在已经知道循环次数的情况下，而while循环更适合在循环次数未知的情况下进行使用。
do...while循环
初始化语句;
do{
循环体语句;
控制体语句;
}while(条件表达式) ;
do...while循环会至少执行以此循环体与控制体语句。
for循环嵌套：
for(初始化语句;条件表达式;控制体语句){
此时的循环体---就是内层for循环
for(初始化语句2;条件表达式2;控制体语句2){
内层循环的循环体...
}
}
跳转控制语句:
break：可以在循环和switch语句中进行使用，代表结束的意思。也可以在for循环嵌套中进行使用。可以给外层循环和内层循环进行标记，然后使用break 来结束。
wc: for(初始化语句;条件表达式;控制体语句){
此时的循环体---就是内层for循环
nc:for(初始化语句2;条件表达式2;控制体语句2){
内层循环的循环体...
break nc;//结束内层循环
break wc;//结束外层循环
}
}
跳转控制语句
break:
结束当前循环，或者在switch语句中结束使用结束switch。
continue：
代表跳出当次循环，执行下一次循环。
return ：
返回，可以单独进行使用，但是不建议，一般使用场景是在方法中，用来结束方法，并且返回一个值。
方法：
方法概念：
方法就是一个代码块{},给{}起一个名字(方法名),然后在方法中写入实现某种功能的逻辑代码。以后见到同样一个功能代码块,直接调用方法名即可。
静态方法：
静态方法是使用static关键字修饰的方法。是属于本类的方法。
有返回值类型的格式：
public static 返回值类型 方法名(形式参数类型1 参数名1,参数类型2 参数名2...){
方法逻辑体...
return 结果;
}
在Java中有返回值类型的方法的定义以及调用格式中注意事项:
1.方法和方法平级关系,不能在一个方法中去定义另一个方法!
2.定义方法的返回值类型和main方法中调用方法的时候,接收结果类型不匹配!
3.Java是强类型语言,在定义的方法时候,形式参数名前面必须有参数类型
4.必须有return语句。
5.定义方法的时候,有{号地方不能有分号;有分号;,不能有{左大括号
无返回值类型的格式：
public static void 方法名(参数类型1 参数名1,参数类型2 参数名2...){
//完成方法体逻辑
//输出内容....
}
有返回值类型无参数的格式
public static 返回值类型 方法名(){
方法逻辑体...
return 结果;
}
无返回值类型无参数的格式
public static void 方法名(){
//完成方法体逻辑
//输出内容....
}
非静态方法：
非静态方法不使用static进行修饰，这种方法属于对象。
须通过new关键字创建对象后，再通过对象调用。
无参无返回值
public void methodName(){
}
无参有返回值
public int methodName(){
return 1；
}
有参无返回值
public void methodName(String name){
}
有参有返回值
public int methodName(String name){
return 1；
}
构造方法：
构造方法需要与类名一致，并且没有返回值类型（包括void）。
构造方法的目的是为了给成员变量赋值。
注意事项：
一个类中,如果没有任何构造方法,那么系统(jvm)自动会给我们提供无参构造方法!
一个类中,只提供有参构造方法,那么系统不会无参构造方法,此时,需要给出无参构造方法!
public class Phone {
private String brand;
private double price;
private String color;
private String memory;
无参构造方法：
public Phone(){
}
有参构造方法：
public Phone(String brand, double price, String color, String memory) {
this.brand = brand;
this.price = price;
this.color = color;
this.memory = memory;
}
}
方法重载：
为了提高方法的复用率，Java提供了重载。
重载的方法名是相同的，参数列表不同，与返回值无关。
参数列表不同包括参数个数不同，参数类型不同，参数类型顺序。
JVM
JVM内存结构分配：
jvm内存结构(栈,堆,方法区,本地方法区,pc寄存器(程序计数器)
栈内存
存储局部变量(在方法定义中或者方法声明上的变量)--->方法进栈,开始加载局部变量
局部变量的生命周期:随着方法调用而存在,随着方法调用结束而消失!
堆内存
new出来的东西都在堆中(对象(实例)),当这个对象创建完毕,并且使用完毕,不会立即被释放,等待GC垃圾回收器
空闲的时候回收 (jvm开启一个垃圾回收线程!)
方法区
字节码文件区域
static静态区域
常量池(constant pool)
本地方法区
和系统相关---->驱动技术
JNI:Java Native Interface:java本地接口
Java语言调用C语言
pc寄存器(程序计数器)
和cpu相关。
方法的形式参数基本数据类型和引用数据类型的区别：
基本数据类型:不需要被jvm加载(校验语法格式-->编译时期)
引用数据类型:类,数组,接口----->
class Student{} ---->被jvm加载 (需要编译---运行时期)
如果是基本数据类型,形式参数的改变不会影响实际参数----特殊的引用类型String和这个效果一致!
如果是引用数据类型(除过String),形式参数的改变直接影响实际参数(实际参数需要传递空间地址值)
数组
数组概念：
数组是储存同一种数据类型的容器。
定义格式：
1.数据类型[] 数组名称;
2.数据类型 数组名称[] ;
初始化：
动态初始化：
1.数据类型[] 数组名称 = new 数据类型[数组长度] ;
2.数据类型 数组名称[] = new 数据类型[数组长度] ;
静态初始化：
1.数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
2.数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....} ;
可以简写为：
1.数据类型[] 数组名称 ={元素1,元素2,元素3....} ;
2.数据类型 数组名称[] = {元素1,元素2,元素3....} ;
数组是存储在堆内存中的
数组的最值：
采用假设思想，将数组的第一个值做为最大/最小值，将第一个值赋值给一个中间变量temp,用这个值依次与数组后面的值进行比较，如果后面有数值比第一个数字大/小，则将这个数字赋值给这个temp变量，遍历完整个数组就会出现最大/最小值
public class Demo {
public static void main(String[] args) {
int arr[] = {7, 3, 9, 2, 1，5};
int temp = arr[0];
for (int i = 0; i < arr.length; i++) {
if (temp > arr[i]) {
temp = arr[i];
}
}
System.out.println("最小值是" + temp);
}
}
数组的遍历：
public class Demo {
public static void main(String[] args) {
int arr[] = {7, 3, 9, 2, 1,5};
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+",");
}
}
}
冒泡算法：
冒泡算法就是将数字当前的数字与后面的数字进行比对，比对一轮之后，最大/小的数字会被排到最后面
public class Demo {
public static void main(String[] args) {
int arr[] = {7, 3, 9, 2, 1,5};
for (int i = 0; i < arr.length-1; i++) {
for(int o =0;o<arr.length-i-1;o++){
if(arr[o]>arr[o+1]){
int temp = arr[o];
arr[o] = arr[o+1];
arr[o+1] = temp;
}
}
}
for(int i =0;i<arr.length;i++){
System.out.print(+arr[i]+",");
}
}
}
面向对象
面向对象的思想特点：
1.让复杂的事物简单化
2.更符合日常的思想行为习惯
3.从执行者变为命令者
面向对象的特征：
封装
继承
多态
类：
类是描述现实世界事物的一组属性和行为的集合
封装：
封装概念：
为了保证类内部数据的安全，会将类里面的属性私有化（private权限修饰），对外提供公共的getxx(xxx);和setxx(xxx)方法，来对成员变量进行操作。
private关键字的特点:
1.被private修饰的成员变量/成员方法(非静态),只能在本类中访问,外界类不能访问!
2.虽然被私有修饰的成员变量以及成员方法(非静态)不能直接访问,但是都可以间接的通过"public"公共访问访问。
this关键字：
this关键字代表当前类的对象的地址值引用。告诉成员变量
this.成员变量名 = 局部变量名;
局部变量和成员变量的区别:
区别:
1.类中的书写位置不同
成员变量:在类中,方法外。
局部变量:在方法定义中或者方法声明上。
2.jvm内存位置不同
成员变量:在堆内存中。
局部变量:在栈内存中。
3.生命周期不同:
成员变量:随着对象的创建而存在,随着对象的创建完毕并且使用完之后，等待垃圾回收器回收(不会立即回收)。
局部变量:随着方法调用而存在,随着方法调用结束而消失。
4.初始化值不同:
成员变量:系统会默认初始化,也可以显示初始化。
局部变量:在使用局部变量之前,必须对成员变量进行赋值。
构造方法：
构造方法需要与类名一致，并且没有返回值类型（包括void）。
构造方法的目的是为了给成员变量赋值。
注意事项：
1.一个类中,如果没有任何构造方法,那么系统(jvm)自动会给我们提供无参构造方法!
2.一个类中,只提供有参构造方法,那么系统不会无参构造方法,此时,需要给出无参构造方法!
一个标准类的写法：
成员属性属性私有.
提供公共的setxx(xxx)和getxx(xxx)方法对成员变量进行访问。
3.构造方法：无参构造方法永远给出，有参构造方法视情况而定。
419
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
