小白学Java代码：类和对象（下）

编写年级类
属性：年级编号、年级名称、年级地址
构造方法：无参、带参
方法：输出年级的所有信息

package com.bjpowernode.demo1;

/**
 * 编写年级类
 * 	属性：年级编号、年级名称、年级地址
 * 	构造方法：无参、带参
 * 	方法：输出年级的所有信息
 * 
 */
public class Grade {
    //属性也叫做成员变量或者字段f
    int id; //表示年级编号
    String name;
    String address;
    //构造方
    public Grade() {
    }

    public Grade(int id, String name, String address) {
        this.id = id;
        this.name = name;
        this.address = address;
    }
    //方法：输出年级的所有信息
    public void print(){
        System.out.println("年级编号：" + id + "\n年级名称：" + name + "\n年级地址：" + address);
    }
}

编写学生类
属性：学号、姓名、年龄、性别、年级
构造方法：无参、带参
方法：输出学生的所有信息(学号、姓名、年龄、性别、年级名称、年级地址)

package com.bjpowernode.demo1;

/**
 * 编写学生类
 * 	属性：学号、姓名、年龄、性别、年级
 * 	构造方法：无参、带参
 * 	方法：输出学生的所有信息(学号、姓名、年龄、性别、年级名称、年级地址)
 *
 */
public class Student {
    //编写属性
    int stuNum;
    public String stuName;
    int stuAge;
    char stuGender;
    Grade stuGrade; //默认值为null

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

    public Student(int stuNum, String stuName, int stuAge, char stuGender, Grade stuGrade) {
        this.stuNum = stuNum;
        this.stuName = stuName;
        this.stuAge = stuAge;
        this.stuGender = stuGender;
        this.stuGrade = stuGrade;
    }
    //方法：输出学生的所有信息(学号、姓名、年龄、性别、年级名称、年级地址)
    public void print(){
        System.out.println("学号：" + stuNum);
        System.out.println("姓名：" + stuName);
        System.out.println("年龄：" + stuAge);
        System.out.println("性别：" + stuGender);
        /*
            注意：当年级属性stuGrade没有赋值，则是null默认值，此时就不能再去访问对象中的属性或方法，如果非要访问则就出现空指针异常
            解决办法：在调用属性或方法之前必须要先进行判断，如果年级属性名stuGrade中存放的是null,则就表示没有存放对象的地址,直接输出null，就不需要调用对象中的属性或方法,否则表示stuGrade属性中存放地址，则就可以调用对象中的属性或方法
                  则使用三目运算符完成
                  但是运行后发现依然出现空指针异常,则必须将三目运算符括起来
         */
        System.out.println("年级名称：" + (stuGrade == null ? null : stuGrade.name));
        System.out.println("年级地址：" + (stuGrade == null ? null :stuGrade.address));
    }
}

测试类

package com.bjpowernode.demo1;

public class Test {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();
        //并调用方法输出学生的所有信息
        s.print();

        System.out.println("-----------------------");
        //创建学生对象同时执行带参构造方法
        s = new Student(02012, "小张", 24, '男',new Grade(2013, "Java工程师", "北京市"));
        //其实上面一条语句也可以编写为如下代码
        /*Grade g = new Grade(2013, "Java工程师", "北京市");
        s = new Student(2012, "小张", 24, '男', g);*/

        s.print();
    }
}

1.this关键字可以访问本类(当前类)中的实例变量

package com.jian.demo3;

/**
 * 1.this关键字可以访问本类(当前类)中的实例变量
 *      1.变量：存放数据的，并且存放的数据是可以发生改变的
 *        实例变量也就是对象的变量：也就是属性(成员变量、字段)没有使用static关键字修饰
 *        静态变量也叫做类的变量：也就是属性(成员变量、字段)使用static关键字修饰
 *      2.实例变量什么时候存在？
 *          当创建对象时，会在堆内存的对象中存放，因此也叫做对象的变量
 *      3.当局部变量没有与实例变量同名，则可以在本类(当前类)中直接使用实例变量，其实默认前面添加this.
 *        比如：brand其实等价于this.brand
 *      4.在同一个类中，局部变量的名字可以与实例变量同名，不报错，但是局部变量优先也就是就近的优先，如果非要访问实例变量则必须使用this.
 * 
 */
