Java - day7 - 面向对象

面向对象编程的例子：

import java.util.Random;
import java.util.Scanner;

public class AS {
    public static void main(String[] args) {
        //1、创建一个扫描器对象，用于接收用户输入的数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入您的年龄:");
        int age = sc.nextInt();
                System.out.println(age);
//2、得到一个随机数对象，用于得到随机数
        Random r = new Random();
        int data = r.nextInt(10)+1 ; //生成1-10之间的随机数system.out.print1n(data);
    }
}

类是什么：

• 类(设计图)︰是对象共同特征的描述;
• 对象:是真实存在的具体实例。
• 结论:在Java中，必须先设计类，才能创建对象并使用。

如何设计类

public class 如何设计类_类名 {
        //1、成员变量（代表属性,一般是名词)
       // 2、成员方法（代表行为,一般是动词)
      // 3、构造器
    //4、代码块
    // 5、内部类
}

例子：

public class car {
    //属性（成员变量)
    String name;
    double price;

    //行为（方法)
    public void start() {
    }

    public void run() {

    }
}

如何得到类的对象

• 类名对象名= new类名();
• Car c= new Car();

如何使用对象

• 访问属性:对象名.成员变量
• 访问行为:对象名.方法名(...)

定义类的补充注意事项

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

实例：

package aaa.dao;
public class good {
    int id;//编号
    String name;//名称
    double price;
    int buyNumber;
}

package aaa.dao;
import java.util.Scanner;

public class car {
    public static void main(String[] args) {
        //1、定义商品类，用于后期创建商品对象
        //2、定义购物车对象:使用一个数组对象表示。
        good[] car = new good[100];
        // 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(car,sc);
                    break;
                case "query": //查询购物车商品展示
                    queryGoods(car);
                    break;
                case "update"://修改商品的购买数量
                    updateGoods(car,sc);
                    break;
                case "pay" ://结算金额
                    payGoods(car);
                    break;
                default:
                    System.out.println("没有该功能!");
            }
        }
    }

    public static void payGoods(good[] car) {
        queryGoods(car);
       //1、定义一个求和变量累加金额
        double money = 0;
       //2、遍历购物车数组中的全部商品对象，累加单价*数量
        //[g1,g2,null, ....]
        for (int i = 0; i < car.length; i++) {
            good g = car[i];
            if(g != null){
                money += (g.price * g.buyNumber);
            }else {
                break;
            }
        }
        System.out.println("订单总金额:" + money);
    }

    public static void updateGoods(good[] car,Scanner sc)  {
        //让用户输入要修改商品的id,根据id查询出要修改的商品对象。
        while (true) {
            System.out.println("请您输入要修改的商品id:" );
            int id = sc.nextInt();
            good g = getGoodsById(car,id);
            if(g == null){
                //没有该商品
                System.out.println("对不起，没有购买商品!");
            }else {//说明存在该商品对象，可以修改它了
                System.out.println("请您输入:" + g.name+"商品最新购买数量:");
                int buyNumber = sc.nextInt();
                g.buyNumber = buyNumber;
                System.out.println("修改完成!");
                queryGoods(car);
                break;
            }
        }
    }

    public static good getGoodsById(good[] car ,int id) {
        //car = [g1, g2, g3, null, null, ...]
        for (int i = 0; i < car.length; i++) {
            good g = car[i];
            if (g != null) {
                //判断这个商品对象的id是否是我们要找的
                if (g.id == id) {
                    return g;
                }
            }else{
                return null;  //找完了全面存在的商品，都没有找到!
            }
        }
        return null;  //代表找完了10日个商品都没有找到id一样的商品
    }

    public static void queryGoods(good[] car) {
        System.out.println("============查询购物车信息如下=============");
        System.out.println("编号\t\t名称\t\t\t价格\t\t\t购买数量");
        //shopCar = [g1,g2，g3, null,null, ...]
        for (int i = 0; i < car.length; i++) {
            good g = car[i];
            if(g != null){//展示这个商品对象
                System.out.println(g.id +"\t\t" + g.name+" \t\t\t" + g.price +"\t\t\t" + g.buyNumber);
            }else {
                break; //遍历结束
            }
        }
}

    public static void addGoods(good[] car,Scanner sc) {
        //1、录入用户输入的购买商品的信息。
        System.out.println("请您输入购买商品的编号（不重复):");int id = sc.nextInt();
        System.out.println("请您输入购买商品的名称:");
        String name = sc.next();
        System.out.println("请您输入购买商品的数量:");
        int buyNumber = sc.nextInt();
        System.out.println("请您输入购买商品的价格: ");
        double price = sc.nextDouble();

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

        //3、把这个商品对象添加到购物车数组中去。
        //car = [a, a2,null, .........]
        for (int i = 0; i < car.length; i++) {
            if(car[i] == null){  //说明此位置没有元素存入，把我们新买的商品添加到此处即可
                car[i] = g;
                break;//结束，因为商品已经成功存入了，不需要继续找位置了
            }
        }
        System.out.println("您的商品:" + g.name +"添加到购物车完成! ");
    }
}

学构造器的目的?

• 真正知道对象具体是通过调用什么代码得到的。
• 能够掌握为对象赋值的其他简便写法。
• 为以后学习面向对象编程的其他内容做支撑。

简单来说：无参构造器就是不写参数的，默认的；有参构造器就是有带接受参数的。

this关键字是什么

• 可以出现在构造器、方法中
• 代表当前对象的地址。

封装

• 面向对象的三大特征:封装，继承，多态。
• 封装:告诉我们，如何正确设计对象的属性和方法。
• 封装的原则:对象代表什么，就得封装对应的数据，并提供数据对应的行为。

理解封装思想有啥好处?

• 有什么事，找对象，调方法就行，编程变得很简单。

例如：

• String:代表字符串对象 —— 拥有操作字符串的很多方法
• Socket:代表一个网络连接 —— 可以连接别人，发消息，收消息

如何进行封装更好?

• 一般建议对成员变量使用private(私有、隐藏)关键字修饰（private修饰的成员只能在当前类中访问)
• 为每个成员变量提供配套public修饰的的getter、setter方法暴露其取值和赋值。

JavaBean

• 也可以称为实体类，其对象可以用于在程序中封装数据。

标准JavaBean须满足如下书写要求:

• 成员变量使用private修饰。
• 提供成员变量对应的setXxx() / getXxx()方法。
• 必须提供一个无参构造器;有参数构造器是可写可不写的,

实例：

package movie;

public class Movie {
    //成员变量
    private String name;
    private double score;
    private String actor;

    public Movie() {
    }

    public Movie(String name, double score, String actor) {
        this.name = name;
        this.score = score;
        this.actor = actor;
    }

    public String getName() {
        return name;
    }

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

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }
}

package movie;

public class Test {
    public static void main(String[] args) {
        //1、设计电影类
        // 2、创建3个电影对象，封装电影的信息吧
        //3、定义一个电影类型的数组，存储3部电影对象
        Movie[] movies = new Movie[3];
        movies[0]= new Movie("《长津湖》",9.7 ,"吴京");
        movies[1]= new Movie("《duan津湖》",9.0 ,"xin京");
        movies[2]= new Movie("《长湖》",5.7 ,"uy京");

        //4、遍历数组中的每个电影对象，然后获取它的信息展示出来
        for (int i = 0; i < movies.length; i++){
            Movie m = movies[i];
            System.out.println("电影名:" +m.getName());
            System.out.println("得分:" + m.getScore());
            System.out.println("主演: " + m.getActor());
            System.out.println( "---------------");
        }
    }
}

结论:数组中存储的元素并不是对象本身，而是对象的地址。