人生苦短我学Java-6-面向对象之类与方法定义/实例化/重载/可变个数形参/递归

一、面向对象

1、面向对象的三大特征

• 封装
• 继承
• 多态

如果要说是四大特征就多加：抽象性

 

2、类(Class)和对象(Object)是面向对象的核心概念。

•  类是对一类事物的描述，是抽象的、概念上的定义。重点就是类的设计(比如我们人类，是有哪些特征等等)
•  对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。

类就好比如是：人类

对象：实实在在的我

如下：创建PersonTest类，其中有属性有方法：

package com.object;

/*
@USER PPL-泡泡龙 or 广深小龙
@date 2020-12-20 12:42
*/

public class Person {
    public static void main(String[] args) {
        PersonTest p1 = new PersonTest();
        p1.name = "ppl";
        p1.age = 18;
        p1.isMale = true;
        p1.eat();
        p1.sleep();
        p1.talk();
    }

}

class PersonTest {

    // 属性
    String name;
    int age;
    boolean isMale;

    // 方法
    public void eat() {
        System.out.println("人吃什么？答：人间烟火");
    }

    public void sleep() {
        System.out.println("人需要睡觉休息，专家建议每天睡眠至少8小时");
    }

    public void talk() {
        System.out.println("人可以说话，但我说的是中文");
    }
}

3、类属性(成员变量)与局部变量

也意味着作用域不一样。

特别需要注意：局部变量在调用前是没有初始值，所以一定要在调用前初始化值，除了形参以调用时传入；

package com.object;

/*
@USER PPL-泡泡龙 or 广深小龙
@date 2020-12-20 12:15
*/

public class ObjectTest {
    public static void main(String[] args) {
        User user = new User();
        user.name = "泡泡龙";
        user.age = 18;
        user.eat("米饭");
    }
}

class User {

    // 类的变量
    String name;
    int age; 

    public void eat(String food) {
        System.out.println("姓名：" + name + " 吃的是什么？ 答案：" + food);
        System.out.println("年龄只有：" + age);

        String IsMale = "true";  // 方法的变量（局部变量）
        System.out.println("我是局部变量：" + IsMale);
    }
}

4、类的方法声明

• pubilc String xx：定义了返回值为String类型，就一定要有String返回值；
• pubilc String xx(String xxx){}：形参xxx，可以多个形参，逗号分开，调用该方法时传入；
• 方法中也可以调用类的属性；
• return既是结束这个方法执行，并返回值；(结束后面不可再执行，因已结束方法)；
• 在类中的方法A它可以调用方法B等等，特殊的递归，方法A调用方法A；(慎用递归)
• 方法中，不能再定义方法；(Python里面是可以的，常用装饰器便如此)

package com.object;

/*
@USER PPL-泡泡龙 or 广深小龙
@date 2020-12-20 16:20
*/

public class ClassM {
    public static void main(String[] args) {
        ClassTest m = new ClassTest();
        m.eat("米饭");
        System.out.println(m.name);
        System.out.println(m.getName());
        System.out.println(m.returnName());

        // 引用类型
        ClassTest[] st = new ClassTest[3];
        st[0] = new ClassTest();
        System.out.println("111" + st[0].name);
    }
}

class ClassTest {

    // 类属性
    String name = "泡泡龙";

    // 形参：food，可以多个逗号分开
    public void eat(String food) {
        System.out.println("吃的是：" + food);
    }

    // 有返回值：return，需指定返回的类型，比如：String
    // 但是命名指定了返回值的类型，就一定要有：return返回值
    public String getName() {
        eat("面条");      // 方法内部调用方法
        return name;
    }

    // 判断语句，需要在各个分支都要return
    public String returnName() {
        if ("泡泡".contains(name)) {
            return name;
        } else if ("泡泡龙".contains(name)) {
            return "1";
        } else {
            return "-1";
        }
    }
}

输出：

吃的是：米饭
泡泡龙
吃的是：面条
泡泡龙
1
111泡泡龙

5、匿名实例化对象

在实例化中，没有赋值给一个变量，即为匿名实例化；

特征：只能调用一次（再调用就是新的调用，内存解析会重新执行）new ClassName().方法名；

package com.object;

/*
@USER PPL-泡泡龙 or 广深小龙
@date 2020-12-20 17:47
*/

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

        // 正常实例化
        PersonT p = new PersonT();
        p.GetAge();

        // 匿名实例化
        new PersonT().GetAge();
    }
}

class PersonT {
    int age = 8;

    public void GetAge() {
        System.out.println(age);
    }
}

6、方法重载

同一个类，相同的方法名，参数不同包括形参个数,不同参数的类型。跟起它都没有关系，比如返回值，修饰符等。

