【JavaSE】- 面向对象编程(基础部分)

难吃的茄子

已于 2023-07-10 15:21:47 修改

阅读量65

点赞数

文章标签：开发语言 java

于 2023-06-29 21:41:43 首次发布

本文链接：https://blog.csdn.net/m0_62605243/article/details/131365964

版权

面向对象编程_基础部分

1.1🌠面向对象引出

张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。还有一只叫小花,今年 100 岁,花色。请编写一个程序，当用户
输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示张老太没有这只猫猫。

单独的定义变量解决
使用数组解决
现有技术解决的缺点分析
不利于数据的管理
效率低===> 引出我们的新知识点类与对象
java 设计者引入类与对象(OOP) ，根本原因就是现有的技术，不能完美的解决新的新的需求

code

public class Object01 {
    //编写一个 main 方法
    public static void main(String[] args) {

//单独变量来解决 => 不利于数据的管理(你把一只猫的信息拆解)
//第 1 只猫信息
// String cat1Name = "小白";
// int cat1Age = 3;
// String cat1Color = "白色";
// //第 2 只猫信息
// String cat2Name = "小花";
// int cat2Age = 100;
// String cat2Color = "花色";
//数组 ===>(1)数据类型体现不出来(2) 只能通过[下标]获取信息，造成变量名字和内容
// 的对应关系不明确(3) 不能体现猫的行为
//第 1 只猫信息
// String[] cat1 = {"小白", "3", "白色"};
// String[] cat2 = {"小花", "100", "花色"};
        
//使用 OOP 面向对象解决
//实例化一只猫[创建一只猫对象]

//1. new Cat() 创建一只猫(猫对象)
//2. Cat cat1 = new Cat(); 把创建的猫赋给 cat1

//3. cat1 就是一个对象
        Cat cat1 = new Cat();
        cat1.name = "小白";
        cat1.age = 3;
        cat1.color = "白色";
        cat1.weight = 10;
//创建了第二只猫，并赋给 cat2
//cat2 也是一个对象(猫对象)
        Cat cat2 = new Cat();
        cat2.name = "小花";
        cat2.age = 100;
        cat2.color = "花色";
        cat2.weight = 20;
//怎么访问对象的属性呢
        System.out.println("第 1 只猫信息" + cat1.name
                + " " + cat1.age + " " + cat1.color + " " + cat1.weight);
        System.out.println("第 2 只猫信息" + cat2.name
                + " " + cat2.age + " " + cat2.color + " " + cat2.weight);
    }
}
    //使用面向对象的方式来解决养猫问题
//

//定义一个猫类 Cat -> 自定义的数据类型
class Cat {
    //属性/成员变量
    String name; //名字
    int age; //年龄
    String color; //颜色
    double weight; //体重
    //行为
}

run
在这里插入图片描述

1.2🍏类和对象的区别和联系

在这里插入图片描述

通过上面的案例和讲解我们可以看出:

类是抽象的，概念的，代表一类事物,比如人类,猫类…, 即它是数据类型.
对象是具体的，实际的，代表一个具体事物, 即是实例.
类是对象的模板，对象是类的一个个体，对应一个实例

内存分析图
在这里插入图片描述

1.3🍋属性/成员变量/字段

从概念或叫法上看：成员变量 = 属性 = field(字段) （即成员变量是用来表示属性的，授课中，统一叫属性)

属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。比如我们前面定义猫类的 int age 就是属性

code

class Car {
    String name;//属性, 成员变量, 字段 field
    double price;
    String color;
    String[] master;//属性可以是基本数据类型，也可以是引用类型(对象，数组)
}

1.4🍥属性注意事项

属性的定义语法同变量，示例：访问修饰符属性类型属性名; 这里老师简单的介绍访问修饰符：控制属性的访问范围有四种访问修饰符
public, proctected, 默认, private

属性的定义类型可以为任意类型，包含基本类型或引用类型

属性如果不赋值，有默认值，规则和数组一致。具体说: int 0，short 0,byte 0, long 0, float 0.0,double 0.0，char \u0000 boolean false，String null

code

public class PropertiesDetail {

    public static void main(String[] args) {
    //创建 Person 对象
    //p1 是对象名(对象引用)
    //new Person() 创建的对象空间(数据) 才是真正的对象
        Person p1 = new Person();
//对象的属性默认值，遵守数组规则:
//int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
        System.out.println("\n 当前这个人的信息");
        System.out.println("age=" + p1.age + " name=" + p1.name + " sal=" + p1.sal + " isPass=" + p1.isPass) ;
    }
}
class Person {  // 大驼峰写法规范
    //四个属性
    int age;
    String name;
    double sal;
    boolean isPass;
}

code
在这里插入图片描述

2.1🍒如何创建对象

先声明再创建
Cat cat ; //声明对象 cat
cat = new Cat(); //创建
直接创建
Cat cat = new Cat();
7.1.12 如何访问属性
基本语法
对象名.属性名;
案例演示赋值和输出
cat.name ;
cat.age;
cat.color;

code

public class Object03 {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.age = 10;
        p1.name = "小明";
        Person p2 = p1; // p2对象指向p1
        p1.age = 80;
        System.out.println(p2.age);  // 80
    }
}

class Person
{
    int age;
    String name;
}

创建对象内存分析图
在这里插入图片描述
Java 内存的结构分析

栈：一般存放基本数据类型(局部变量)
堆：存放对象(Cat cat , 数组等)
方法区：常量池(常量，比如字符串)，类加载信息
示意图 [Cat (name, age, price)]
Java 创建对象的流程简单分析
Person p = new Person();
p.name = “jack”;
p.age = 10

先加载 Person 类信息(属性和方法信息, 只会加载一次)
在堆中分配空间, 进行默认初始化(看规则)
把地址赋给 p , p 就指向对象
进行指定初始化，比如 p.name =”jack” p.age = 10

再看一道题加深理解

在这里插入图片描述

2.2🥑方法的定义

