6.Java面向对象（基础）

1.对象概述

在Java中，必须先设计类，才能获得对象
类： 是对象共同特征的描述； 对象：是真实存在的具体实例
如何定义类

public class 类名  {
	1.成员变量(代表属性，一般是名词)
	2.成员方法(代表行为，一般是动词)
	3.构造器
	4.代码块
	5.内部类
}

public class Car {
	String name;
	double price;
	public void run() {
	}
}

Car c = new Car();
c.name = "奔驰";
c.price = 20.8

2.定义类的补充事项

成员变量的完整定义格式是：修饰符 数据类型 变量名称 = 初始化值； 一半无需指定初始化值
类名首字母建议大写，且有意义，满足驼峰模式
一个Java文件中可以定义多个class类，且只能一个类是public修饰，而且public修饰的类名必须称为代码文件名（实际开发中建议还是一个文件定义一个class类）

垃圾回收
注意：当堆内存中的类对象或数组对象，没有被任何变量引用（指向）时，就会被判定为内存中的垃圾
Java存在垃圾回收器，会定期进行清理

3.案例：购物车模拟

Goods.java

public class Goods {
    int id;  // 编号
    String name;  // 名称
    double price;  // 价格
    int buyNum;  // 购买数量
}

shopCar.java

public class ShopCatTest {
    public static void main(String[] args) {
        // 1.定义商品类，用于后期创建商品对象
        // 2.定义购物车对象，使用一个数组对象表示
        Goods[] shopCar = new Goods[100];  // [null, null, ...]
        // 3.搭建操作架构
        while (true) {
            System.out.println("请您选择如下名命令进行操作");
            System.out.println("添加商品到购物车: add");
            System.out.println("查询购物车上坪商品: query");
            System.out.println("修改商品购买数量: update");
            System.out.println("结果购买商品的金额： pay");
            Scanner sc = new Scanner(System.in);
            System.out.println("请您输入命令");
            String command = sc.next();
            switch(command) {
                case "add":
                    // 添加商品到购物车
                    addGoods(shopCar, sc);
                    break;
                case "query":
                    // 查询购物车商品展示
                    queryGoods(shopCar);
                    break;
                case "update":
                    // 修改商品购买数量
                    updateGoods(shopCar, sc);
                    break;
                case "pay":
                    // 结算金额
                    payGoods(shopCar);
                    break;
                default:
                    System.out.println("没有该功能");
            }
        }
    }
    /*
    *  完成商品添加到购物车的功能
    * */
    public static void addGoods(Goods[] shopCar, Scanner sc) {
        // 1.录入用户输入的购买的商品的信息
        System.out.println("请您输入购买商品的编号（不重复）");
        int id = sc.nextInt();
        System.out.println("请您输入购买商品的名称");
        String name = sc.next();
        System.out.println("请输入购买商品的数量");
        int buyNum = sc.nextInt();
        System.out.println("请输入购买商品的价格");
        double price = sc.nextDouble();

        // 2.把购买商品的信息封装成一个商品对象
        Goods g = new Goods();
        g.id = id;
        g.name = name;
        g.buyNum = buyNum;
        g.price = price;

        // 3.把商品对象添加到购物车数组中去
        // shopCar = [null, null, null, ...]
        for (int i = 0; i < shopCar.length; i++) {
            if(shopCar[i] == null) {
                // 此位置没有元素存入，把新买的商品添加到此处即可
                shopCar[i] = g;
                break;
            }
        }
        System.out.println("添加完成");
    }

    /*
    *  查询购物车中的商品对象并展示
    * */
    public static void queryGoods(Goods[] shopCar) {
        System.out.println("查询购物车信息如下");
        System.out.println("编号\t\t名称\t\t价格\t\t购买数量");
        for (int i = 0; i < shopCar.length; i++) {
            Goods g = shopCar[i];
            if(g != null) {
                // 展示商品对象
                System.out.println(g.id+"\t\t"+g.name+"\t\t"+g.price+"\t\t"+g.buyNum);
            } else {
                // 遍历结束
                System.out.println("商品展示结束");
                break;
            }
        }
    }
    /*
    *  修改购物车中购买商品的数量
    * */
    public static void updateGoods(Goods[] shopCar, Scanner sc) {
        // 输入要修改的商品的id, 根据id查询出要修改的商品对象
        while (true) {
            System.out.println("请输入要修改的商品id");
            int id = sc.nextInt();
            Goods g = getGoodsById(shopCar, id);
            if(g == null) {
                // 没有该上坪
                System.out.println("对不起，没有购买该商品");
            } else {
                System.out.println("请您输入"+g.name+"的购买数量");
                int buyNUm = sc.nextInt();
                g.buyNum =buyNUm;
                queryGoods(shopCar);
                break;
            }
        }
    }
    /*
    *  通过id查询商品
    * */
    public static Goods getGoodsById(Goods[] shopCar,int id ) {
        for (int i = 0; i < shopCar.length; i++) {
            Goods g = shopCar[i];
            if(g != null) {
                // 判断这个商品对象的id是否是要找的
                if(g.id == id) {
                    return g;
                }
            } else {
                return null; // 找完了所有存在的商品，都没有找到
            }
        }
        return null; // 找完100个商品都没找到
    }
    public static void payGoods(Goods[] shopCar) {
        double totalPrice = 0;
        for (int i = 0; i < shopCar.length; i++) {
            Goods g =shopCar[i];
            if(g != null) {
                totalPrice += g.price * g.buyNum;
            } else {
                break;
            }
        }
        System.out.println("总价为"+totalPrice);
    }
}