简单来说处理不同数据类型的时候，可以定义不同类型，同名称的方法，方便我们任何类型进行调用。

package com.object1220;

/*
@USER PPL-泡泡龙 or 广深小龙
@date 2020-12-20 19:47
*/

public class OverLoad {

    // 方法重载，定义两个同名的方法：print
    public String print(String str) {
        return str;
    }

    public int print(int num) {
        return num;
    }
}

class OverLoadTest {
    public static void main(String[] args) {
        OverLoad o = new OverLoad();
        System.out.println(o.print("字符串"));
        System.out.println(o.print(666));
    }
}

7、可变个数形参方法

格式：public void 方法名(数据类型... 变量名){}

• 也是可以形成方法重载，但也得遵循重载原来的规则；
• 传参时可以传入多个，通过变量名下标获取或者遍历获取所以传入的参数；
• 只能命名一个数据类型的可变个数形参；

package com.object1220;

/*
@USER PPL-泡泡龙 or 广深小龙
@date 2020-12-20 20:18
*/

public class Args {

    // 可变个数形参
    public void eat(String... food) {
        // 遍历可变形参
        String strs = "";
        for (int i = 0; i < food.length; i++) {
            strs += food[i] + " ";
        }
        System.out.println(strs);
    }

    public void eat(String food) {
        System.out.println("重载：" + food);
    }

    public void eat(int count) {
        System.out.println("重载，每天吃几次？：" + count);
    }

    public static void main(String[] args) {
        Args a = new Args();
        a.eat("1", "2", "3", "PPL");
        a.eat("米饭");
        a.eat(3);
    }
}

输出：

1 2 3 PPL
重载：米饭
重载，每天吃几次？：3

二、递归

递归方法：一个方法内调用它自身(方法调方法)，递归有它的一个深度，不然就和死循环没什么区别；

1、例子：计算1-100之间所有自然数之和;用递归实现；

package com.object1223;

/*
@USER PPL-泡泡龙 or 广深小龙
@date 2020-12-23 22:13
*/

public class Recursion {
    public static void main(String[] args) {
        /*
        1、递归方法：一个方法内调用它自身(方法调方法)
        */
        Recursion rec = new Recursion();
        System.out.println(rec.getNumber(100));
    }

    // 计算1-100之间所有自然数之和;
    public int getNumber(int i) {
        if (i == 1) {
            return 1;
        } else {
            return i + getNumber(i - 1);
        }
    }
}

就比如斐波那契也是利用递归，递归是一种算法，一种解决问题的思路；

2、其它面试题

题一：

/*
* 定义一个int型的数组:{10, 3, 234, 234, 12, 123, 34, 86};
* 让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组。
*/

package com.interview;

/*
@USER PPL-泡泡龙 or 广深小龙
@date 2020-12-21 21:36
*/

import java.util.Arrays;

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

        int[] arr = {10, 3, 234, 234, 12, 123, 34, 86};
//         for (int i = 0; i < arr.length; i++) {       // 错误写法

        // 方法一：倒着来可以的
        for (int i = arr.length - 1; i >= 0; i--) {
            arr[i] = arr[i] / arr[0];
        }
        System.out.println(Arrays.toString(arr));

        // 方法二：用变量来先赋值下标为0的数值
        int[] arr2 = {10, 3, 234, 234, 12, 123, 34, 86};
        int temp = arr2[0];
        for (int i = 0; i < arr.length; i++) {
            arr2[i] = arr2[i] / temp;
        }
        System.out.println(Arrays.toString(arr2));
    }
}

题二： // 需要在method调用后仅打印出a=100,b=200；(method是你要写的处理逻辑)

package com.interview;

/*
@USER PPL-泡泡龙 or 广深小龙
@date 2020-12-21 21:51
*/

public class Interview2 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;

        // 需要在method调用后仅打印出a=100,b=200；
        method(a, b);

        System.out.println("a=" + a);
        System.out.println("b=" + b);
    }

    public static void method(int a, int b) {
        a = a * 10;
        b = b * 20;
        System.out.println("a=" + a);
        System.out.println("b=" + b);
        System.exit(0);
    }
}

题三：看以下程序，说出程序运行后输出的内容，ps：char类型是直接输出内容；

package com.interview;

/*
@USER PPL-泡泡龙 or 广深小龙
@date 2020-12-21 22:00
*/

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

        int[] arr = new int[10];
        System.out.println(arr);        // 输出地址值

        char[] arr1 = new char[2];
        System.out.println(arr1);       // 为啥是空？

        char[] arr2 = {'a', 'b'};
        System.out.println(arr2);       // 输出的是 a b
    }
}

 感谢尚硅谷在B站开源教学视频提供学习，欢迎来大家QQ交流群一起学习：482713805