面向对象（二）

最新推荐文章于 2024-09-04 10:03:11 发布

原创最新推荐文章于 2024-09-04 10:03:11 发布 · 228 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#面向对象

JAVA学习专栏收录该内容

59 篇文章

订阅专栏

成员变量和局部变量的区别

    A:在类中的位置不同
        成员变量：在类中方法外
        局部变量：在方法定义中或者方法声明上
    B:在内存中的位置不同
        成员变量：在堆内存
        局部变量：在栈内存
    C:生命周期不同
        成员变量：随着对象的创建而存在，随着对象的消失而消失
        局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
    D:初始化值不同
        成员变量：有默认初始化值
        局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

    注意事项：
        局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

class Varialbe {
    //成员变量
    //int num = 10;
    int num; //0

    public void show() {
        //int num2 = 20; //局部变量
        //可能尚未初始化变量num2
        //int num2; //没有默认值
        int num2 = 20;
        System.out.println(num2);

        //int num = 100;
        System.out.println(num);
    }
}


class VariableDemo {
    public static void main(String[] args) {
        Varialbe v = new Varialbe();

        System.out.println(v.num); //访问成员变量

        v.show();   

    }
}

形式参数的问题

    基本类型：形式参数的改变不影响实际参数
    引用类型：形式参数的改变直接影响实际参数

//形式参数是基本类型
class Demo {
    public int sum(int a,int b) {
        return a + b;
    }
}

//形式参数是引用类型
class Student {
    public void show() {
        System.out.println("我爱学习");
    }
}

class StudentDemo {
    //如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
    public void method(Student s) { //调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();
        s.show();
    }
}

class ArgsTest {
    public static void main(String[] args) {
        //形式参数是基本类型的调用
        Demo d = new Demo();
        int result = d.sum(10,20);
        System.out.println("result:"+result);
        System.out.println("--------------");

        //形式参数是引用类型的调用
        //需求：我要调用StudentDemo类中的method()方法
        StudentDemo sd = new StudentDemo();
        //创建学生对象
        Student s = new Student();
        sd.method(s); //把s的地址给到了这里
    }
}

匿名对象

    就是没有名字的对象。

匿名对象的应用场景：
    A:调用方法，仅仅只调用一次的时候。
        注意：调用多次的时候，不适合。
        那么，这种匿名调用有什么好处吗?
            有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
    B:匿名对象可以作为实际参数传递

class Student {
    public void show() {
        System.out.println("我爱学习");
    }
}

class StudentDemo {
    public void method(Student s) {
        s.show();
    }
}

class NoNameDemo {
    public static void main(String[] args) {
        //带名字的调用
        Student s = new Student();
        s.show();
        s.show();
        System.out.println("--------------");

        //匿名对象
        //new Student();
        //匿名对象调用方法
        new Student().show();
        new Student().show(); //这里其实是重新创建了一个新的对象
        System.out.println("--------------");


        //匿名对象作为实际参数传递
        StudentDemo sd = new StudentDemo();
        //Student ss = new Student();
        //sd.method(ss); //这里的s是一个实际参数
        //匿名对象
        sd.method(new Student());

        //在来一个
        new StudentDemo().method(new Student());
    }
}

封装和private关键字

private:
    是一个权限修饰符
    可以修饰成员变量和成员方法
    被其修饰的成员只能在本类中被访问

class Demo {
    //int num = 10;
    //用private修饰
    private int num = 10;

    public void show() {
        System.out.println(num);
    }

    private void method() {
        System.out.println("method");
    }

    public void function() {
        method();
    }
}

class PrivateDemo {
    public static void main(String[] args) {
        Demo d = new Demo();
        //不能方法私有的成员变量
        //System.out.println(d.num);
        d.show();
        //不能访问私有的成员方法
        //d.method();
        d.function();
    }
}

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

class Student {
    //姓名
    String name;
    //年龄
    private int age;

    //写一个方法对数据进行校验
    /*
        返回值类型：void
        参数列表：int a
    */
    public void setAge(int a) {
        if(a < 0 || age > 120) {
            System.out.println("你给的年龄有问题");
        }else {
            age = a;
        }
    }


    //show()方法,显示所有成员变量值
    public void show() {
        System.out.println("姓名："+name);
        System.out.println("年龄："+age);
    }
}

class StudentDemo {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();
        s.show();
        System.out.println("--------------");

        //给成员变量赋值
        s.name = "林青霞";
        //s.age = 27;
        s.setAge(27);
        s.show();
        System.out.println("--------------");

        //给age赋值
        //s.age = -27; //这个数据是不合理的
        //通过方法给值
        s.setAge(-27);
        s.show();
        System.out.println("--------------");
    }
}

this关键字