public class Method01 {
    //编写一个 main 方法
    public static void main(String[] args) {
//方法使用
//1. 方法写好后，如果不去调用(使用)，不会输出
//2. 先创建对象 ,然后调用方法即可
        Person p1 = new Person();
        p1.speak(); //调用方法
        p1.cal01(); //调用 cal01 方法
        p1.cal02(5); //调用 cal02 方法，同时给 n = 5
        p1.cal02(10); //调用 cal02 方法，同时给 n = 10
//调用 getSum 方法，同时 num1=10, num2=20
//把 方法 getSum 返回的值，赋给 变量 returnRes
        int returnRes = p1.getSum(10, 20);
        System.out.println("getSum 方法返回的值=" + returnRes);
    }
}
class Person {
    String name;
    int age;
    //方法(成员方法)
//添加 speak 成员方法,输出 “我是一个好人”
//1. public 表示方法是公开
//2. void ： 表示方法没有返回值
//3. speak() : speak 是方法名， () 形参列表
//4. {} 方法体，可以写我们要执行的代码
//5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话
    public void speak() {
        System.out.println("我是一个好人");
    }
    //添加 cal01 成员方法,可以计算从 1+..+1000 的结果
    public void cal01() {
//循环完成
        int res = 0;
        for(int i = 1; i <= 1000; i++) {
            res += i;
        }
        System.out.println("cal01 方法 计算结果=" + res);
    }
    //添加 cal02 成员方法,该方法可以接收一个数 n，计算从 1+..+n 的结果

//1. (int n) 形参列表， 表示当前有一个形参 n, 可以接收用户输入
    public void cal02(int n) {
//循环完成
        int res = 0;
        for(int i = 1; i <= n; i++) {
            res += i;
        }
        System.out.println("cal02 方法 计算结果=" + res);
    }
    //添加 getSum 成员方法,可以计算两个数的和
//1. public 表示方法是公开的
//2. int :表示方法执行后，返回一个 int 值
//3. getSum 方法名
//4. (int num1, int num2) 形参列表，2 个形参，可以接收用户传入的两个数
//5. return res; 表示把 res 的值， 返回
    public int getSum(int num1, int num2) {
        int res = num1 + num2;
        return res;
    }
}

方法调用机制分析
在这里插入图片描述

请遍历一个数组 , 输出数组的各个元素值

code

public class Method02 {
    public static void main(String[] args) {
//        请遍历一个数组 , 输出数组的各个元素值
        int[][] map = {{1, 1, 1,}, {2, 2, 2}, {3, 3, 3}};
        MyTools myTools = new MyTools();
        myTools.printArr(map);
        myTools.printArr(map);
        myTools.printArr(map);
    }
}

class MyTools {
    public void printArr(int[][] map) {
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }
}

run
在这里插入图片描述

成员方法的好处

提高代码的复用性
可以将实现的细节封装起来然后供其他用户来调用即可

方法的定义

访问修饰符返回数据类型方法名（形参列表…） {
//方法体语句；
return 返回值;
}

形参列表：表示成员方法输入 cal(int n) ， getSum(int num1, int num2)
返回数据类型：表示成员方法输出, void 表示没有返回值
方法主体：表示为了实现某一功能代码块
return 语句不是必须的。

2.3🚠方法的细节

访问修饰符 (作用是控制方法使用的范围)
如果不写默认访问，[有四种: public, protected, 默认, private], 具体在后面说
返回数据类型

一个方法最多有一个返回值 [思考，如何返回多个结果返回数组 ]
返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的值类型一致或兼容
如果方法是 void，则方法体中可以没有 return 语句，或者只写 return ;
方法名
遵循驼峰命名法，最好见名知义，表达出该功能的意思即可, 比如得到两个数的和 getSum, 开发中按照规范

public class MethodDetail {
    public static void main(String[] args) {
        AA a = new AA();
        int[] res = a.getSumAndSub(1, 4);
        System.out.println("和=" + res[0]);
        System.out.println("差=" + res[1]);
//细节: 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型 的参数
        byte b1 = 1;
        byte b2 = 2;
        a.getSumAndSub(b1, b2);//byte -> int
//a.getSumAndSub(1.1, 1.8);//double ->int(×)
//细节: 实参和形参的类型要一致或兼容、个数、顺序必须一致
//a.getSumAndSub(100);//× 个数不一致
        a.f3("tom", 10); //ok
//a.f3(100, "jack"); // 实际参数和形式参数顺序不对
    }
}
class AA {
    //细节: 方法不能嵌套定义
    public void f4() {
//错误
// public void f5() {
// }
    }
    public void f3(String str, int n) {
    }
    //1. 一个方法最多有一个返回值 [思考，如何返回多个结果 返回数组 ]
    public int[] getSumAndSub(int n1, int n2) {
        int[] resArr = new int[2]; //
        resArr[0] = n1 + n2;
        resArr[1] = n1 - n2;
        return resArr;
    }
    //2. 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
// 具体看 getSumAndSub

//3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值;
// 而且要求返回值类型必须和 return 的值类型一致或兼容
    public double f1() {
        double d1 = 1.1 * 3;
        int n = 100;
        return n; // int ->double
        //return d1; //ok? double -> int
    }
    //如果方法是 void，则方法体中可以没有 return 语句，或者 只写 return ;

    public void f2() {
        System.out.println("hello1");
        System.out.println("hello1");
        System.out.println("hello1");
        int n = 10;
        return ;    // 返回值是void这样写也是可以的 
    }
}

方法可以嵌套调用，不能嵌套定义
在这里插入图片描述

    //细节: 方法不能嵌套定义
    public void f4() {
		//错误
		// public void f5() {
		// }
    }

在这里插入图片描述

code

