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

编写学生类

package com.jian.demo1;

public class Student { //第一步：编写类，比如：学生类
    //第二步：编写属性也叫做编写编写成员变量，比如：姓名、年龄、性别、身高、体重
    String name; //默认值为null
    int age;    //默认值为0
    char gender;    //默认值为\u0000
    double height;  //默认值为0.0
    double weight;  //默认值为0.0

    //第三步：编写方法，比如：学习
    public void study(){
        System.out.println("正在学习面向对象......");
    }

}

 编写测试类

package com.jian.demo1;

public class Test { //编写测试类
    public static void main(String[] args) {
        /*
            根据类来创建对象，语法格式：类名 对象名 = new 类名();
            当执行new运算符时，则表示创建一个对象，并且在堆内存中开辟一块空间存储一个对象，会自动分配一个内存地址，当前创建的是学生对象，则就会在该对象中存放5个属性，并且都是默认值
            将对象的内存地址赋给左侧的对象名zs
         */
        Student zs = new Student();
        /*
            输出对象中所有的属性值，语法格式：对象名.属性名
            注意：当编写对象名.时，提示m表示为方法(method)，提示f表示字段(field)，其中字段也就是属性或者成员变量

         */
//        System.out.println(name); //出现编译错误，原因：当前main方法中没有name属性，因此不能直接访问
        System.out.println(zs.name); //null
        System.out.println(zs.age); //0
        System.out.println(zs.gender); //
        System.out.println(zs.height); //0.0
        System.out.println(zs.weight); //0.0

        //实现对属性赋值，语法格式： 对象名.属性名 = 值;
        zs.name = "张三";
        zs.age = 19;
        zs.gender = '男';
        zs.height = 1.74;
        zs.weight = 80.2;

        //输出对象名zs中所有的属性值
        System.out.println("姓名：" + zs.name + "\n年龄：" + zs.age + "\n性别：" + zs.gender + "\n身高：" + zs.height + "\n体重：" + zs.weight);

        /*
            访问对象中的方法，语法格式：对象名.方法名称([参数列表]);
            注意：不能使用类名.方法名称，原因：当前方法没有编写static因此访问不到
         */
        zs.study();

        //一个类可以创建任意多个对象，因此来创建第二个学生对象
        Student s2 = new Student();
        System.out.println("s2.name = " + s2.name); //null
        s2.study();
    }
}

 编写电脑类，属性：品牌、内存、价格、尺寸、颜色，方法：输出电脑的信息

package com.jian.demo2;

/**
 * 编写电脑类，属性：品牌、内存、价格、尺寸、颜色，方法：输出电脑的信息
 * 
 */
public class Computer {
    //编写属性也叫做编写成员变量或者编写字段f
    String brand;
    String memory;
    int price;
    double size;
    String color;
    //编写方法，输出电脑的信息，其实也就是将电脑中所有的属性值在该方法中输出
    public void print(){
        //可以在当前类中直接使用属性或者成员变量或者字段
        System.out.println("品牌：" + brand + "\n内存：" + memory + "\n价格：" + price + "\n尺寸：" + size + "\n颜色：" + color);
    }
}

 编写电脑测试类，创建电脑对象，调用方法输出所有信息
 创建电脑对象，完成对所有属性赋值，并调用方法输出电脑信息

package com.jian.demo2;

/**
 * 编写电脑测试类，创建电脑对象，调用方法输出所有信息
 *                  创建电脑对象，完成对所有属性赋值，并调用方法输出电脑信息
 */
public class Test {
    public static void main(String[] args) {
        //创建电脑对象
        Computer c = new Computer();
        //调用方法输出所有信息
        c.print();

        System.out.println("--------------");
        //创建电脑对象
        Computer c2 = new Computer();
        //完成对所有属性赋值
        c2.color = "黑色";
        c2.size = 15.6;
        c2.price = 5688;
        c2.memory = "16G";
        c2.brand = "Lenovo";

        //并调用方法输出电脑信息
        c2.print();
    }
}

Dog类

package com.jian.demo1;

public class Dog {
    String nickName; //nickName就是成员变量
    int age; //age就是成员变量
    String breed; //breed就是成员变量

