Java基础学习第七天——面向对象常见概念

成员变量与局部变量

• 成员变量与局部变量区别：
  • A：在类中的位置不同
    • 成员变量：在类中，方法外
    • 局部变量：在方法定义中或者方法声明上。
  • B:在内存中的位置不同：
    • 成员变量：在堆内存
    • 局部变量：在栈内存
  • C:生命周期不同
    • 成员变量：随着对象的创建而存在，随着对象的消失而消失
    • 局部变量：随着方法的调用而存在，随着方法的调用完毕而存在
  • D:初始化值不同
    • 成员变量：有默认初始值
    • 局部变量：没有默认初始值，必须定义，赋值，然后才能使用。
• 注：局部变量名称可以和成员变量名称一致，在方法中使用的时候，采用就近原则。

类 类型的形式参数问题

• 一个方法的形式参数是一个类 类型(引用类型)，这里其实需要的是该类的对象。

//形式参数是 基本类型
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的地址给到了这里
    }
}

匿名对象

• 匿名对象：就是没有名字的对象。是对象的一种简化表示形式。
• 匿名对象的两种使用情况
  • 对象调用方法仅仅一次的时候
  • 作为实际参数传递
• 匿名调用好处
  • 匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。

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();
        //匿名对象
        sd.method(new Student());

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

封装

• 封装概述:
  • 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
• 好处：
  • 隐藏实现细节，提供公共的访问方式
  • 提高了代码的复用性
  • 提高安全性
• 封装原则：
  • 将不需要对外提供的内容都隐藏起来。
  • 把属性隐藏，提供公共方法对其访问。
• 注：
  • 测试类一般只创建对象，调用方法。

private关键字

• 是一个权限修饰符,是封装的一种体现。
• 可以修饰成员(成员变量和成员方法)
• 被private修饰的成员只在本类中才能访问。

private最常见的应用

• 把成员变量用private修饰
• 提供对应的getXxx()/setXxx()方法

this关键字

• this:代表所在类的对象引用
• 方法被哪个对象调用，this就代表那个对象

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

    //姓名获取值
    public String getName() {
        return name;
    }

    //姓名设置值
    public void setName(String name) { //name = "林青霞";
        //Student.name = name;
        this.name = name;
    }

    //年龄获取值
    public int getAge() {
        return age;
    }

    //年龄赋值
    public void setAge(int age) {
        this.age = age;
    }
}

//测试类
class StudentTest {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();

        //给成员变量赋值
        s.setName("林青霞");
        s.setAge(27);
        //获取数据
        System.out.println(s.getName()+"---"+s.getAge());
    }
}

构造方法

• 构造方法作用概述
  • 给对象的数据进行初始化
• 构造方法格式
  • 方法名与类名相同
  • 没有返回值类型，连void都没有
  • 没有具体的返回值。(可以有return；这一语句，表示方法到这里结束)
• 构造方法注意事项
  • 如果你不提供构造方法，系统会给出默认无参构造方法
  • 如果你提供了构造方法，系统将不再提供默认的无参构造方法。必须自己给出。（建议永远自己给出无参构造方法！）
  • 构造方法也是可以重载的

class Student {
    private String name;
    private int age;

    public Student() {
        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();
    }
}

一个基本类的标准代码写法

• 成员变量
• 构造方法
  • 无参构造方法
  • 带参构造方法
• 成员方法
  • getXxx()
  • setXxx()
• 给成员变量赋值的方式
  • 无参构造方法+setXxx()
  • 带参构造方法

/*
    一个标准代码的最终版。

    学生类：
        成员变量：
            name，age
        构造方法：
            无参，带两个参
        成员方法：
            getXxx()/setXxx()
            show()：输出该类的所有成员变量值

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

    输出成员变量值的方式：
        A:通过getXxx()分别获取然后拼接
        B:通过调用show()方法搞定
*/
class Student {
    //姓名
    private String name;
    //年龄
    private int age;

    //构造方法
    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    //输出所有的成员变量值
    public void show() {
        System.out.println(name+"---"+age);
    }
}

//测试类
class StudentTest {
    public static void main(String[] args) {
        //方式1给成员变量赋值
        //无参构造+setXxx()
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(27);
        //输出值
        System.out.println(s1.getName()+"---"+s1.getAge());
        s1.show();
        System.out.println("----------------------------");

        //方式2给成员变量赋值
        Student s2 = new Student("刘意",30);
        System.out.println(s2.getName()+"---"+s2.getAge());
        s2.show();
    }
}

Student s = new Student();在内存中做了哪些事情

• 加载Student.class文件进内存
• 在栈内存为s开辟空间
• 在堆内存为学生对象开辟空间
• 对学生对象的成员变量进行默认初始化
• 对学生对象的成员变量进行显示初始化
• 通过构造方法对学生对象的成员变量赋值
• 学生对象初始化完毕，把对象地址赋值给s变量

static关键字(重难点)

• 可以修饰成员变量和成员方法
• static关键字特点
  • 随着类的加载而加载
  • 优先于对象存在
  • 被类的所有对象共享
    • 这也是我们判断是否使用静态关键字的条件
  • 可以通过类名调用,也可以通过对象调用。
• static关键字注意事项
  • 在静态方法中是没有this关键字（无法从静态上下文引用非静态 变量 xxx）
    • 因为静态时随着类的加载而加载，this是随着对象的创建而存在。
    • 静态比对象先存在。
  • 静态方法只能访问静态的成员变量和静态的成员方法，非静态方法可以随意访问。

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);

    }

    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();
    }
}

静态变量和成员变量的区别

• 所属不同
  • 静态变量属于类，所以也称为类变量
  • 成员变量属于对象，所以也称为实例变量(对象变量)
• 内存中位置不同
  • 静态变量存储于方法区的静态区
  • 成员变量存储于堆内存
• 内存出现时间不同
  • 静态变量随着类的加载而加载，随着类的消失而消失
  • 成员变量随着对象的创建而存在，随着对象的消失而消失
• 调用不同
  • 静态变量可以通过类名调用，也可以通过对象调用
  • 成员变量只能通过对象名调用

main方法是静态的

• public static void main(String[] args) {}
  • public 公共的，访问权限最大，因为被jvm调用，需要访问权限足够大。
  • static 静态的，不需要创建对象，被jvm调用，不用创建对象，直接类名访问
  • void被jvm调用，不需要给jvm返回值
  • main 一个通用的名称，虽然不是关键字，但是被jvm识别
  • String[] args 以前用于接收键盘录入的
    • eg：java MainDemo hello world java