public class MethodDetail02 {
    public static void main(String[] args) {
        A a = new A();
        //a.sayOk();
        a.m1();
    }
}
class A {
    //同一个类中的方法调用：直接调用即可
    public void print(int n) {
        System.out.println("print()方法被调用 n=" + n);
    }
    public void sayOk() { //sayOk 调用 print(直接调用即可)
        print(10);
        System.out.println("继续执行 sayOK()~~~");
    }
    //跨类中的方法 A 类调用 B 类方法：需要通过对象名调用
    public void m1() {
//创建 B 对象, 然后在调用方法即可
        System.out.println("m1() 方法被调用");
        B b = new B();
        b.hi();
        System.out.println("m1() 继续执行:)");
    }
}
class B {
    public void hi() {
        System.out.println("B 类中的 hi()被执行");
    }
}

编写类 AA ，有一个方法：判断一个数是奇数 odd 还是偶数, 返回 Boolean
根据行、列、字符打印对应行数和列数的字符，比如：行：4，列：4，字符#,则打印相应的效果

code

public class MethodExercise01 {
    public static void main(String[] args) {
//        1) 编写类 AA ，有一个方法：判断一个数是奇数 odd 还是偶数, 返回 boolean
        AA aa = new AA();
        if (aa.m1(11)) {
            System.out.println("偶数");
        } else {
            System.out.println("奇数");
        }

//        2) 根据行、列、字符打印 对应行数和列数的字符，比如：行：4，列：4，字符#,则打印相应的效果

        aa.print(4, 3, "@");
    }
}

class AA {
    public boolean m1(int n) {
        //return n % 2 == 0 ? true : false;   // 偶数返回t 奇数返回f
        return n % 2 == 0;   // 偶数返回t 奇数返回f
    }

    public void print(int row, int col, String style) {
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                System.out.print(style + " ");
            }
            System.out.println();
        }
    }

}

run
在这里插入图片描述

2.4🥮方法的传参

基本数据类型
形参的结果不影响实参

code

public class MethodParameter01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
//创建 AA 对象 名字 obj
        AA obj = new AA();
        obj.swap(a, b); //调用 swap
        System.out.println("main 方法 a=" + a + " b=" + b);//a=10 b=20
    }
}
class AA {
    public void swap(int a,int b){
        System.out.println("\na 和 b 交换前的值\na=" + a + "\tb=" + b);//a=10 b=20
//完成了 a 和 b 的交换
        int tmp = a;
        a = b;
        b = tmp;
        System.out.println("\na 和 b 交换后的值\na=" + a + "\tb=" + b);//a=20 b=10
    }
}

run
在这里插入图片描述

在这里插入图片描述
code

public class MethodParameter02 {
    //编写一个 main 方法
    public static void main(String[] args) {
//测试
        B b = new B();
        int[] arr = {1, 2, 3};
        b.test100(arr);//调用方法
        System.out.println(" main 的 arr 数组 ");
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
//测试
        Person p = new Person();
        p.name = "jack";
        p.age = 10;
        b.test200(p);
//测试题, 如果 test200 执行的是 p = null ,下面的结果是 10
//测试题, 如果 test200 执行的是 p = new Person();..., 下面输出的是 10
        System.out.println("main 的 p.age=" + p.age);//10000
    }
}

class Person {
    String name;
    int age;
}

class B {
    public void test200(Person p) {
        p.age = 10000; //修改对象属性
//思考
//        p = new Person();
//        p.name = "tom";
//        p.age = 99;
//思考
//p = null;
    }

    //B 类中编写一个方法 test100，
//可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化
    public void test100(int[] arr) {
        arr[0] = 200;//修改元素
//遍历数组
        System.out.println(" test100 的 arr 数组 ");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }
}

run
在这里插入图片描述

code

public class MethodParameter02 {
    public static void main(String[] args) {
        B b = new B();
        Person p = new Person();
        p.name = "jack";
        p.age = 10;
        b.test200(p);
        //测试题, 如果 test200 执行的是 p = null ,下面的结果是 10
		        
        System.out.println("main 的 p.age=" + p.age);
    }
}
class Person {
    String name;
    int age;
}

class B {
    public void test200(Person p) {
        p = null;
    }

}

run
在这里插入图片描述

code

public class MethodParameter02 {
    public static void main(String[] args) {
        B b = new B();
        Person p = new Person();
        p.name = "jack";
        p.age = 10;
        b.test200(p);
        
        System.out.println("main 的 p.age=" + p.age);//10
    }
}
class Person {
    String name;
    int age;
}

class B {
    public void test200(Person p) {
        
        		//思考
                p = new Person();
                p.name = "tom";
                p.age = 99;
   
    }

}

run
在这里插入图片描述

new了一个新对象，但是这个对象没有被使用在test200这个栈结束后这个对象会被销毁

在这里插入图片描述

3.1🧀对象的克隆

code

public class MethodExercise02 {
    public static void main(String[] args) {
        Person p = new Person();
        p.name = "milan";
        p.age = 100;
	//创建 tools
        MyTools tools = new MyTools();
        Person p2 = tools.copyPerson(p);
//到此 p 和 p2 是 Person 对象，但是是两个独立的对象，属性相同
        System.out.println("p 的属性 age=" + p.age + " 名字=" + p.name);
        System.out.println("p2 的属性 age=" + p2.age + " 名字=" + p2.name);
//这里老师提示： 可以同 对象比较看看是否为同一个对象
        System.out.println(p == p2);//false
    }
}
class Person {
    String name;
    int age;
}
class MyTools {

    //编写一个方法 copyPerson，可以复制一个 Person 对象，返回复制的对象。克隆对象，
//注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同
//
//编写方法的思路
//1. 方法的返回类型 Person
//2. 方法的名字 copyPerson
//3. 方法的形参 (Person p)
//4. 方法体, 创建一个新对象，并复制属性，返回即可
    public Person copyPerson(Person p) {
//创建一个新的对象
        Person p2 = new Person();
        p2.name = p.name; //把原来对象的名字赋给 p2.name
        p2.age = p.age; //把原来对象的年龄赋给 p2.age
        return p2;
    }
}

run
在这里插入图片描述

3.2🌰递归

package recursion;

