2.1 java基础 day02 流程控制创建类和对象栈堆元空间

news2024/10/5 13:53:57

1流程控制

流程控制：

1.1.计算机在执行代码时对指令代码执行顺序的控制

1.2.Java 流程控制主要分三种：

顺序执行
分支执行
重复执行
1.3.顺序执行

按代码和语法出现的先后顺序执行
1.4.分支执行

根据判断条件执行分支逻辑
可选分支、必选分支（多选一）、多分支、特殊分支（switch）
1.5.重复执行

根据条件循环执行
while、do … while、for
break 和 continue

分支执行：

可选分支（单分支，if true or false）
必选分支（双分支，if / else）
多分支（多重判断，if / else if / {else}）
特殊分支（等值判断，switch case
switch：
会对数据进行判断，如果等于某一个分支数据的值，会执行该分支的逻辑代码，并顺序执行后面的分支
如果一个分支都无法匹配，那么一个分支都不会执行，此时如果还想执行分支，可以增加 default 关键字（必选）
如果执行某个分支后，不想再执行其他分支，可以使用 break 关键字跳出当前分支
小练习：根据年龄判断成长阶段

package chapter02;

public class java04_nianlingtezheng {
    public static void main(String[] args) {
        int age=10;
        if(age<7){
            System.out.println("儿童");
        }else if (age<18){
            System.out.println("少年");
        }else if(age<40){
            System.out.println("成年");
        }else if(age<60){
            System.out.println("中年");
        }else {
            System.out.println("老年");
        }
    }
        }

重复执行：

**while：**有条件循环
while (条件表达式) {}

先判断条件，{} 执行完毕后，重新判断条件

小心死循环

2.do {} while：

先执行 do{}，再判断条件

至少执行一次

3.for ( a; b; c) ：

初始化表达式（用于条件表达式中的变量初始化）

条件表达式（决定是否执行循环）

更新表达式（控制循环次数）

break 跳出当前层循环，不再执行后续操作

continue 跳过当前层的这次循环，继续执行下次循环

6.小练习：九层妖塔

结合使用 print 和 println
嵌套循环找规律

package chapter02;

public class java05_chongfuzhixing {
    public static void main(String[] args) {
        int level=6;
        for(int j=0;j<level;j++){
//           打印前面的空格
            for(int i=0;i<level-j;i++){
                System.out.print(" ");
            }
//            打印星号
            for(int i=0;i<j*2+1;i++){
                System.out.print("*");
            };
//          换行
            System.out.println(" ");

        }

    }
}

面向对象

1.面向过程：把大象装进冰箱里分三步

2.思考方式：如果需要解决很多类似问题，每次梳理步骤过程就会比较麻烦，但如果直接去分析问题涉及的具体事物（Object，对象），会更符合日常生活的思考方式，这就叫“面向对象编程”

3.面向对象：是一种编程思想，一种分析事物和解决问题的方式，我们通过编程语言的语法来体现这种思想

基本语法：

1.类和对象：

类表示归纳和整理
对象表示具体事物
2.类的语法基本语法结构：

class 类名 {
特征（属性），
功能（方法）
}

创建对象的语法：
new 类名();

3.步骤：

TODO 1. 先声明类

TODO 2. 创建对象

TODO 3. 声明属性，所谓的属性其实就是类中的变量
变量类型变量名称 = 变量值
属性类型属性名称 = 属性值

TODO 4. 声明方法
void 方法名（参数）{ 功能代码 }

TODO 5. 执行方法
对象.属性
对象.方法名（）

public class Java01_Object {
    public static void main(String[] args) {

        // TODO 面向对象
        //所谓的面向对象，其实就是分析问题时，以问题所涉及到的事或物为中心的分析方式
        // 类和对象
        // 类表示归纳和整理
        // 对象就表示具体的事物
        // TODO class（类）
        /*
          类的语法基本语法结构：

          class 类名 {
             特征（属性），
             功能（方法）
          }

          创建对象的语法：
          new 类名();
         */

        // 问题：做一道菜，红烧排骨
        // 类：菜， 对象：红烧排骨

        // TODO 1. 先声明类
        // TODO 2. 创建对象
        // TODO 3. 声明属性，所谓的属性其实就是类中的变量
        //         变量类型  变量名称  = 变量值
        //         属性类型  属性名称  = 属性值
        // TODO 4. 声明方法
        //         void 方法名（参数）{ 功能代码 }
        // TODO 5. 执行方法
        //         对象.属性
        //         对象.方法名（）

        // 引用数据类型
        Cooking c = new Cooking();
        c.name = "红烧排骨";
        c.food = "排骨";
        c.execute();

        Cooking c1 = new Cooking();
        c1.name = "红烧鱼";
        c1.food = "鲫鱼";
        c1.execute();

    }
}
class Cooking {

    // 特征（属性）
    // 名字
    String name;
    // 菜的类型
    String type = "红烧";
    // 食材
    String food;
    // 佐料
    String relish = "大料";

    // TODO 执行
    void execute() {
        System.out.println("准备食材:" + food);
        System.out.println("准备佐料:" + relish);
        System.out.println("开始烹饪");
        System.out.println(name + "烹饪完成");
    }
}

注意：

在对同一个对象的不同属性进行操作的时候，需要用变量来引用这个对象
Cooking c = new Cooking()
创建对象，用对象类型的变量来引用它，当处理变量时，处理的其实是引用的对象
基本数据类型不是对象，因此不是引用数据类型

用“+”拼接字符串
如果需要新菜，用new再次创建即可

类：

结构体，里面包含了属性（特征）和方法（行为）会有很多的对象。
class : 关键字（全是小写）
类名：类的名称，标识符。遵循规则。一般情况下，类名的首写字母是大写。

对象：

类的实例化（具象化）

new 类名（），下括号需要增加。

new也是关键字，表示创建一个具体的对象，而且，使用一次，创建一次，每次都是全新的。

一般new出来的对象会赋值给变量，方便重复使用

变量的类型就是对象的类型。

对象是将内存地址赋值给了变量，所以变量其实引用了内存中的对象，所以称之为引用变量，

而变量的类型称之为引用数据类型。

特殊的对象：空对象(null)，没有引用的对象，称之为空对象, 关键字对象。

所有引用类型变量的默认取值就是null

public class java06_lei {
    public static void main(String[] args) {
        Dog d1=new Dog();
        d1.name="小白";

        d1.run();

        Dog d2=new Dog();
        d2.name="小黑";
        d2.run();
    }
}
class Dog{
    String name;
    void run(){
        System.out.println(name+"跑开了");
    }
}

**内存分为三个部分：**栈、堆、元空间

栈存储方法、变量 User user

堆存储对象 new User()

元空间 存储类的信息