Java基础05-面向对象&private\this\static关键字

面向对象

类

package 进阶.Demo03_面向对象;

public class demo03_局部和成员变量的区别 {
    public static void main(String[] args) {

        /*局部变量和成员变量的区别：
        * 1. 定义的位置不同：
        *   局部变量： 方法的内部
        *   成员变量： 方法的外部，类中
        * 2. 作用的范围不同：
        *   局部变量： 只有方法当中可以使用，方法之外不可用
        *   成员变量： 整个类都可以使用
        * 3. 默认值不一样：
        *   局部变量： 没有默认值
        *   成员变量： 有默认值
        * 4. 内存中的位置不一样:
        *   局部变量： 位于栈内存
        *   成员变量： 位于堆内存
        * 5. 生命周期不一样：
        *   局部变量：随着方法的进栈诞生，随着出栈而消失
        *   成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
        * */

    }

    String name; // 成员变量

    public void methodA() {
        int num = 10; // 局部变量
        System.out.println(num);
        System.out.println(name);
    }

    public void methodB(int param) { // 方法的参数是局部变量
        System.out.println(param);
        // 局部param参数在方法调用时，必然会被赋值，此处正确。
        int age;
//        System.out.println(age);  局部age未赋值，不可用
//        System.out.println(num);  错误写法，未定义局部变量
    }

}

对象

package 进阶.Demo03_面向对象;



public class demo02_学生对象 {
    public static void main(String[] args) {
        /*实例化类:
        * 1. 导包:需要指出使用的类的路径: import 包名称.类名称;
        *   当前包无需进行导入
        * 2. 创建
        *   类名称 对象名 = new 类名称();
        *   Student stu = new Student();
        * 3. 使用
        *   对象名.成员变量名
        * */

        demo01_学生类 student = new demo01_学生类();
        System.out.println(student.name); // null
        System.out.println(student.age); // 0

        student.name = "Jack";
        student.age = 24;
        System.out.println(student.name);
        System.out.println(student.age);

        student.eat();
        student.sleep();
    }
}

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

package 进阶.Demo03_面向对象;

public class demo03_局部和成员变量的区别 {
    public static void main(String[] args) {

        /*局部变量和成员变量的区别：
        * 1. 定义的位置不同：
        *   局部变量： 方法的内部
        *   成员变量： 方法的外部，类中
        * 2. 作用的范围不同：
        *   局部变量： 只有方法当中可以使用，方法之外不可用
        *   成员变量： 整个类都可以使用
        * 3. 默认值不一样：
        *   局部变量： 没有默认值
        *   成员变量： 有默认值
        * 4. 内存中的位置不一样:
        *   局部变量： 位于栈内存
        *   成员变量： 位于堆内存
        * 5. 生命周期不一样：
        *   局部变量：随着方法的进栈诞生，随着出栈而消失
        *   成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
        * */

    }

    String name; // 成员变量

    public void methodA() {
        int num = 10; // 局部变量
        System.out.println(num);
        System.out.println(name);
    }

    public void methodB(int param) { // 方法的参数是局部变量
        System.out.println(param);
        // 局部param参数在方法调用时，必然会被赋值，此处正确。
        int age;
//        System.out.println(age);  局部age未赋值，不可用
//        System.out.println(num);  错误写法，未定义局部变量
    }

}

面向对象的封装性

package 进阶.Demo03_面向对象;

public class demo04_封装性 {
    public static void main(String[] args) {

        /*面向对象特性：
        * 封装、继承、多态
        *
        * 封装性的体现：
        * （封装其实是将一些细节隐藏起来，对于外界不可见。）
        * 1. 方法就是一种封装
        * 2. 关键字private也是一种封装
        *
        * */
    }
}

private关键字

类

package 进阶.Demo03_面向对象;

public class demo05_Person类_privat关键字 {
    /*问题:
    * 定义Person的年龄时，无法判断年龄是否合法
    * 解决：
    * 用private关键字将需要保护的成员变量进行修饰。
    * 注意：
    * 使用了private关键字之后，该属性本类当中仍然可以随意访问，
    * 但是超出本类范围之外就不能直接访问了。
    * 间接访问方法如下：Getter() && Setter()   （注意Boolean值为`isser`）
    * 对于Getter：不能有参数，返回值类型和成员变量对应
    * 对于Setter: 不能有返回值，参数类型和成员变量对应
    * */

    String name;
//    int age;
    private int age;

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

    // 该成员方法，专门用于向age设置值
    public void setAge(int num) {
        if(num < 100 && num > 1) {
            age = num;
        } else {
            System.out.println("年龄不合法");
        }
    }

    // 该成员方法，专门用于获取私有属性age的值
    public int getAge() {
        return age;
    }
}

对象

package 进阶.Demo03_面向对象;

public class demo06_Person对象_private关键字 {
    public static void main(String[] args) {
        demo05_Person类_privat关键字 person = new demo05_Person类_privat关键字();
        person.show();

        person.name = "Jack";
        person.setAge(-24); // 不合法
        person.show();

    }
}

this关键字

类

package 进阶.Demo03_面向对象;

public class demo07_Cat类_this关键字 {

    /*
    * 当方法的局部变量和类的成员变量重名冲突时，根据`就近原则`，优先使用局部变量，
    * 如果需要访问本类中的成员变量，需要使用格式： this.成员变量名
    *
    * 哪一个对象调用的该方法，this就指代该对象本身
    * */

    String name;
    int age;

    // 成员方法中的参数 与 成员属性的参数发生冲突时，需要添加关键字`this`
    public void say(String name) {
        System.out.println(this.name + ":" + name + "!");
    }
}

对象

package 进阶.Demo03_面向对象;

public class demo08_Cat对象_this关键字 {

    public static void main(String[] args) {

        demo07_Cat类_this关键字 blue = new demo07_Cat类_this关键字();
        blue.name = "blue";
        blue.say("hua");
    }
}

static关键字

类

package 进阶.Demo03_面向对象;

public class demo09_Students类_static关键字 {
    public static void main(String[] args) {
        /*static关键字：
        * 如果一个成员变量使用了static关键字，则该属性属于类，不属于对象
        * 如果一个成员变量使用了static关键字，则该方法属于类，不属于对象
        *
        * 注意事项：
        * 1. 无论是静态方法和静态变量，都推荐类名称进行调用，本类中调用静态方法可以不需要类名称
        * 2. 静态方法可以访问静态变量，静态不能直接访问非静态，因为先加载静态，后加载非静态内容
        * 3. 静态方法中不能使用this关键字
        *
        * 静态代码块：
        * static { }
        * 第一次使用本类时，执行唯一一次。多用于：一次性为静态成员变量赋值。
        * */
    }

    static {
        System.out.println("静态代码块执行");
    }

    private String name;
    private int age;

    public demo09_Students类_static关键字() {
    }

    public demo09_Students类_static关键字(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void func() {
        System.out.println("成员方法");
    }
    public static void staticFunc() {
        System.out.println("静态方法");
    }

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


}

对象

package 进阶.Demo03_面向对象;

public class demo10_Students对象_static关键字 {

    public static void main(String[] args) {
        demo09_Students类_static关键字 one = new demo09_Students类_static关键字("Jack",24);
        demo09_Students类_static关键字 two = new demo09_Students类_static关键字("Rose",23);
        System.out.println(one.getName());
        System.out.println(two.getName());

        one.func();
        // 对于静态方法，可以通过对象调用，也可以通过类名称调用
        one.staticFunc(); // 不推荐，编译之后也会被翻译为类名称.静态方法。
        demo09_Students类_static关键字.staticFunc(); // 推荐

    }
}