public class Recursion01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        T t1 = new T();
        t1.test(4); // 输出什么？ n=2 n=3 n=4
        int res = t1.factorial(5);
        System.out.println("5 的阶乘 res =" + res);
    }
}

class T {
    //分析
    public void test(int n) {
        if (n > 2) {
            test(n - 1);
        }
        System.out.println("n=" + n);
    }

    //factorial 阶乘
    public int factorial(int n) {
        if (n == 1) {
            return 1;
        } else {
            return factorial(n - 1) * n;
        }
    }
}

在这里插入图片描述

递归注意事项

code

package recursion;

public class RecursionExercise01 {
    public static void main(String[] args) {
        // 斐波那契
        // 1 1 2 3 5 8 13
        TT tt = new TT();
        int r = tt.f(5);
        if (r != -1) {
            System.out.println(r);
        }

        /*
        猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！
        以后每天猴子都吃其中的一半，然后再多吃一个。当到第 10 天时，
        想再吃时（即还没吃），发现只有 1 个桃子了。问题：最初共多少个桃子？
        */
        // 第10天 1
        // 第9天  4
        // 第8天  10
        // ...

        int ret = tt.Peach(1);
        if (ret!=-1){
            System.out.println(ret);
        }
    }
}

class TT {
    // 斐波那契
    public int f(int n) {
        if (n >= 1) {
            if (n <= 2) {
                return 1;
            } else {
                return f(n - 1) + f(n - 2);
            }
        } else {
            System.out.println("输出有误，请重新输入");
            return 0;
        }
    }

    // 猴子吃桃
    public int Peach(int day) {
        if (day == 10) {
            return 1;
        } else if (day >= 1 && day <= 9) {
            // 比如第9天，就是((第10天的桃子数)+1)*2 = 4 个桃子
            return (Peach(day + 1) + 1) * 2;
        } else {
            System.out.println("输入有误");
            return -1;
        }

    }
}

run
在这里插入图片描述
迷宫问题

在这里插入图片描述
code

package recursion;

public class MiGong {
    public static void main(String[] args) {
        // 0 1
        // 1 1 1 1 1 1 1
// 0 1  // 1 0 0 0 0 0 1
        // 1 0 0 0 0 0 1
        // 1 1 1 0 0 0 1     -> 共8行 7列
        // 1 0 0 0 0 0 1
        // 1 0 0 0 0 0 1
        // 1 0 0 0 0 0 1
        // 1 1 1 1 1 1 1

        int[][] map = new int[8][7];
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                // 如果是第1行和第8行 , 每一列的第一个和最后一个 ，设置为1
                if (i == 0 || i == map.length - 1 || j == 0 || j == map[i].length - 1) {
                    map[i][j] = 1;
                }
                map[3][1] = 1;
                map[3][2] = 1;
                //map[2][1] = 1;
                //map[2][2] = 1;   // 测试回溯现象
                //map[1][2] = 1;
            }
        }
        MG mg = new MG();
        Boolean b = mg.findWay(map, 1, 1);
        System.out.println(b);
        // 遍历
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }


    }
}

class MG {
    //1. findWay 方法就是专门来找出迷宫的路径
    //2. 如果找到，就返回 true ,否则返回 false
    //3. map 就是二维数组，即表示迷宫
    //4. i,j 就是老鼠的位置，初始化的位置为(1,1)
    //5. 因为我们是递归的找路，所以我先规定 map 数组的各个值的含义
    // 0 表示可以走 1 表示障碍物 2 表示可以走 3 表示走过，但是走不通是死路
    //6. 当 map[6][5] =2 就说明找到通路,就可以结束，否则就继续找.
    //7. 先确定老鼠找路策略 下->右->上->左

    public boolean findWay(int[][] map, int i, int j) {
        // 如果最后一个坐标是2
        if (map[6][5] == 2) {
            return true;
        } else {
            // 当前位置是0，表示可以走
            if (map[i][j] == 0) {
                // 假定可以走通
                map[i][j] = 2;
                    // 往下走
                if (findWay(map, i + 1, j)) {
                    return true;   //
                    // 右
                } else if (findWay(map, i, j + 1)) {
                    return true;
                } else if (findWay(map, i - 1, j)) {
                    // 上
                    return true;
                } else if (findWay(map, i, j- 1)) {
                    // 左
                    return true;
                    // 下右上左都走不通，直接返回false
                } else {
                    map[i][j] = 3; // 说明四个方向都走过了，返回false
                    return false;
                }
            }else {
                return false;
            }
        }
    }


}

run

在这里插入图片描述
汉诺塔问题
code

package recursion;

public class Test {
    public static void main(String[] args) {
        M m = new M();
        m.Tower(3,'A','B','C');

    }
}

class M {
    public void Tower(int n,char p1,char p2,char p3){
        if (n==1){
            System.out.print(p1+"->"+p3+" ");
        }else{
            Tower(n-1,p1,p3,p2);
            System.out.print(p1+"->"+p3+" ");
            Tower(n-1,p2,p1,p3);
        }
    }
}

run
在这里插入图片描述 八皇后

code

run

4.1🧁方法的重载

基本介绍
java 中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！
比如：System.out.println(); out 是 PrintStream 类型

重载的好处

减轻了起名的麻烦
减轻了记名的麻烦

code

package overload;

public class OverLoad01 {
    //编写一个 main 方法
    public static void main(String[] args) {
    // System.out.println(100);
    // System.out.println("hello,world");
    // System.out.println('h');
    // System.out.println(1.1);
    // System.out.println(true);
    //
        MyCalculator mc = new MyCalculator();
        System.out.println(mc.calculate(1, 2));
        System.out.println(mc.calculate(1.1, 2));
        System.out.println(mc.calculate(1, 2.1));
    }
}
class MyCalculator {
    //下面的四个 calculate 方法构成了重载
    //两个整数的和
    public int calculate(int n1, int n2) {
        System.out.println("calculate(int n1, int n2) 被调用");
        return n1 + n2;
    }

    // 这里返回类型不同
    //与上面没有构成方法重载, 仍然是错误的，因为是方法的重复定义