this:哪个对象调用那个方法，this就代表那个对象

class Student {
    private String name;
    private int age;

    public String getName() {
        return name; //这里其实是隐含了this
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

class StudentTest2 {
    public static void main(String[] args) {
        //创建一个对象
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(27);
        System.out.println(s1.getName()+"---"+s1.getAge());

        //创建第二个对象
        Student s2 = new Student();
        s2.setName("刘意");
        s2.setAge(30);
        System.out.println(s2.getName()+"---"+s2.getAge());
    }
}

this内存图

构造方法

    给对象的数据进行初始化

格式：
    A:方法名与类名相同
    B:没有返回值类型，连void都没有
    C:没有具体的返回值

class Student {
    private String name; //null
    private int age; //0

    public Student() {
        System.out.println("这是构造方法");
    }
}

class ConstructDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        System.out.println(s); //Student@e5bbd6
    }
}

我们一直在使用构造方法，但是，我们确没有定义构造方法，用的是哪里来的呢?

构造方法的注意事项:
    A:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
    B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
        注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

给成员变量赋值有两种方式：
    A:setXxx()
    B:构造方法

class Student {
    private String name;
    private int age;

    public Student() {
        //System.out.println("我给了，你还给不");
        System.out.println("这是无参构造方法");
    }

    //构造方法的重载格式
    public Student(String name) {
        System.out.println("这是带一个String类型的构造方法");
        this.name = name;
    }

    public Student(int age) {
        System.out.println("这是带一个int类型的构造方法");
        this.age = age;
    }

    public Student(String name,int age) {
        System.out.println("这是一个带多个参数的构造方法");
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name+"---"+age);
    }
}

class ConstructDemo2 {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.show();
        System.out.println("-------------");

        //创建对象2
        Student s2 = new Student("林青霞");
        s2.show();
        System.out.println("-------------");

        //创建对象3
        Student s3 = new Student(27);
        s3.show();
        System.out.println("-------------");

        //创建对象4
        Student s4 = new Student("林青霞",27);
        s4.show();
    }
}

类的组成

类的组成：
    A: 成员变量
    B: 构造方法
    C: 成员方法
        根据返回值：
            void类型
            非void类型
        形式参数：
            空参方法
            非空参方法

创建对象做了哪些事情

main方法格式讲解

main方法的格式讲解：
    public static void main(String[] args) {...}

    public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
    static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
    void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。
    main:是一个常见的方法入口。我见过的语言都是以main作为入口。
    String[] args:这是一个字符串数组。值去哪里了?
        这个东西到底有什么用啊?怎么给值啊?
            这个东西早期是为了接收键盘录入的数据的。
            格式是：
                java MainDemo hello world java

static关键字

static的特点：(它可以修饰成员变量，还可以修饰成员方法)
        A:随着类的加载而加载
            回想main方法。
        B:优先于对象存在
        C:被类的所有对象共享
            举例：咱们班级的学生应该共用同一个班级编号。
            其实这个特点也是在告诉我们什么时候使用静态?
                如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
            举例：
                饮水机(用静态修饰)
                水杯(不能用静态修饰)
        D:可以通过类名调用
            其实它本身也可以通过对象名调用。
            推荐使用类名调用。

        静态修饰的内容一般我们称其为：与类相关的，类成员

class Student {
    //非静态变量
    int num = 10;

    //静态变量
    static int num2 = 20;
}

class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.num);

        System.out.println(Student.num2);
        System.out.println(s.num2);
    }
}

注意事项

static关键字注意事项
        A:在静态方法中是没有this关键字的
            如何理解呢?
                静态是随着类的加载而加载，this是随着对象的创建而存在。
                静态比对象先存在。
        B:静态方法只能访问静态的成员变量和静态的成员方法
                静态方法：
                    成员变量：只能访问静态变量
                    成员方法：只能访问静态成员方法
                非静态方法：
                    成员变量：可以是静态的，也可以是非静态的
                    成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
            简单记：
                静态只能访问静态。

class Teacher {
    public int num = 10;
    public static int num2 = 20;

    public void show() {
        System.out.println(num); //隐含的告诉你访问的是成员变量
        System.out.println(this.num); //明确的告诉你访问的是成员变量
        System.out.println(num2);

        //function();
        //function2();
    }

    public static void method() {
        //无法从静态上下文中引用非静态 变量 num
        //System.out.println(num);
        System.out.println(num2);

        //无法从静态上下文中引用非静态 方法 function()
        //function();
        function2();
    }

    public void function() {

    }

    public static void function2() {

    }
}

class TeacherDemo {
    public static void main(String[] args) {
        //创建对象
        Teacher t = new Teacher();
        t.show();
        System.out.println("------------");
        t.method();
    }
}