面向对象编程

1.设计对象并使用

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

public class类名{                                                  

1.成员变量（代表属性,一般是名词)

2、成员方法（代表行为,一般是动词)

3、构造器

 4、代码块

5、内部类}

得到类的对象

类名对象名= new类名();

使用对象

访问属性:对象名.成员变量

访问行为:对象名.方法名(.….)

package com.createobject;
public class Tseat01 {
    public static void main(String[] args) {
        //创建汽车对象
        Car c=new Car();
        c.name="宝马";
        c.price=38.9;
        System.out.println(c.name);
        System.out.println(c.price);
        c.start();
        c.run();
        System.out.println("------------");
        Car c2=new Car();
        c.name="奔驰";
        c.price=39.9;
        System.out.println(c2.name);
        System.out.println(c2.price);
        c2.start();
        c2.run();
    }
}

package com.createobject;

public class Car {
    //成员变量
    String name;
    double price;
    //方法
    public void start(){
        System.out.println(name+"启动了");
    }
    public void run(){
        System.out.println("价格是："+price+"的"+name+"跑到很快");
    }
}

注意事项：1.类名首字母建议大写，且有意义，满足“驼峰模式”。

2.一个Java文件中可以定义多个class类，但只能一个类是public修饰，而且public修饰的类名必须成为代码文件名。实际开发中建议还是一个文件定义一个class类。3.

3.成员变量的完整定义格式是∶修饰符 数据类型 变量名称=初始化值;一般无需指定初始化值，存在默认值。

2.对象在内存中的运行机制

（1）对象放在堆内存中；

（2）.car c= new Car(; c变量名中存储的是对象在堆内存中的地址。

（3）成员变量(name、price)的数据放在对象中，存在于堆内存中。

注意:当堆内存中的对象，没有被任何变量引用（指向）时，就会被判定为内存中的“垃圾”。 Java存在自动垃圾回收器，会定期进行清理。

3.面向对象编程训练

模拟购物车模块：(1)模拟购物车模块的功能，需要实现添加商品到购物车中去，同时需要提供修改商品的购买数量，结算商品价格功能（请使用面向对象编程来解决）。

(2)让用户输入商品信息，并加入到购物车中去，且可立即查看购物车信息。

(3) 让用户输入商品id，找出对应的商品修改其购买数量

(4)当用户输入了pay命令后，需要展示全部购买的商品信息和总金额。

分析：

（1）购物车中的每个商品都是一个对象，需要定义一个商品类。

（2）购物车本身也是一个对象:可以使用数组对象代表它。

（3）完成界面架构，让用户选择操作的功能。

(4)需要让用户录入商品信息，创建商品对象封装商品信息。

(5)并把商品对象加入到购物车数组中去。

(6)查询购物车信息，就是遍历购物车数组中的每个商品对象。

(7)定义方法能够根据用户输入的id去购物车数组中查看是否存在该商品对象。存在返回该商品对象的地址，不存在返回null。

(8) 判断返回的对象地址是否存在，存在修改其购买数量，不存在就继续。

(9)定义求和变量，遍历购物车数组中的全部商品，累加其单价*购买数量。

package com.demo;

import java.util.Scanner;

public class shop {
    public static void main(String[] args) {
        //1.定义商品类
        //2.定义购物车对象，使用一个数组对象表示
        Goods [] shopCar=new Goods[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(shopCar,sc);
                case "query":
                    queryGoods(shopCar);
                    break;
                case "update":
                    updateGoods(shopCar,sc);
                    break;
                case "pay":
                    payGoods(shopCar);
                    break;
                default:
                    System.out.println("没有该功能");
            }
        }
    }


    public static void payGoods(Goods[] shopCar) {
        //定义一个求和变量
        queryGoods(shopCar);
        double money=0;
        //2.遍历购物车数组中对象
        for (int i = 0; i < shopCar.length; i++) {
           Goods g= shopCar[i];
           if(g!=null){
               money+=g.price*g.buynumber;
           }else {
               break;
           }
        }
        System.out.println("订单总金额"+money);
    }

    public static void updateGoods(Goods[] shopCar,Scanner sc) {
        //让用户输入要修改的id，然后根据id修改对象
        while (true) {
            System.out.println("请你输入要修改的商品id:");
            int id=sc.nextInt();
            Goods g=getGoodByid(shopCar,id);
            if(g==null){
                //没有该商品信息
                System.out.println("对不起，没有购买该商品");
            }else{
                //说明存在 修改
                System.out.println("请你输入"+g.name+"商品最新购买数量");
                int buynumber=sc.nextInt();
                g.buynumber=buynumber;
                System.out.println("修改完成");
                queryGoods(shopCar);
                break;
            }
        }
    }
    public static Goods getGoodByid(Goods[] shopCar,int id){
        for (int i = 0; i < shopCar.length; i++) {
            Goods g=shopCar[i];
            if (g!=null){
                if(g.id==id)
                {
                    return g;
                }else {
                    return null;//找完了全面存在的商品，都没有找到
                }
            }
        }
        return null;//代表找完了100中商品，没有找到想要id
    }
    //查询商品对象信息
    public static void queryGoods(Goods[] shopCar) {
        System.out.println("==================查询购物车信息如下=============");
        System.out.println("编号\t\t名称\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\t"+g.price+"\t\t\t"+g.buynumber);
            }else{
                //遍历结束
                break;
            }
        }
    }