    // public void calculate(int n1, int n2) {
    // System.out.println("calculate(int n1, int n2) 被调用");
    // int res = n1 + n2;
    // }

    // ==================================================================================================================

    // public void calculate(int n1, int n2) {
    // System.out.println("calculate(int n1, int n2) 被调用");
    // }

    // 这里形参名字不一样
    // 看看下面是否构成重载, 没有构成，而是方法的重复定义,就错了
    
    // public int calculate(int a1, int a2) {
    // System.out.println("calculate(int n1, int n2) 被调用");
    // return a1 + a2;
    // }

//一个整数，一个 double 的和
    public double calculate(int n1, double n2) {
        return n1 + n2;
    }
    //一个 double ,一个 Int 和
    public double calculate(double n1, int n2) {
        System.out.println("calculate(double n1, int n2) 被调用..");
        return n1 + n2;
    }
    //三个 int 的和
    public int calculate(int n1, int n2,int n3) {
        return n1 + n2 + n2;
    }
}

注意：

返回类型不同

    public int calculate(int n1, int n2) {
        System.out.println("calculate(int n1, int n2) 被调用");
        return n1 + n2;
    }

    // 这里返回类型不同
    //与上面没有构成方法重载, 仍然是错误的，因为是方法的重复定义

    // public void calculate(int n1, int n2) {
    // System.out.println("calculate(int n1, int n2) 被调用");
    // int res = n1 + n2;
    // }

形参名不同

     public void calculate(int n1, int n2) {
     	System.out.println("calculate(int n1, int n2) 被调用");
     }

    // 这里形参名字不一样
    // 看看下面是否构成重载, 没有构成，而是方法的重复定义,就错了
    
    // public int calculate(int a1, int a2) {
    // System.out.println("calculate(int n1, int n2) 被调用");
    // return a1 + a2;
    // }

在这里插入图片描述

code

package overload;

public class OverLoadExercise01 {
    public static void main(String[] args) {
        Methods methods = new Methods();
        System.out.println(methods.m(10));
        System.out.println(methods.m(100, 200));
        methods.m("hello");

        System.out.println(methods.max(10,20));
        System.out.println(methods.max(20.4,0.5));
        System.out.println(methods.max(20.4,0.5,99.3));
    }
}

class Methods {
    public int m(int n) {
        return n * n;
    }

    public int m(int n1, int n2) {
        return n1 * n2;
    }

    public void m(String s) {
        System.out.println(s);
    }

    public int max(int n1, int n2) {
        return n1 > n2 ? n1 : n2;
    }

    public double max(double d1, double d2) {
        return d1 > d2 ? d1 : d2;
    }

    public double max(double d1, double d2, double d3) {
        ;

        return (d1 > d2 ? d1 : d2) > d3 ? (d1 > d2 ? d1 : d2) : d3;
    }


}

run
在这里插入图片描述

4.2🥚可变参数

可变参数引出

package VarParameter;

public class VarParameter01 {
    public static void main(String[] args) {
        Method method = new Method();

        System.out.println(method.m1(10,20,30));
        System.out.println(method.m1(10,30));
    }
}
class Method{
    //可以计算 2 个数的和，3 个数的和 ， 4. 5， 。。
//可以使用方法重载
// public int sum(int n1, int n2) {//2 个数的和
// return n1 + n2;
// }
// public int sum(int n1, int n2, int n3) {//3 个数的和
// return n1 + n2 + n3;
// }
// public int sum(int n1, int n2, int n3, int n4) {//4 个数的和
// return n1 + n2 + n3 + n4;
// }
//.....
//上面的三个方法名称相同，功能相同, 参数个数不同-> 使用可变参数优化

    // 可变参数可以当作是一个数组
    public int m1(int... nums){
        int s = 0;
        for (int i = 0 ; i<nums.length ; i++){
            s+=nums[i];
        }
        return s;
    }
}

run
在这里插入图片描述

可变参数细节
在这里插入图片描述

package VarParameter;

public class VarParameterDetail {
    //编写一个 main 方法
    public static void main(String[] args) {

        //细节: 可变参数的实参可以为数组
        // 可变参数的本质就是数组
        int[] arr = {1, 2, 3};
        T t1 = new T();
        t1.f1(arr);
        t1.f2("hello",2.3,9.8,3.3);
    }
}

class T {
    public void f1(int... nums) {
        System.out.println("长度 = " + nums.length);
    }

        //细节: 可变参数可以和普通类型的参数一起放在形参列表，
        // 但必须保证可变参数在最后
        public void f2 (String str,double...nums){
        }
        //细节: 一个形参列表中只能出现一个可变参数
        //下面的写法是错的.
        // public void f3(int... nums1, double... nums2) {
        // }
    
}

练习

有三个方法，分别实现返回姓名和两门课成绩(总分)，
返回姓名和三门课成绩(总分)，返回姓名和五门课成绩（总分）。
封装成一个可变参数的方法

package VarParameter;

public class VarParameterExercise {
    public static void main(String[] args) {
/*        有三个方法，分别实现返回姓名和两门课成绩(总分)，
        返回姓名和三门课成绩(总分)，返回姓名和五门课成绩（总分）。
        封装成一个可变参数的方法*/

        Q q = new Q();
        System.out.println(q.m("小吴",20.2,10.3));
        System.out.println(q.m("小刘",20.2,10.3,56.3));
        System.out.println(q.m("小王",3.2,4.7,3.2,4.7));
    }
}

class Q {
    public String m(String s, double... score) {
        double sum = 0.0;
        for (int i = 0; i < score.length; i++) {
            sum+=score[i];
        }
        return s+" "+score.length+"门课的总成绩为"+sum;
    }
}

run
在这里插入图片描述

4.3🚝作用域

在这里插入图片描述
code