    public void print(){
        int a; //a就是局部变量
        int b = 100; //b就是局部变量
        double c; //c就是局部变量
        for(int i = 1;i <= 5;i++){ //i就是局部变量

        }
    }
    public void print2(){
        System.out.println(nickName);
        System.out.println(age);
        System.out.println(breed);
    }
    public void print3(){
        int num; //局部变量
//        System.out.println(num); //出现编译错误，原因：局部变量没有默认值，必须先声明，然后再赋值，最后才可以使用

        num = 123;
        System.out.println(num);
    }

    public void print4(){
        /*
        总结：在同一个类中，局部变量的名字可以与成员变量的名字同名，不报错，但是局部变量优先，也就是就近的优先，如果非要访问成员变量，则必须使用this.
        this代表当前这个对象，也就是说当前谁调用这个方法则这个对象就是谁
         */
        String nickName = "旺财"; //nickName就是局部变量
        System.out.println(nickName);
        System.out.println("输出成员变量nickName的值：" + this.nickName);
    }
}

 测试类

package com.jian.demo1;

public class Test {
    public static void main(String[] args) {
        //创建Dog对象
        Dog d = new Dog();
//        d.print2();
//        d.print3();
        d.print4();

        //创建第二个Dog对象
        Dog dog1 = new Dog();
        dog1.nickName = "二哈";
        dog1.print4();
    }
}

 Car类

package com.jian.demo2;

public class Car {
    //编写成员变量也叫做编写属性或者编写字段f
    String id; //表示车牌号
    String brand;
    int price;

    //编写方法
    public void setId(String id){ //形参id属于局部变量，只能在当前方法中使用
        //实现将形参的id值赋给成员变量id
        //id = id; //注意：不报错，但是没有达到要求，目前实现的是形参id赋给形参id
        //应该编写为：成员变量 = 局部变量;
        this.id = id;
    }
}

 测试类

package com.jian.demo2;

public class Test {
    public static void main(String[] args) {
        //创建小轿车对象
        Car c = new Car();
        c.setId("京A12345");
        System.out.println(c.id); //京A12345
        System.out.println(c.brand); //null
        System.out.println(c.price); //0
    }
}

 构造方法

package com.jian.demo3;

/**
 * 构造方法：
 *      1.构造方法作用：实现对象属性赋值
 *      2.什么是构造方法？
 *          构造方法是一个特殊的方法
 *          构造方法的名字必须与类名一致
 *          构造方法必须没有返回值类型，也就是都不需要编写void
 *      3.构造方法语法格式
 *          public 类名([参数列表]){
 *              完成对属性赋值
 *          }
 *      4.快捷键生成构造方法
 *        4.1光标放在类体中，按Alt + Insert键，选择第一项Constructor构造器回车，如果按两次Tab键，则生成无参构造方法
 *           注意：大多数无参构造方法体中不编写任何内容
 *        4.2光标放在类体中，按Alt + Insert键，选择第一项Constructor构造器回车，鼠标左键点击要赋值的属性，然后再按Ctrl + 鼠标左键点击其他要赋值的属性，再按回车，则生成带参构造方法，实现对部分属性赋值
 *        4.3光标放在类体中，按Alt + Insert键，选择第一项Constructor构造器回车，按Ctrl + A全选，实现带参构造方法，完成对所有属性赋值的构造方法
 *      5.构造方法如何执行？
 *          ----当创建对象时会自动找相匹配的构造方法执行
 *          注意：1.当创建对象时小括号中没有内容，则执行无参构造方法
 *               2.当创建对象时小括号中有内容，则执行相匹配的带参构造方法，否则出现编译错误
 *               3.建议：当编写new，然后敲一个空格，编写类名的首字母，这时就可以按方向键进行选择执行哪个构造方法
 *               4.当创建对象时没有选择执行哪个构造方法，则需要进行设置，具体如下：
 *                 File--->Settings--->Editor--->General--->Code Completion--->右侧设置参数信息，将第一项和第三项勾上，点击OK
 *      6.构造方法注意事项
 *          6.1在一个类中，如果没有编写构造方法，则系统会提供一个默认的无参的构造方法，称为隐式构造方法
 *             总结：一个类中不编写构造方法，则有一个无参的隐式的构造方法
 *          6.2在一个类中，如果编写构造方法，则系统不会提供默认的无参的构造方法，称为显式构造方法
 *              总结：在一个类中编写几个构造方法，则就有几个构造方法
 *          6.3建议：当编写构造方法时，先编写无参构造方法，然后再编写需要的带参构造方法，否则可能会出现编译错误
 *      7.构造方法重载
 *          7.1什么是构造方法重载？
 *              在同一个类中，构造方法的名字必须相同，参数列表必须不同(个数不同、类型不同、顺序不同)，至少编写两个构造方法
 *          7.2当构成构造方法重载以后，怎么知道要执行哪个构造方法？
 *              在创建对象时，会自动找相匹配的构造方法执行，否则出现编译错误
 *          7.3构造方法重载好处：
 *              在使用时更灵活
 */