//完成用户输入添加到购物车的功能
    public static void addGoods(Goods[] shopCar,Scanner sc) {
//录入用户输入的购买商品的信息
        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.把商品信息封装一个商品对象
        Goods g=new Goods();
        g.id=id;
        g.name=name;
        g.buynumber=buynumber;
        g.price=price;

        //3.把商品对象放到购物车数组中去
        for (int i = 0; i < shopCar.length; i++) {
            if(shopCar[i]==null){
                //说明此位置没有元素存入
                shopCar[i]=g;
                break;//因为商品成功存入  不需要继续找位置
            }
        }
        System.out.println("你的商品："+g.name+"添加到购物车");
    }
}

package com.demo;

public class Goods {
    int id;
    String name;
    double price;
    int buynumber;

}

4.构造器

定义在类中的，可以用于初始化一个类的对象，并返回对象的地址。

car c= new Car();

格式：

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

….}

无参数构造器（默认存在的)∶初始化对象时，成员变量的数据均采用默认值。

有参数构造器:在初始化对象的时候，同时可以接收参数为对象进行赋值。

package com.constructor;

import java.util.concurrent.Callable;

public class Test {
    public static void main(String[] args) {
        //通过构造器得到对象
        Car c=new Car();
        c.name="宝马";
        c.price=38.9;
        System.out.println(c.name);
        System.out.println(c.price);
        //调用有参数构造器
        Car c2=new Car("奔驰",39.8);
        System.out.println(c2.name);
        System.out.println(c2.price);

    }
}

package com.constructor;

public class Car {
    String name;
    double price;
    //无参数构造器
    public  Car(){
        System.out.println("==无参数的构造器被调用了==");
    }
    //有参数构造器
    public Car(String n,double p){
        System.out.println("==参数构造器被调用了==");
        name=n;
        price=p;
    }
}

注意事项：任何类定义出来，默认就自带了无参数构造器，写不写都有。

一旦定义了有参数构造器，那么无参数构造器就没有了，如果还想用无参数构造器，此时就需要自己手写一个无参数构造器了。

5.This关键字

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

作用：可以用于指定访问当前对象的成员变量、成员方法。

6.封装

面向对象的三大特征:封装，继承，多态。

封装:告诉我们，如何正确设计对象的属性和方法。

封装的原则:对象代表什么，就得封装对应的数据，并提供数据对应的行为。