package VarScope;
@SuppressWarnings({"all"})
public class VarScope01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
        cat.cry();
        cat.hi();
    }
}
@SuppressWarnings({"all"})
class Cat {
    //全局变量：也就是属性，作用域为整个类体 Cat 类：cry eat 等方法使用属性
    //属性在定义时，可以直接赋值
    int age = 10; //指定的值是 10
    //全局变量(属性)可以不赋值，直接使用，因为有默认值，
    double weight; //默认值是 0.0

    public void hi() {
        //局部变量必须赋值后，才能使用，因为没有默认值
        int num = 1;
        String address = "北京的猫";
        System.out.println("num=" + num);
        System.out.println("address=" + address);
        System.out.println("weight=" + weight);//属性
    }

    public void cry() {
    //1. 局部变量一般是指在成员方法中定义的变量
    //2. n 和 name 就是局部变量
    //3. n 和 name 的作用域在 cry 方法中
        int n = 10;
        String name = "jack";
        System.out.println("在 cry 中使用属性 age=" + age);
    }

    public void eat() {
        // 优先打印局部变量
        int age = 30;
        System.out.println("在 eat 中使用属性 age=" + age);
        //System.out.println("在 eat 中使用 cry 的变量 name=" + name);//错误
    }
}

run

在这里插入图片描述作用域细节

code

package VarScope;

public class VarScopeDetail01 {

    public static void main(String[] args) {
        Person p1 = new Person();
/*
属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
局部变量，生命周期较短，伴随着它的代码块的执行而创建，
伴随着代码块的结束而销毁。即在一次方法调用过程中
*/
//p1.say();//当执行 say 方法时，say 方法的局部变量比如 name,会创建，当 say 执行完毕后
//name 局部变量就销毁,但是属性(全局变量)仍然可以使用
//
        T t1 = new T();
        Person person = new Person();
        System.out.println(person.name);  //person类里的方法就调用不了了

        t1.test(); //第 1 种跨类访问对象属性的方式
        t1.test2(p1);//第 2 种跨类访问对象属性的方式
    }
}
class T {
    //全局变量/属性：可以被本类使用，或其他类使用（通过对象调用)
    public void test() {
        Person p1 = new Person();
        System.out.println(p1.name);//jack 
    }

    public void test2(Person p) {
        System.out.println(p.name);//jack
    }
}
class Person {
    //细节: 属性可以加修饰符(public protected private..)
    // 局部变量不能加修饰符
    public int age = 20;
    String name = "jack";
    public void say() {
        //细节 属性和局部变量可以重名，访问时遵循就近原则
        /*protected*/ String name = "king"; // 局部变量不能有访问修饰符
        System.out.println("say() name=" + name);
    }
    public void hi() {
        String address = "北京";
        //String address = "上海";//错误,重复定义变量
        String name = "wyt";//可以
    }
}

4.4🗾构造器

看一个需求
我们来看一个需求：前面我们在创建人类的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如
果现在我要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，该怎么做? 这时就可以使用构造器。

基本语法
[修饰符] 方法名(形参列表){
方法体;
}

构造器的修饰符可以默认，也可以是 public protected private
构造器没有返回值
方法名和类名字必须一样
参数列表和成员方法一样的规则
构造器的调用, 由系统完成
基本介绍
构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：
方法名和类名相同
没有返回值
在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。

code

package constructor;

public class constructor01 {
    public static void main(String[] args) {
//当我们 new 一个对象时，直接通过构造器指定名字和年龄
        Person p1 = new Person("smith", 80);
        System.out.println("p1 的信息如下");
        System.out.println("p1 对象 name=" + p1.name);//smith
        System.out.println("p1 对象 age=" + p1.age);//80

    }
}

//在创建人类的对象时，就直接指定这个对象的年龄和姓名

class Person {
    String name;
    int age;

    //1. 构造器没有返回值, 也不能写 void
    //2. 构造器的名称和类 Person 一样
    //3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样
    public Person(String pName, int pAge) {
        System.out.println("构造器被调用~~ 完成对象的属性初始化");
        name = pName;
        age = pAge;
    }
}

run
在这里插入图片描述
构造器细节说明

package constructor;



public class ConstructorDetail {
    //编写一个 main 方法
    public static void main(String[] args) {
        Person1 p1 = new Person1("king", 40);//第 1 个构造器
        Person1 p2 = new Person1("tom");//第 2 个构造器
        
        // 如果想使用默认的无参构造器，必须显式的声明一下
        Dog dog1 = new Dog();//使用的是默认的无参构造器

    }
}
class Dog {
    //如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)
    //使用 javap 指令 反编译看看
    /*
    默认构造器
        Dog() {
        }
    */
    //一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，
    //除非显式的定义一下,即: Dog(){} 写 (这点很重要)
    //
    public Dog(String dName) {
    //...
    }
    /*public*/ Dog() { //显式的定义一下 无参构造器
    }
}
class Person1 {
    String name;
    int age;//默认 0
    //第 1 个构造器

    public Person1(String pName, int pAge) {
        name = pName;
        age = pAge;
    }
    //第 2 个构造器, 只指定人名，不需要指定年龄
    public Person1(String pName) {
        name = pName;
    }
}

练习
在前面定义的 Person 类中添加两个构造器：第一个无参构造器：利用构造器设置所有人的 age 属性初始值都为 18 第二个带 pName 和 pAge 两个参数的构造器：使得每次创建 Person 对象的同时初始化对象的 age 属性值和 name 属性值。分别使用不同的构造器，创建对象

code

package constructor;

public class ConstructorExercise01 {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person("小明",20);
        System.out.println(person1.name+" "+person1.age);
        System.out.println(person2.name+" "+person2.age);

    }
}

class Person{
    String name;
    int age;
    public Person(){
        age = 18;
    }
    public  Person(String pName,int pAge){
        name = pName;
        age = pAge;
    }
}

run

在这里插入图片描述
这个代码在内存中的执行流程

Person p = new Person("小倩",20);
class Person{
    int age = 90;
    String name;
    Person(String s,int a){
        name = s;
        age = a;
    }
}

在这里插入图片描述

4.5🥩this

code


