【03】Java入门03：类与对象

一、类与对象及其使用

1.类与对象概述

    1) 描述现实世界事物
        ①属性就是该事物的描述信息(事物身上的名词)。
        ②行为就是该事物能够做什么(事物身上的动词)。

    2) Java中最基本的单位是类
        ①成员变量就是事物的属性。
        ②成员方法就是事物的行为。

    3) 定义类其实就是定义类的成员(成员变量和成员方法)

        ①成员变量和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
        ②成员方法和以前定义方法是一样的，只不过把static去掉。

2.类和对象的概念

    类：是一组相关的属性和行为的集合（我们班所有的同学都具备相同的属性和行为，比如：姓名，年龄，学习，这样就把所有的学生成为学生类）。
    对象：是该类事物的具体体现（说某个同学时，他都具备自己特有的属性和行为）。

3.利用学生介绍类及对象使用

public class Student {
    // 成员变量
    // 姓名
    String name;
    // 年龄
    int age;
	
    // 成员方法
    // 学习的方法
    public void study() {
        System.out.println("好好学习，天天向上");
    }
	
    // 吃饭的方法
    public void eat() {
        System.out.println("学习饿了要吃饭");
    }
}

public class stuClassDemo {
    public static void main(String[] args) {
        // 格式：类名 对象名 = new 类名();
        Student s = new Student();
        // System.out.println("s:"+s); // com.jzfblog.Student@193c0cf
		
        //直接输出成员变量值
        System.out.println("姓名："+s.name); // null
        System.out.println("年龄："+s.age); // 0
        System.out.println("----------");
		
        // 给成员变量赋值
        s.name = "黄雨廷";
        s.age = 18;
		
        // 再次输出成员变量的值
        System.out.println("姓名："+s.name); // 黄雨廷
        System.out.println("年龄："+s.age); // 18
        System.out.println("----------");
		
        // 调用成员方法
        s.study();
        s.eat();
    }
}

　　

4.成员变量和局部变量区别

    1) 在类中的位置不同
        ①成员变量：类中，方法外。
        ②局部变量：方法中或者方法声明上(形式参数)。

    2) 在内存中的位置不同

        ①成员变量：堆内存。
        ②局部变量：栈内存。

    3) 生命周期不同
        ①成员变量：随着对象的创建而存在，随着对象的消失而消失。
        ②局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。

    4) 初始化值的问题
        ①成员变量：有默认值。
        ②局部变量：没有默认值。必须先定义，赋值，最后使用。

二、面向对象特性之封装

1. private关键字

    ①是一个权限修饰符。
    ②可以修饰成员(成员变量和成员方法)。
    ③被private修饰的成员只在本类中才能访问。

2.封装的概述和好处

    1) 封装概述

        ①是面向对象三大特征之一。
        ②是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。

    2) 封装原则

        ①将不需要对外提供的内容都隐藏起来。
        ②把属性隐藏，提供公共方法对其访问。
        ③成员变量private，提供对应的getXxx()/setXxx()方法

    3) 好处

        ①通过方法来控制成员变量的操作，提高了代码的安全性。
        ②把代码用方法进行封装，提高了代码的复用性。

3.this关键字

    ①代表所在类的对象引用。
    ②方法被哪个对象调用，this就代表那个对象。
    ③什么时候使用this：局部变量和成员变量重名。

public class Student {
    private String name;
    private int age;
   
    public void setName(String name) { // "黄雨廷"
        // name = name;
        this.name = name;
    }
   
    public String getName() {
        return name;
    }
   
    public void setAge(int age) {
        // age = age;
        this.age = age;
    }
   
    public int getAge() {
        return age;
    }
}

三、面向对象之构造方法

1.构造方法

    主要用来给对象的数据进行初始化。

2.构造方法格式

    ①方法名与类名相同。
    ②没有返回值类型，连void都没有。
    ③没有具体的返回值。

3.构造方法注意事项与重载

    ①如果你不提供构造方法，系统会给出默认构造方法。
    ②如果你提供了构造方法，系统将不再提供。
    ③构造方法也是可以重载的,重载条件和普通方法相同。

public class gouzao {	
    private String name;
    private int age;
    public gouzao(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void show () {
        System.out.println("我是"+name+",今年"+age+"岁");
    }
}

public class gouzaoDemo {
    private static gouzao s;
    public static void main(String[] args) {
        // 如何调用构造方法呢?
        // 通过new关键字调用
        // 格式：类名 对象名 = new 构造方法(...);
        s = new gouzao("jack", 18);
        s.show();
    }
}

四、类名作为形参和返回值

1.类名作为方法的形式参数

public class Student {
    public void study() {
        System.out.println("好好学习,天天向上");
    }
}

public class Teacher {
    public void test(Student s) {   // 接收传递过来的Student对象的地址值
        s.study();                 
    }
}
// 需求： 调用Teacher的test方法
 
// 类名作为形式参数：其实这里需要的是该类对象。
public class Test {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        Student s = new Student();
        t.test(s);
    }
}

2.类名作为返回值案例

public class Student {
    public void study() {
        System.out.println("好好学习,天天向上");
    }
}

public class Teacher {
    public Student getStudent() {
        Student s = new Student();
        return s;// 返回的是Student对象的地址值
    }
}

// 需求： 通过Teacher得到Student对象，然后调用Student类的方法
// 如果方法的返回值是类名：其实返回的是该类的对象
public class Test {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        Student s = t.getStudent();
        s.study();
    }
}

五、static静态关键字

1.static

    是一个关键字，用于修饰成员变量和成员方法。

2.static的特点

    ①被所有的对象所共享。
    ②可以使用类名调用。
    ③静态的加载优先于对象。
    ④随着类的加载而加载。

3.静态方法

    ①可以调用静态的成员变量。
    ②可以调用静态的成员方法。
    ③不可以调用非静态成员变量。
    ④不可以调用非静态成员方法。
    ⑤静态方法只能调用静态的成员。

4.非静态方法

    ①可以调用静态的成员变量。
    ②可以调用静态的成员方法。
    ③可以调用非静态的成员变量。
    ④可以调用非静态的成员方法。

5.静态优点

    ①对对象的共享数据提供单独空间的存储，节省空间，没有必要每一个对象都存储一份。
    ②可以直接被类名调用,不用在堆内存创建对象。
    ③静态成员可以通过类名直接访问,相对创建对象访问成员方便。

6.静态弊端

    访问出现局限性。（静态虽好，但只能访问静态）。

7.类变量

    其实就是静态变量。
    ①定义位置：定义在类中方法外。
    ②所在内存区域：方法区。
    ③生命周期：随着类的加载而加载。
    ④特点：无论创建多少对象,类变量仅在方法区中,并且只有一份。

8.实例变量

    其实就是非静态变量。
    ①定义位置：定义在类中方法外。
    ②所在内存区域：堆。
    ③生命周期：随着对象的创建而加载。
    ④特点：每创建一个对象,堆中的对象中就有一份实例变量。