流程控制
分支流程
if-else if-else语句
-
语法结构
if(布尔表达式){ }else if(布尔表达式){ }else{ } -
执行原理：先判断if后面的布尔表达式，若为true则执行，否则继续判断其他分支
-
有一个分支执行了其他分支就不会再判断了
-
练习
public static void main(String[] args) { //如果分数>=90 输出优, 分数>=80&&<=90 输出良，>=70&&<=80 输出中， //大于60小于70及格，小于60，不及格 int score = 86; if(score >= 90) { System.out.println("你的成绩属于优"); }else if(score >=80){ System.out.println("你的成绩属于良"); }else if(score >=70){ System.out.println("你的成绩属于中"); }else if(score >=60){ System.out.println("你的成绩属于及格"); }else { System.out.println("你的成绩属于不及格"); } }
switch语句
-
语法结构
switch(int或String类型的字面量或变量){ case int或String类型的字面量或变量: java语句; break; case int或String类型的字面量或变量: java语句; break; ... default: java语句; } -
执行原理：
- switch后面小括号当中的数据和case后面的数据进行匹配，匹配成功的分支执行，按照自上而下的顺序匹配
- 执行时候遇到break语句的话，整个switch语句终止
- 执行时没有break语句的话，直接进入下一个分支执行，不需要匹配。这种现象称为：case穿透
- 所有分支都没有匹配成功就执行default分支
-
case可以合并
case 1: case 2: case 3: System.out.println("Test code!");
循环流程
for循环
-
语法结构
for(初始化表达式;判断条件;变更条件){ 循环体; } -
执行原理：
- 初始化表达式最先执行，并且在整个循环过程中只执行一次
- 判断布尔表达式的结果，结果若为true就执行循环体
- 循环体执行结束执行更新表达式，再判断布尔表达式的结果
-
在初始化表达式位置定义的变量是仅供for循环使用的变量
-
练习：
public static void main(String[] args) { //循环控制：for //从1到100，求其中的奇数和 int result = 0; for(int i = 0; i < 100; i++) { if((i & 1) == 1) { result += i; } } System.out.println(result); }
while循环
-
语法结构：
while(布尔表达式){ 循环体; } -
执行原理：
- 先判断布尔表达式的结果，结果为true就执行循环体，否则不执行
- 循环体执行完毕继续判断布尔表达式，结果为true就执行循环体，否则不执行
-
while循环的循环次数：0~N次
-
练习
public static void main(String[] args) { //鸡兔同笼 int head = 5; int foot = 18; int rabbit = 0; int r = 0; while(rabbit <= head) { if(rabbit * 4 + (head - rabbit) * 2 == foot) { r = rabbit; } rabbit++; } System.out.println(r); }
break
-
使用在switch语句中，终止switch语句的执行
-
使用在循环体中，终止循环的执行
-
默认情况下，break终止的是自己所在的循环，若需要终止上层循环则需要起别名
for1:for (int i = 0;i < 3;i++){ for2:for (int j = 0;j <3;j++){ if (j == 2){ break for1; } } }
coutinue
- 作用：跳过本次循环，继续执行下一次循环
- 也可以采用别名
数组
数组：—>数据容器
数组创建的格式：C语言：类型 标识符[]
JAVA认为，类型就是类型，数组也是一种类型
数组是一个容器，那么就要遵循容器的特征，容器具有的三个大特征：定位，求长，替换
public static void main(String[] args) {
int[] arr = new int[5];
arr[0] = 1;
arr[1] = 5;
arr[2] = 6;
arr[3] = 8;
arr[4] = 99;
//求长：获取这个容器的长度
System.out.println(arr.length);
//定位:知道角标，找到角标中的内容
System.out.println(arr[4]);
//知道值，求出这个值在容器的中的角标
int j = 1;
for(int i = 0; i < arr.length; i++) {
if(arr[i] == j) {
System.out.println(i);
}
}
//替换：将对应角标中的内容，换成另一个内容
//如果我要将数组里面的某一个角标的值换成数组中另一个
int temp = arr[1];
arr[1] = arr[4];
arr[4] = temp;
System.out.println("输出"+arr[1]);
System.out.println("输出"+arr[4]);
//数组，存放相同类型的元素的，内存连续的，大小不可改变的数据的容器叫做数组。
}
动态初始化和静态初始化
动态初始化，就是先把空间申请下来，然后一个一个赋值
静态初始化，是申请空间的同时把内容直接设置进去
排序
public static void main(String[] args) {
int[] arr = { 44, 6, 3, 12, 34, 66 };
// 排序
// 直接排序
for(int i = 0; i < arr.length; i++) {
for(int j = i+1; j < arr.length; j++) {
if(arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
System.out.print(arr[i] + " ");
}
//选择排序
for (int i = 0; i < arr.length; i++) {
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[minIndex] > arr[j]) {
minIndex = j;
}
}
// 当前minIndex值最小
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
System.out.print(arr[i] + " ");
}
//冒泡排序
for(int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr.length - 1 - i; j++) {
if(arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out.print(arr[i] + " ");
}
}
多维数组
public static void main(String[] args) {
//n维数组是以n-1维数组为元素的1维数组
int[][] arr = {
{1,2,3,4},
{5,6,7,2},
{10,5,2,6}
};
//二维数组中的定位，求长，替换
//求长 简单分为求行和列
System.out.println("数组共有"+arr.length+"行");
System.out.println("数组角标为2的行共有"+arr[2].length+"列");
//定位：现在需要2个值来定位
//遍历：n维数组需要n个for循环
for(int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println(" ");
}
//二维数组的行和
int[] ar = new int[arr.length];
int sum = 0;
for(int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr[i].length; j++) {
sum += arr[i][j];
}
ar[i] =sum;
System.out.println(ar[i]);
}
//二维数组的列和
int[] a = new int[arr[0].length];
int s = 0;
for(int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr[i].length; j++) {
a[j] = a[j] + arr[i][j];
}
}
for(int i = 0; i < arr.length; i++) {
System.out.print(a[i] + " ");
}
}
九九乘法表
public static void main(String[] args) {
/* ******
*****
****
***
**
* */
int n = 6;
for(int i = 1; i < n; i++) {
for(int j = 1; j < n - i; j++) {
System.out.print("*");
}
for(int j = 1; j < n; j++) {
System.out.print(" ");
}
System.out.println();
}
//九九乘法表
for(int i = 1; i <= 9; i++) {
for(int j = 1; j <= i; j++) {
System.out.print(j+"×"+i+"="+i*j+"\t");
}
System.out.println();
}
}
变量
成员变量
成员变量可以分为：
实例属性 （不用static修饰） 随着实例属性的存在而存在
类属性 （static修饰） 随着类的存在而存在
局部变量
局部变量可分为：
形参（形式参数）在整个方法内有效
方法局部变量 （方法内定义）从定义这个变量开始到方法结束这一段时间内有效
代码块局部变量 （代码块内定义）从定义这个变量开始到代码块结束这一段时间内有效
java中 方法method c中 函数function
返回值类型 标识符（参数列表）{代码块}
方法
- 方法执行过程中的内存空间在栈中分配
- 局部变量的内存空间在栈中分配
- 方法的返回值类型如果是void，则不能出现return 值这样的语句，但是可以出现return;用来结束方法
方法重载
- 方法重载与方法名和形式参数列表有关，与访问修饰权限和返回值类型无关
- 方法重载的条件：
- 在同一个类中
- 方法名相同
- 形式参数列表不同，符合以下条件之一即为不同
- 数量不同
- 顺序不同
- 类型不同
构造方法
-
构造方法又被称为构造器、构造函数、Constructor
-
构造方法语法结构：
[修饰符列表] 构造方法名(形式参数列表){ 构造方法体; } -
构造方法的返回值类型不需要指定，并且也不能写void
-
构造方法的方法名必须和当前类的类名保持一致
-
构造方法的作用：
- 创建对象
- 创建对象的同时初始化实例变量的内存空间。构造方法调用时，实例变量被初始化，赋默认值。构造方法没有手动赋值的时候系统赋默认值
-
拓展：成员变量之实例变量，属于对象级别的变量，这种变量必须先有对象才能有实例变量。实例变量没有手动赋值的时候系统赋默认值。系统赋默认值不是在类加载的时候完成的，而是在构造方法执行过程中完成的。因为类加载的时候不存在对象，只是加载了代码片段。无参构造方法里面什么都没有写的情况下其实是有一段给实例变量赋系统默认值的语句
-
构造方法的调用方式：new 构造方法名(实际参数列表)
-
构造方法调用执行之后，返回值是一个对象的内存地址，不需要写return语句
-
当一个类中没有定义任何构造方法的时候，系统默认给该类提供一个无参构造方法，这个构造方法被称为缺省构造器。
-
调用构造方法并且执行完毕后，对象已经创建，如果需要得到对象的内存地址，就需要给前面加上“数据类型 + 变量名”来接收这个内存地址的返回值。只要构造器被调用就会创建对象，并且一定是在堆内存当中开辟内存空间
-
当一个类显示地将构造方法定义出来了，那么系统这不再默认为这个类提供缺省构造器。
-
构造方法支持重载机制
316
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