public class Student {
    //编写属性也叫做编写成员变量或者字段
    String name;
    int age;
    char gender;
    double height;
    double weight;
    double score;
    public void Student(){ //注意：不报错，但是不是构造方法，只是一个普通的方法

    }
    //编写无参构造方法
    public Student() {
        //完成对名字和年龄属性赋值
        name = "无名氏";
        age = 18;
    }
    //编写带参构造方法，实现对名字和分数赋值赋值
    public Student(String name, double score) {
        this.name = name;
        this.score = score;
    }
    //编写带参构造方法，实现对名字、年龄、性别属性赋值
    public Student(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    //编写带参构造方法，实现对身高和体重属性赋值
    public Student(double height, double weight) {
        this.height = height;
        this.weight = weight;
    }
    //编写带参构造方法，实现对年龄、性别、身高属性赋值
    public Student(int age, char gender, double height) {
        this.age = age;
        this.gender = gender;
        this.height = height;
    }
    //编写带参构造方法，实现对名字、年龄、性别、身高和体重属性赋值
    public Student(String name, int age, char gender, double height, double weight) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.height = height;
        this.weight = weight;
    }
    //编写带参构造方法，实现对所有属性赋值的构造方法
    public Student(String name, int age, char gender, double height, double weight, double score) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.height = height;
        this.weight = weight;
        this.score = score;
    }

    //编写方法，实现输出学生的所有信息
    public void print(){
        System.out.println("姓名：" + name + "\n年龄：" + age + "\n性别：" + gender + "\n身高：" + height + "\n体重：" + weight + "\n分数：" + score);
    }
}

 测试类

package com.jian.demo3;

public class Test {
    public static void main(String[] args) {
        //创建学生对象
        Student stu = new Student();

        //第一种方法：实现对属性赋值，语法格式：对象名.属性名 = 值;
        stu.name = "张浩";
        stu.score = 98.5;
        stu.weight = 76.4;
        stu.height = 1.76;
        stu.gender = '男';
        stu.age = 19;

        //调用方法
        stu.print();

        //第二种方法：实现对属性赋值，使用构造方法
    }
}

package com.jian.demo3;

public class Test2 {
    public static void main(String[] args) {
        /*
            1.创建学生对象同时执行无参构造方法，其实也就是小括号没有内容，则执行学生的无参构造方法
            2.执行相匹配构造方法的代码如何编写？
                当编写new，然后敲一个空格，编写类名的首字母，这时就可以按方向键进行选择,
                当小括号中没有内容则执行无参构造方法
                当小括号中有内容则执行相匹配的带参构造方法
            3.当编写new,敲一个空格，然后编写类名首字母后没有提示要选择执行哪个构造方法，具体设置如下：
                File--->Settings--->Editor--->General--->Code Completion--->右侧设置参数信息，将第一项和第三项勾上，点击OK
         */
        /*Student s1 = new Student();
        s1.print();*/

        //创建学生对象同时执行带参构造方法，完成对名字和成绩属性赋值
       /* Student s2 = new Student("莉莉", 89.7);
        s2.print();*/

       //创建学生对象同时执行带参构造方法，完成对
        /*Student s3 = new Student(27, '女', 1.64);
        s3.print();*/

        //创建学生对象同时执行带参构造方法，完成对所有属性赋值
        Student s4 = new Student("lisi", 23, '男', 1.77, 80.1, 92.5);
        s4.print();

    }
}

 编写车类，属性：车牌号、品牌、颜色、价格，方法：输出车的信息