import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Dog dog1 = new Dog("大壮", 3);
        dog1.info();
    }
}

class Dog { //类
    String name;
    int age;

    public Dog(String name, int age) {//构造器
        name = name;   // 这里是给局部变量赋值，并不是属性
        age = age;
    }
    //如果我们构造器的形参，能够直接写成属性名，就更好了
    //但是出现了一个问题，根据变量的作用域原则
    //构造器的 name 是局部变量，而不是属性
    //构造器的 age 是局部变量，而不是属性

    public void info() {//成员方法,输出属性 x 信息
        System.out.println(name + "\t" + age + "\t"); // 打印的是属性
            }
}

run
在这里插入图片描述
code

package this_test;

public class This01 {
    public static void main(String[] args) {
        Dog dog1 = new Dog("大壮", 3);
        System.out.println("dog1 的 hashcode=" + dog1.hashCode());
    //dog1 调用了 info()方法
        dog1.info();
        System.out.println("============");
        Dog dog2 = new Dog("大黄", 2);
        System.out.println("dog2 的 hashcode=" + dog2.hashCode());
        dog2.info();
    }
}
class Dog{ //类
    String name;
    int age;

    //==> 引出 this 关键字来解决
    public Dog(String name, int age){//构造器
    //this.name 就是当前对象的属性 name
        this.name = name;
    //this.age 就是当前对象的属性 age
        this.age = age;
        System.out.println("this.hashCode=" + this.hashCode());
    }
    public void info(){//成员方法,输出属性 x 信息
        System.out.println("this.hashCode=" + this.hashCode());
        System.out.println(name + "\t" + age + "\t");
    }
}

run
在这里插入图片描述

在这里插入图片描述

this细节

this 关键字可以用来访问本类的属性、方法、构造器
this 用于区分当前类的属性和局部变量
访问成员方法的语法：this.方法名(参数列表);
访问构造器语法：this(参数列表); 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句)
this 不能在类定义的外部使用，只能在类定义的方法中使用。

code

package this_test;

public class ThisDetail{
    public static void main(String[] args) {
        // 1) this 关键字可以用来访问本类的属性、方法、构造器
        // 2) this 用于区分当前类的属性和局部变量
        // 3) 访问成员方法的语法：this.方法名(参数列表);
        // 4) 访问构造器语法：this(参数列表);
        // 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句)
        // 5) this 不能在类定义的外部使用，只能在类定义的方法中使用。

        T t01 = new T();		// 测试this来调用方法
        t01.f2();
        System.out.println();

        T t02 = new T();		// 测试this来调用构造器

        T t03 = new T();		// 测试this来调用属性
        t03.f3();



    }
}
class T{
    String name = "小明";
    int age = 19;

    // Detail02:访问构造器语法:this(参数列表);
    // 注意只能在构造器中使用(只能在构造器中访问另一个构造器)
    // 必须放在第一条语句!!!!!!!!!!!!!!!!!!!
    public T(){
        this("jack",18);	// 调用另一个构造器
        System.out.println("T()构造器被调用");
    }
    public T(String name,int age){
        System.out.println("T(String name,int age)构造器被调用");
    }

    // Detail01:访问方法：this.方法名(参数列表);
    public void f1(){
        // this("jack",18);  //  注意，方法中是调用不了构造器的，只有构造器才能调用构造器
        System.out.println("f1()被调用");
    }
    public void f2(){
        System.out.println("f2()被调用");
        f1();
        this.f1();
    }

    public void f3(){
        String name = "王宝强";
        System.out.println("name="+name+"\t"+"age="+age);	        // 就近原则
        System.out.println("name="+this.name+"\t"+"age="+this.age);	// 直接访问当前对象的属性
    }
}

run
在这里插入图片描述

code

package this_test;

public class ThisExercise {
    public static void main(String[] args) {
        /*
		定义 Person 类，里面有 name、age 属性，并提供 compareTo 比较方法，
		用于判断是否和另一个人相等，提供测试类 TestPerson 用于测试
		名字和年龄完全一样，就返回 true, 否则返回 false
		*/
        Person TestPerson = new Person("小明",18);
        boolean b = TestPerson.compareTo("小李",19);
        if (b){
            System.out.println("信息相同");
        }else {
            System.out.println("信息不同");
        }
    }
}
class Person{
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public boolean compareTo(String name, int age){
        if (name.equals(this.name) && age==this.age){
            return true;
        }else {
            return false;
        }
    }
}

code2

package this_test;

public class ThisExercise {
    public static void main(String[] args) {
        /*
		定义 Person 类，里面有 name、age 属性，并提供 compareTo 比较方法，
		用于判断是否和另一个人相等，提供测试类 TestPerson 用于测试
		名字和年龄完全一样，就返回 true, 否则返回 false
		*/
        Person TestPerson = new Person("小明",18);
        Person person = new Person("小明",18);
        boolean b = TestPerson.compareTo(person);
        if (b){
            System.out.println("信息相同");
        }else {
            System.out.println("信息不同");
        }
    }
}
class Person{
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

//    public boolean compareTo(String name, int age){
//        if (name.equals(this.name) && age==this.age){
//            return true;
//        }else {
//            return false;
//        }
//    }
    public boolean compareTo(Person p){
        return this.name.equals(p.name) && this.age==p.age;
    }
}

run
在这里插入图片描述

5.1🥟本章习题

求double数组的最大值

code


public class HomeWork01 {
    public static void main(String[] args) {
        // 求double数组的最大值
        double[] arr = null;//{};//{1.7, 4.5, 8.1, 0.2, 1.4};
        A01 a01 = new A01();
        Double r = a01.m1(arr);
        if (r != null) {
            System.out.println("最大值为 = " + r);
        } else {
            System.out.println("输入有误！");
        }
    }
}

class A01 {
    public Double m1(double... nums) {
        // 提高代码的健壮性
        // 避免空指针
        if (nums != null && nums.length > 0 ) {
            double max = nums[0];
            for (int i = 0; i < nums.length; i++) {
                if (max < nums[i]) {
                    max = nums[i];
                }
            }
            return max;
        } else {
            return null;
        }
    }
}

