一、流程控制语句switch格式以及注意事项
switch语句的格式：
switch(表达式或者变量值){
case 值1：
语句1；
break；
case 值2：
语句2；
break；
......
case 值n：
语句n；
break；
default:
语句n；
break;
}注意事项：
（1）switch中的case语句后面只能跟常量，不能是变量。
（2）case语句具有“穿透性”，即如果不在其后加break则会跳过下一个case语句直接进入下一个语句中。
（3）switch...case语句结束的条件有两个
1、当代码中遇到break时，会结束代码。
2、当语句走到结尾时，会结束代码。
（4）default可以出现在代码语句中的任何位置，不影响语句的流程，default即当不满足case语句时，就会跳到该代码上。
二、循环结构语句
1、for循环（使用最多）
格式：
for(初始化语句;条件表达式;控制体语句){
循环体语句;
}执行流程：
1）初始化语句，
2）进入判断，如果满足进入循环体语句，
3）循环体语句完成后进行一次控制体语句，
4）然后继续进行判断，
5）直到不满足条件语句时，循环结束，跳出循环。
例：//输出0到9，每次换行输出
for(int i = 0 ;i<10;i++){
System.out.println(i);
}
2、while循环（其次）
格式：
初始化语句；
while(条件表达式){
循环体语句；
控制体语句；
}流程：
1）先进性初始化
2）进行条件判断，满足条件，则进入循环体语句
3）循环体进行完后必须有控制体语句（否则会进入死循环）
4）一直循环，直到不满足while条件，则结束循环。
例：//输出0到9，每次换行输出。
int i = 0;
while(i<10){
System.out.println(i);
i++;
}do...while循环
格式：
do{
循环体语句；
控制体语句；
}while(条件表达式)
该代码有一个问题就是，就算条件不符合，也会进行输出一次（循环一次）
三、水仙花
要求：即一个三位数，其个位值的立方加上其十位数上的立方加上百位数上的立方，等于该数
public class Demo1 {
public static void main(String[] args) {
for (int i =100;i<1000;i++){
int a = i%10; //个位数上的值
int b = i/10%10; //十位数上的值
int c = i/10/10%10; //百位数上的值
int time=0;
if (i==a*a*a+b*b*b+c*c*c){ //判断是否符合要求
time++;
System.out.println("第"+time+"个水仙花值为："+i);
}
}
}
}四、死循环for和while
第一个格式：
for(;;){
循环体语句；
}第二个格式：
while(true){ //使用较多
循环体语句；
}五、跳转控制语句
break:中断结束循环或者switch
continue:只结束当前循环，并进入下一次循环
return:结束方法，当方法有具体返回值时使用
注意事项：
1）break不能单独使用，需要搭配循环或者switch
2）return:很少单独使用，大多数情况都用于结束方法
六、方法
调用方法的三个方法：
1）单独调用：不适用于具有返回值的方法2）输出调用：可以输出就直接输出
3）赋值调用：适用于具有返回值的方法，需要定义一个和返回值类型相同的变量进行接收返回值，并可以在主函数中随意调用
1、带返回值的方法
格式：
public static 返回值类型 方法名（形式参数1，形式参数2...形式参数n）{
return;
}适用于：赋值调用
定义一个方法：两个明确
1）明确返回值类型
2）明确参数类型以及参数个数
举例
class Dmeo{
public static void main(String[] args){
int a = 10;
int b = 15;
int sum = sum(a,b); //调用方法，并赋值给int类型的sum
System.out.println("sum:"+sum);//输出sum
}
public static int sum(int i, int j){//创建了一个两个int类型变量相加的方法
return i+j;
}
}2、无返回值的方法
格式：
public static void 方法名（形式参数1，形式参数2...形式参数n）{
方法表达式;
}适用于：单独调用
举例
class Dmeo{
public static void main(String[] args){
int a = 10;
int b = 15;
sum(a,b); //直接调用
}
public static void sum(int i, int j){//创建了一个两个int类型变量相加的方法
System.out.println("sum"+(a+b));
}
}七、方法重载
相对理论一些的知识，其含义是方法名相同，其中的形式参数类型，数量不同这就是方法重载（overload），在调用的时候需要注意参数类型，就可以在同一个方法名下进行多组不同的操作了
例：
class Dmeo{
public static void main(String[] args){
int a = 10;
int b = 15;
int c = 20;
duoble d = 12.34;
sum(a,b); //a+b
sum(a,b,c); //a+b+c
sum(c,d); //c+d
sum(d,c); //d+c
}
public static int sum(int i, int j){//创建了一个两个int类型变量相加的方法
return i+j;
}
public static int sum(int i, int j,int n){//创建了一个两个int类型变量相加的方法
return i+j+m;
}
public static int sum(int i, duoble j){//创建了一个两个int类型变量相加的方法
return i+j;
}
public static int sum(duoble i, int j){//创建了一个两个int类型变量相加的方法
return i+j;
}
}八、数组
定义：用于存储同一类数据的容器
格式：
定义格式:
int[] arr;定义了一个数组,整数类型的数组,名字叫arr,
int arr[];定义了一个数组,整数类型的名字叫arr的数组,
初始化格式:
动态格式:数据类型[] 数组名称 = new 数据类型[数组内元素的数量];
静态格式:数据类型[] 数组名称 = new 数据类型[元素1,元素2...元素n];
静态格式（简写）：数据类型[] 数组名称 =[元素1,元素2...元素n];图解其内存空间的使用
1）先加载类，在main方法进栈
2）main方法在栈内找空间存放定义类（int[] arr1）
3）new出来的对象需要进堆，在堆内申请空间，产生一个空间地址0x0011
4）然后就可以通过堆内存地址，堆数组进行初始化
赋值前的值，String类型为null，int类型为0
九、冒泡排序
如上图，下面进行代码展示：
public class BubbleSortDemo {
public static void main(String[] args) {
int[] arr= {23,1,124,412,464,223,4312,413,567,899};
printAA(arr);
bubble(arr);
printAA(arr);
}
private static void bubble(int[] arr){//用于进行冒泡排序的方法
for (int i = 0; i < arr.length-1; 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;
}
}
}
}
public static void printAA(int[] arr){//用于遍历输出的方法
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length-1){
System.out.println(arr[i]+"]");
}else {
System.out.print(arr[i]+", ");
}
}
}
}十、面向对象（上）
1、面向对象的思想特点以及特征
1.思想特点：
1）更加符合生活中的思想行为习惯
2）将复杂的事情简单化
3）由执行者变成指挥者
2.面向对象的三大特征：封装，继承，多态
2、 类
什么是类：类，是能描述现实世界事物一组属性和行为的集合
类和事务的关系：一一对应的关系
测试：
创建一个Phone类
public class Phone {
String brand;
String color;
int price;
String memory;
public void callPhone(String bear){
System.out.println("打电话给"+bear);
}
public void photograph(String someone){
System.out.println("拍照给"+someone);
}
public void chat(){
System.out.println("可以用来聊天");
}
}对Phone类进行测试
/**手机事物
*属性：品牌，颜色，价格，内存
*行为：打电话，拍照，聊天
*/
public class PhoneTest {
public static void main(String[] args) {
Phone p =new Phone(); //new一个新的对象p用来接收Phone类中的数据
p.brand="iphone13 pro max"; //对Phone类中的基础属性进行赋值
p.color="远峰蓝";
p.price=10999;
p.memory="1TB";
System.out.println("手机品牌:"+ p.brand+",手机颜色:"+ p.color+
",手机价格:"+ p.price+",手机内存:"+ p.memory);
p.callPhone("胡歌"); //调用方法
p.photograph("彭于晏");
p.chat();
}
}3、封装
由于我们在类的测试中发现了一个问题，就是，不论你输入的值，是否正确，他都会输出那个值，为了放着这种情况的发生，我们引进了private，私有创建，即，使用了private我们只能在该类内进行调用，所以我们又引进了set和get方法
测试如下：
Phone的封装类
public class Phone {
private String brand;
private String name;
private int price;
private String memory;
public void setBrand(String b){
brand = b;
}
public void setName(String n){
name = n;
}
public void setPrice(int p){
price = p;
}
public void setMemory(String m){
memory = m;
}
public String getBrand(){
return brand;
}
public String getName(){
return name;
}
public int getPrice(){
return price;
}
public String getMemory(){
return memory;
}
public void callPhone(String someone){
System.out.println("可以打电话"+someone);
}
public void photograph(String someone){
System.out.println("可以给"+someone+"拍照");
}
public void chat(){
System.out.println("用来聊天");
}
}测试新的封装类
public class PhoneTest {
public static void main(String[] args) {
Phone p = new Phone(); //创建一个新的对象用来调用Phone中的属性
p.setBrand("华为");
p.setName("mate40pro +");
p.setPrice(8499);
p.setMemory("12+512G");
System.out.println("手机品牌:"+ p.getBrand()+",手机型号:"+ p.getName()+
",手机价格:"+ p.getPrice()+",手机内存:"+ p.getMemory());
p.callPhone("胡歌");
p.photograph("高圆圆");
p.chat();
}以上就是本周的总结，感谢观看
扫一扫
3597
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