package com.jian.demo4;

/**
 * 编写车类，属性：车牌号、品牌、颜色、价格，方法：输出车的信息
 * 
 */
public class Car {
    //编写属性也叫做编写成员变量或者编写字段f
    String id; //表示车牌号
    String brand;
    String color;
    int price;

    public Car() {
    }

    public Car(String id, String brand) {
        this.id = id;
        this.brand = brand;
    }

    public Car(String id, String brand, String color, int price) {
        this.id = id;
        this.brand = brand;
        this.color = color;
        this.price = price;
    }

    //方法：输出车的信息
    public void print(){
        System.out.println("车牌号：" + id + "\n品牌：" + brand + "\n颜色：" + color + "\n价格：" + price);
    }
}

 编写测试类，创建对象同时执行无参构造方法，并调用方法输出车的信息
 创建对象同时执行带两个参数的构造方法，完成对车牌号和品牌赋值，并调用方法输出车的信息
 创建对象同时执行带参构造方法完成对所有属性赋值，并调用方法输出车的信息

package com.jian.demo4;

/**
 * 编写测试类，创建对象同时执行无参构造方法，并调用方法输出车的信息
 * 	     创建对象同时执行带两个参数的构造方法，完成对车牌号和品牌赋值，并调用方法输出车的信息
 * 	     创建对象同时执行带参构造方法完成对所有属性赋值，并调用方法输出车的信息
 *
 */
public class Test {
    public static void main(String[] args) {
        //创建对象同时执行无参构造方法
        Car c1 = new Car();
        //并调用方法输出车的信息
        c1.print();

        System.out.println("------------------");
        //创建对象同时执行带两个参数的构造方法，完成对车牌号和品牌赋值
        Car c2 = new Car("辽A66666","大众" );
        //并调用方法输出车的信息
        c2.print();

        System.out.println("------------------");
        //创建对象同时执行带参构造方法完成对所有属性赋值
        Car c3 = new Car("鲁A88888", "比亚迪", "黑色", 100000);
        //并调用方法输出车的信息
        c3.print();
    }
}

编写猫类，属性：昵称，年龄，性别，无参构造，带参构造，输出猫的信息

package com.jian.demo5;

public class Cat {
    //编写属性也叫做成员变量或者字段f
    String nickName;
    int age;
    char gender;

    public Cat() {
    }

    public Cat(String nickName, int age, char gender) {
        this.nickName = nickName;
        this.age = age;
        this.gender = gender;
    }
    //编写方法，输出猫的信息
    public void print(){
        System.out.println("昵称：" + nickName + "\n年龄：" + age + "\n性别：" + gender);
    }
}

 编写测试类

package com.jian.demo5;

public class Test {
    public static void main(String[] args) {
        //int num = 18;
        //上面一条语句，等价于如下写法：
        /*int num; //表示声明一个整数类型局部变量名称num
        num = 18;
        num = -1;
        num = 123;

        String name;*/

        //创建猫的对象同时执行无参构造方法
        //Cat c = new Cat();
        //上面一条语句，也可以编写为如下代码：
        Cat c; //表示声明一个Cat类型的局部变量名c,其中Cat是一个自定义类的类名，在Java中可以使用类名作为数据类型
        c = new Cat();
        c.print();
        System.out.println("----------------");
        c = new Cat("小白", 3, '公');
        c.print();

        //也可以对对象名赋值为null
        c = null;
        /*
            属于运行错误，空指针异常java.lang.NullPointerException
            原因：当前对象名c中存放的是null，也就是说存放的不是地址，因此没有指向某个对象，所以就不能访问对象中的属性和对象中的方法，如果非要访问，则就出现空指针异常
         */
//        c.print();
        //解决办法：在访问对象中的属性或对象中的方法之前，必须保证对象名中存放的是地址，也就是指向某个对象，就可以访问对象中的属性或对象中的方法
        System.out.println("-----------------------");
        c = new Cat();
        c.print();
    }
}