public class Computer {
    //编写实例变量也就是对象的变量
    String brand;
    int price;
    double size;

    //编写方法
    public void print(){
        //3当局部变量没有与实例变量同名，则可以在本类(当前类)中直接使用实例变量，其实默认前面添加this.
        System.out.println(brand); //等价于this.brand
        System.out.println(price); //等价于this.price
        System.out.println(size); //等价于this.size
    }

    public void print2(){
        //4.在同一个类中，局部变量的名字可以与实例变量同名，不报错，但是局部变量优先也就是就近的优先，如果非要访问实例变量则必须使用this.
        String brand = "acer"; //brand就是局部变量
        System.out.println("输出实例变量品牌的值：" + this.brand);
        System.out.println("输出局部变量品牌的值：" + brand);
    }
}

测试类

package com.jian.demo3;

public class Test {
    public static void main(String[] args) {
        //创建电脑对象
        Computer c = new Computer();
        c.print();

        Computer computer = new Computer();
        computer.print();

        c.print2();
        computer.print2();


    }
}

2.this关键字可以访问本类(当前类)中的实例方法

package com.jian.demo4;

/**
 * 2.this关键字可以访问本类(当前类)中的实例方法
 *    2.1实例方法也就是对象的方法：其实就是在方法前面没有编写static关键字
 *        静态方法也就是类的方法：其实也就是在方法中使用static关键字修饰
 *    2.2在同一个类中，实例方法之间是可以相互直接调用，也就是默认前面添加this.
 * 
 */
public class Computer {

    //实例方法也叫做对象的方法
    public void print(){

    }
    public void print2(){
        this.print();  //等价于print();
    }
}

测试类

package com.jian.demo4;

public class Test {
    public static void main(String[] args) {
        Computer c1 = new Computer();
        c1.print2();

        Computer c = new Computer();
        c.print2();
    }
}

3.this关键字可以访问本类中的其他构造方法

package com.jian.demo5;

/**
 * 3.this关键字可以访问本类中的其他构造方法
 *   调用本类中的构造方法，则使用this关键字
 *         ---如果this后面的小括号中没有内容，则执行无参构造方法
 *         ---如果this后面的小括号中有内容，则执行带参构造方法
 *         注意事项：1.当使用this关键字调用本类的构造方法时,必须编写在构造方法中，并且是第一条语句
 *                 2.当使用this关键字调用构造方法时，不能构造方法自己调用自己，也就是递归调用，也就是死循环，没有意义
 * 
 */
public class Computer {
    //编写实例变量
    String brand;
    String color;
    int price;
    double size;
    //构造方法

    public Computer() {
    }

    public Computer(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }

    public Computer(String brand, String color, int price, double size) {
        /*this.brand = brand;
        this.price = price;*/
        /*
        其实上面两条语句，也可以编写调用本类中的带两个参数的构造方法，完成对品牌和价格
        调用本类中的构造方法，则使用this关键字
        ---如果this后面的小括号中没有内容，则执行无参构造方法
        ---如果this后面的小括号中有内容，则执行带参构造方法
        注意事项：1.当使用this关键字调用本类的构造方法时,必须编写在构造方法中，并且是第一条语句
                2.当使用this关键字调用构造方法时，不能构造方法自己调用自己，也就是递归调用，也就是死循环，没有意义
         */
        this(brand, price);
        this.color = color;
        this.size = size;
    }
    //编写方法，输出电脑的所有信息
    public void print(){
        System.out.println("品牌：" + this.brand + "\n颜色：" + this.color + "\n价格：" + this.price + "\n尺寸：" + this.size);
    }
}