4.构造器

作用： 用于初始化一个类的对象，并返回对象的地址。 Car c = new Car()
构造器的定义格式

修饰符 类名(形参列表) {
}

public class Car {
	// 无参数构造器
	public Car() {
	}
	// 有参数构造器
	public Car(String n, String b) {
	}
}

构造器的分类
无参数构造器（默认存在的）：初始化的对象时，成员变量的数据均采用默认值
有参数构造器：在初始化对象的时候，同时可以为对象进行赋值

初始化对象的格式
类型 变量名称 = new 构造器
Car c = new Car()

Car.java

public class Car {
    String name;
    double price;
    // 无参数构造器
    public Car() {
        System.out.println("无参数构造器被触发执行");
    }
    // 有参数构造器
    public Car(String n,double p) {
        name = n;
        price = p;
    }
}

Test.java

public class Test {
    public static void main(String[] args) {
        Car c = new Car();
        System.out.println(c.name);
        System.out.println(c.price);

        Car c2 = new Car("宝马",  99.9);
        System.out.println(c2.name);
        System.out.println(c2.price);
    }
}

5.this关键字

作用:出现在成员方法、构造器中代表当前对象的地址，用于访问当前对象的成员变量、成员方法
this出现在有参数构造器中的方法

public class Car {
    String name;
    double price;

    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }
}

this出现在成员方法中

 public void runWith(String name) {
  	System.out.println(this.name+ "正在和" + name + "比赛");
 }

6.封装

面向对象的三大特征：封装，继承，多态
封装：合理隐藏，合理暴露
封装的实现步骤
一般对成员变量private（私有）关键字修饰进行隐藏，private修饰后该成员变量就只能在当前类中访问
提供public修饰的公开的getter、setter方法暴露其取值和赋值

public class Student {
    private int age;
    /*
    *  取值的方法 getAge
    * */
    public int getAge() {
        return age;
    }
    /*
    *  赋值的方法 setAge
    * */
    public void setAge(int age) {
        if(age >= 0 && age <= 200) {
            this.age = age;
        } else {
            System.out.println("年龄不合法");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.getAge());
        s.setAge(20);
    }
}

封装的好处
1.加强了程序代码的安全性
2.适当的封装可以提高开发效率，同时可以让程序更容易理解和维护

7.JavaBean

可以理解为实体类，其对象可以用于在程序中封装数据
标准JavaBean需满足如下要求
1.成员变量使用private修饰
2.提供每一个成员变量对应的setXxx(),getXxx()
3.必须提供一个无参构造器