一般建议对成员变量使用private(私有、隐藏)关键字修饰进〈private修饰的成员只能在当前类中访问)。

为每个成员变量提供配套public修饰的的getter、setter方法暴露其取值和赋值。

package com.encapsulation;

public class Test01 {
    public static void main(String[] args) {
        student s=new student();
        s.setAge(23);
        System.out.println(s.getAge());
    }
}

package com.encapsulation;

public class student {
    //1.成员变量，使用private修饰,只能在本类中访问
    private int age;
    //2.提供成套的getter和setter方法暴露
    public void setAge(int age){
        if(age>=0&&age<=200){
            this.age=age;
        }else{
            System.out.println("你的年龄数据有问题");
        }
    }
    public int getAge(){
        return age;
    }
}

7.javabean

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

书写要求：

成员变量使用private修饰。

提供成员变量对应的setXxx() l getXxx()方法。

必须提供一个无参构造器;有参数构造器是可写可不写的。

package com.javabean;

public class Test {
    public static void main(String[] args) {
        //1.无参数构造器创建对象封装一个用户信息
        user u1=new user();
        u1.setName("黑马吴彦祖");
        u1.setHeight(180.5);
        u1.setSalary(1100);
        System.out.println(u1.getName());
        System.out.println(u1.getHeight());
        System.out.println(u1.getSalary());
        //2.创建有参数构造器
        user u2=new user("黑马武大郎",156,3000);
        System.out.println(u2.getName());
        System.out.println(u2.getHeight());
        System.out.println(u2.getSalary());
    }
}

package com.javabean;

public class user {
    //1.成员变量使用private私有
    private String name;
    public double height;
    private double salary;
    //3.要求提供无参数构造器 有参数构造器可选

    public user() {
    }

    public user(String name, double height, double salary) {
        this.name = name;
        this.height = height;
        this.salary = salary;
    }

    //2.为变量提供setter和getter

    public String getName() {
        return name;
    }

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

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public double getSalary() {
        return salary;
    }

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

成员变量、局部变量

区别                        成员变量                                                  局部变量

类中位置不同          类中，方法外                  常见于方法中

初始化值不同          有默认值无需初始化       没有默认值，使用之前需要完成赋值

内存位置不同           堆内存                             栈内存

生命周期不同           随着对象的创建而存在随着对象的消失而消失                 随着方法的调用而存在，随着方法的运行结束而消失

作用域                                                               在所归属的大括号中

面向对象案例

模仿电影信息展示：使用面向对象编程，模仿电影信息的展示。

分析：一部电影是一个Java对象，需要先设计电影类，再创建电影对象。

三部电影对象可以采用数组存储起来。

依次遍历数组中的每个电影对象，取出其信息进行展示。

package com.demo;

public class Test {
    public static void main(String[] args) {
        //设计电影类
        //创建3个电影对象，封装电影的信息
        move m1=new move("《长津湖》",9.7,"吴京");
        move m2=new move("《我和我的父亲》",9.6,"吴京");
        move m3=new move("《扑水少年》",9.5,"王川");
        //定义一个电影类型的数组存储
        move movies[]=new move[3];
        movies[0]=new move("《长津湖》",9.7,"吴京");
        movies[1]=new move("《我和我的父亲》",9.6,"吴京");
        movies[2]=new move("《扑水少年》",9.5,"王川");
        //4.遍历数组中每个电影对象
        for (int i = 0; i < movies.length ; i++) {
            move m=movies[i];
            System.out.println("电影名:"+m.getName());
            System.out.println("得分："+m.getScore());
            System.out.println("主演："+m.getActor());
            System.out.println("------------------------");
        }

    }
}

package com.demo;

public class move {
    //成员变量
    private String name;
    private double score;
    private String actor;
    //3.


    public move() {
    }

    public move(String name, double score, String actor) {
        this.name = name;
        this.score = score;
        this.actor = actor;
    }
    //2.getter  setter

    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;
    }
}