实现查找某字符串是否在字符串数组中，并返回索引号如果找不到，返回-1

code



public class HomeWork02 {
    public static void main(String[] args) {
        // 实现查找某字符串是否在字符串数组中，并返回索引号
        // 如果找不到，返回-1
        String[] str = null;/*{};*/ //{"王", "宝", "强"};
        String findStr = "强";
        A02 a02 = new A02();
        Integer r = a02.find(str, findStr);
        if (r != null && r != -1) {
            System.out.println("找到了" + findStr + "下标是" + r);
        } else {
            System.out.println("找不到");
        }
    }
}

class A02 {
    public Integer find(String[] str, String findStr) {
        // 必须先写 str!=null ， 换位的话会直接抛出异常
        if (str != null && str.length > 0) {
            for (int i = 0; i < str.length; i++) {
                if (findStr.equals(str[i])) {
                    return i;
                }
            }
            return -1;
        }
        return null;


    }
}

code

package homework;

public class HomeWork03 {
    public static void main(String[] args) {
        // 如果价格>150,则更改为150，如果价格>100,更改为100
        // 否则不变
        A03 a03 = new A03("小王子", 120);
        System.out.print("价格更新前：");
        a03.info();
        a03.updatePrice();
        System.out.print("价格更新后：");
        a03.info();

    }
}

class A03 {
    String name;
    double price;

    public A03(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public void updatePrice() {
        if (price >= 0) {
            if (price > 150) {
                this.price = 150;
            } else if (price > 100) {
                this.price = 100;
            }
        }
    }

    public void info(){
        System.out.println(this.name +" 价格"+this.price);
    }

}

run
在这里插入图片描述

code

package homework;

public class HomeWork04 {
    public static void main(String[] args) {
        // 克隆数组: 输入旧数组，返回一个新数组，元素和旧数组一样
        int oldArr[] = {1, 2, 3, 4, 5, 9};
        A04 a04 = new A04();
        // 返回的新数组
        int[] r = a04.copyArr(oldArr);
        for (int i = 0 ; i< r.length ;i++){
            System.out.print(r[i]+" ");
        }

    }
}

class A04 {
    public int[] copyArr(int[] oldArr) {
        int[] newArr = new int[oldArr.length];
        for (int i = 0; i < oldArr.length; i++) {
            newArr[i] = oldArr[i];
        }
        return newArr;
    }
}

run
在这里插入图片描述

code

package homework;

public class HomeWork05 {
    public static void main(String[] args) {
        // 求圆的周长和面积
        A05 a05 = new A05(4);
        // 求周长
        double c = a05.C();
        // 求面积
        double s = a05.S();
        System.out.println("周长："+c+" 面积："+s);
    }
}


class A05 {
    double circle;

    public A05(double circle) {
        this.circle = circle;
    }

    public double C() {
        return Math.PI * 2 * this.circle;
    }

    public double S() {

        return Math.PI * circle * circle;
    }

}

run
在这里插入图片描述

code

package homework;

public class HomeWork06 {
    public static void main(String[] args) {
        Cale cale = new Cale(20,0);

        Double r = cale.devide();
        if (r != null) {
            System.out.println(cale.devide());
        }
    }
}

class Cale{
    double n1;
    double n2;

    public Cale(double n1, double n2) {
        this.n1 = n1;
        this.n2 = n2;
    }

    public Double devide(){
        if (this.n2==0){
            System.out.println("除数不能为0！");
            return null;
        }else {
            return this.n1 / this.n2;
        }
    }
}

code


public class HomeWork07 {
    int count = 9;
    public void count1(){
        count = 10;
        System.out.println("count1="+count);
    }
    public void count2(){
        System.out.println("count2="+count++);
    }
    public static void main(String[] args) {
        new HomeWork07().count1();
        HomeWork07 t = new HomeWork07();
        t.count2();
        t.count2();
    }
}

run
在这里插入图片描述

code

public class HomeWork08 {
    public static void main(String[] args) {
        Demo d1 = new Demo();
        Demo d2 = d1;
        d2.m();
        System.out.println(d1.i);
        System.out.println(d2.i);
    }
}

class Demo{
    int i = 100;
    public void m(){
        int j = i++;
        System.out.println("i = "+i);
        System.out.println("j = "+j);
    }
}

run
在这里插入图片描述

code

package homework;

public class HomeWork10 {
}

class Employee{
    String name;
    char gender;
    int age;
    String job;
    double sal;
    

    public Employee(String name, char gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    public Employee(String job, double sal) {
        this.job = job;
        this.sal = sal;
    }    
    public Employee(String name, char gender, int age, String job, double sal) {
        // 使用前面的构造器，构造器复用
        this(name,gender,age);  
        this.job = job;
        this.sal = sal;
    }
}

code

package homework;

public class HomeWork11 {
    public static void main(String[] args) {
        Circle circle = new Circle();
        PassObject passObject = new PassObject();
        passObject.printAreas(circle, 5);
    }
}

class Circle {
    double radius;

    public double findArea(double radius) {
        return Math.PI * radius * radius;
    }
}

class PassObject {
    public void printAreas(Circle c, int times) {
        System.out.println("Radius" + "\t" + "Area");
        for (int i = 1; i <= times; i++) {
            System.out.println(i +"\t\t" +c.findArea(i));
        }
    }
}

run
在这里插入图片描述

code
run

难吃的茄子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
【JavaSE】- 面向对象编程(基础部分)

/编写一个 main 方法 public static void main(String [ ] args) {//方法使用 //1. 方法写好后，如果不去调用(使用)，不会输出 //2. 先创建对象 ,然后调用方法即可 Person p1 = new Person();//调用方法 p1 . cal01();//调用 cal01 方法 p1 . cal02(5);//调用 cal02 方法，同时给 n = 5 p1 . cal02(10);
复制链接

扫一扫