public class User {
    //1. 成员变量私有
    private String name;
    private double salary;
    // 3.必须要有无参构造器（默认的）
    public User() {
    }
    // 4.有参构造器（可选）
    public User(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    //2. 必须提供成套的getter 和 setter方法暴露成员变量的取值和赋值
    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

public class Test {
    public static void main(String[] args) {
        User u = new User();
        u.setName("张三");
        u.setSalary(67.8);
        System.out.println(u.getName());
        System.out.println(u.getSalary());

        User u2 = new User("李四", 6700);
        System.out.println(u2.getSalary());
        System.out.println(u2.getName());
    }
}

8.购物车案例改进

package com.xwl.javabean;

public class Goods {
    private int id;  // 编号
    private String name;  // 名称
    private double price;  // 价格
    private int buyNum;  // 购买数量

    public Goods() {
    }

    public Goods(int id, String name, double price, int buyNum) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.buyNum = buyNum;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getBuyNum() {
        return buyNum;
    }

    public void setBuyNum(int buyNum) {
        this.buyNum = buyNum;
    }
}

package com.xwl.javabean;
import java.util.Scanner;
public class ShopCatTest {
    public static void main(String[] args) {
        // 1.定义商品类，用于后期创建商品对象
        // 2.定义购物车对象，使用一个数组对象表示
        Goods[] shopCar = new Goods[100];  // [null, null, ...]
        // 3.搭建操作架构
        while (true) {
            System.out.println("请您选择如下名命令进行操作");
            System.out.println("添加商品到购物车: add");
            System.out.println("查询购物车上坪商品: query");
            System.out.println("修改商品购买数量: update");
            System.out.println("结果购买商品的金额： pay");
            Scanner sc = new Scanner(System.in);
            System.out.println("请您输入命令");
            String command = sc.next();
            switch(command) {
                case "add":
                    // 添加商品到购物车
                    addGoods(shopCar, sc);
                    break;
                case "query":
                    // 查询购物车商品展示
                    queryGoods(shopCar);
                    break;
                case "update":
                    // 修改商品购买数量
                    updateGoods(shopCar, sc);
                    break;
                case "pay":
                    // 结算金额
                    payGoods(shopCar);
                    break;
                default:
                    System.out.println("没有该功能");
            }
        }
    }
    /*
     *  完成商品添加到购物车的功能
     * */
    public static void addGoods(Goods[] shopCar, Scanner sc) {
        // 1.录入用户输入的购买的商品的信息
        System.out.println("请您输入购买商品的编号（不重复）");
        int id = sc.nextInt();
        System.out.println("请您输入购买商品的名称");
        String name = sc.next();
        System.out.println("请输入购买商品的数量");
        int buyNum = sc.nextInt();
        System.out.println("请输入购买商品的价格");
        double price = sc.nextDouble();

        // 2.把购买商品的信息封装成一个商品对象
        Goods g = new Goods();
        g.setId(id);
        g.setName(name);
        g.setBuyNum(buyNum);
        g.setPrice(price);

        // 3.把商品对象添加到购物车数组中去
        // shopCar = [null, null, null, ...]
        for (int i = 0; i < shopCar.length; i++) {
            if(shopCar[i] == null) {
                // 此位置没有元素存入，把新买的商品添加到此处即可
                shopCar[i] = g;
                break;
            }
        }
        System.out.println("添加完成");
    }

    /*
     *  查询购物车中的商品对象并展示
     * */
    public static void queryGoods(Goods[] shopCar) {
        System.out.println("查询购物车信息如下");
        System.out.println("编号\t\t名称\t\t价格\t\t购买数量");
        for (int i = 0; i < shopCar.length; i++) {
            Goods g = shopCar[i];
            if(g != null) {
                // 展示商品对象
                System.out.println(g.getId()+"\t\t"+g.getName()+"\t\t"+g.getPrice()+"\t\t"+g.getBuyNum());
            } else {
                // 遍历结束
                System.out.println("商品展示结束");
                break;
            }
        }
    }
    /*
     *  修改购物车中购买商品的数量
     * */
    public static void updateGoods(Goods[] shopCar, Scanner sc) {
        // 输入要修改的商品的id, 根据id查询出要修改的商品对象
        while (true) {
            System.out.println("请输入要修改的商品id");
            int id = sc.nextInt();
           Goods g = getGoodsById(shopCar, id);
            if(g == null) {
                // 没有该上坪
                System.out.println("对不起，没有购买该商品");
            } else {
                System.out.println("请您输入"+g.getName()+"的购买数量");
                int buyNUm = sc.nextInt();
                g.setBuyNum(buyNUm);
                queryGoods(shopCar);
                break;
            }
        }
    }
    /*
     *  通过id查询商品
     * */
    public static Goods getGoodsById(Goods[] shopCar, int id ) {
        for (int i = 0; i < shopCar.length; i++) {
          Goods g = shopCar[i];
            if(g != null) {
                // 判断这个商品对象的id是否是要找的
                if(g.getId() == id) {
                    return g;
                }
            } else {
                return null; // 找完了所有存在的商品，都没有找到
            }
        }
        return null; // 找完100个商品都没找到
    }
    public static void payGoods(Goods[] shopCar) {
        double totalPrice = 0;
        for (int i = 0; i < shopCar.length; i++) {
            Goods g =shopCar[i];
            if(g != null) {
                totalPrice += g.getPrice() * g.getBuyNum();
            } else {
                break;
            }
        }
        System.out.println("总价为"+totalPrice);
    }

}

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

区别	成员变量	布局变量
类中位置不同	类中、方法外	常见于方法中
初始化值不同	有默认初始化值	没有，使用之前需要完成赋值
内存位置不同	堆内存	栈内存
生命周期不同	随着对象的创建而存在，随着对象的消失而消失	随着方法的调用而存在，随着变量的销毁而消失
作用域		在归属的大括号内