学习Java的第七天

面向对象编程:

面向就是拿或找的意思

对象就是东西的意思

设计类并使用

在java中必须先设计类，才能设计对象

类(设计图)：是对象共同特征的描述，对象:是真实存在的具体实例

public class 类名(){

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

2.成员方法(代表行为，一般是动词)

3.构造器()

4.代码块

5.内部类

}

 如何使用对象?访问属性:对象名，成员变量   访问行为:对象名.方法名(...)

package com.itheima.createobject;

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

package com.itheima.createobject;

public class Test{
    public static void main(String[] args) {
        //目标;自己设计对象并使用
        //类名 对象名=new 类名（）;
        Car c=new Car();
        c.name="奔驰";
        c.price=39.78;
        System.out.println(c.name);
        System.out.println(c.price);
        c.start();
        c.run();
        Car c2=new Car();
        c2.name="宝马X3";
        c2.price=38.98;
        System.out.println(c2.name);
        System.out.println(c2.price);
        c2.start();
        c2.run();
    }
}

类和对象是什么?

类是共同特征的描述(设计图)  对象:是真实存在的具体实例

如何得到对象?

public class 类名{

1.成员变量(代表属性的，一般是名词)

2.成员方法(代表行为的，一般是动词)

}

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

拿到对象后能做什么?

对象.成员变量;

 对象.成员方法(...)

定义类的几个补充注意事项

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

英文首字母建议大写，且有意义，满足"驼峰模式"

一个java文件中可以定义多个class类，且只能一个类是public 修饰，而且public修饰的类名必须成为代码文件名

实际开发中建议还是一个文件定义一个class类

对象的成员变量的默认值规则

定义类有哪些建议，有什么需要注意的?

类名首字母建议大写，英文、有意义，满足驼峰模式，不能用关键字，满足标识符规定

一个代码文件中可以定义多个类，但是只能一个类是public修饰的

public 修饰的类名必须是java代码的文件名称

成员变量的格式是什么样的，有什么特点?

成员变量的完整格式是:修饰符  数据类型  变量名称=初始化值

一般无需指定初始化值，存在默认值

对象内存图

 对象放在哪个位置?

堆内存中

Car c=new Car();c变量名中存储的是什么？

存储的是对象在堆内存中的地址

成员变量(name、price)的数据放在哪里，存放在哪个位置?

对象中，存在于堆内存中

package com.itheima.memory;

public class Student {
    String name;
    char sex;
    String hobby;
    public void study(){
        System.out.println("名称:"+name+",性别"+sex
        +",爱好:"+hobby+"的学生，开始学习了!");
    }
}

package com.itheima.memory;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name="小明";
        s1.sex='男';
        s1.hobby="游戏,睡觉,听课";
        s1.study();
        Student s2=s1;
        s2.hobby="爱提问";
        System.out.println(s2.name);
        System.out.println(s2.sex);
        System.out.println(s1.hobby);
        s2.study();
    }
}

垃圾回收

注意:在堆内存中的类对象或数组对象，没有被任何变量引用(指向)时，就会被判定为内存中的"垃圾"

java存在自动垃圾回收器,会定期进行清理

购物车中的每个商品可以看成什么,需要先做什么准备?

可以看成一个个的对象

定义商品类:Goods,后期创建对象代表一个商品信息

购物车对象用什么表示的,可以用做什么?

购物车可以使用商品类型的数组对象表示,可以用于存放商品对象.

Goods[] shopCar=new Goods[100];

package com.itheima.demo;
import java.util.Scanner;
public class ShopCarTest {
    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);
                    break;
                case "query":
                    //查询购物车商品展示
                    queryGoods(shopCar);
                    break;
                case "update":
                    //修改商品的购买数量
                    updateGoods(shopCar,sc);
                    break;
                case "pay":
                    //结算金额
                    pay(shopCar);
                    break;
            }
        }
    }
    public static void pay(Goods[] shopCar) {
        queryGoods(shopCar);
        double money=0;
        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查询出要修改的商品对象
        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 buyNumber=sc.nextInt();
            g.buyNumber=buyNumber;
            System.out.println("修改完成!");
            queryGoods(shopCar);

        }
    }
    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;
    }
    /**
      查询购物车中的商品对象信息，并展示出来
     */
    public static void queryGoods(Goods[] shopCar) {
        System.out.println("=====查询购物车信息如下=====");
        System.out.println("编号\t\t\t名称\t\t\t价格\t\t\t购买数量");
        //shopCar=[g1,g2,g3,null,null,...]
        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) {
        //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.把这个购买商品的信息封装成一个商品对象
        //通过new关键字将获取的id存入对象名的id中
        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++) {
            //如果shopCar中的元素有一个是null
            if(shopCar[i]==null){
                //说明此位置没有元素存入，把我们新买的商品添加到此处即可
                shopCar[i]=g;
                break;//结束，因为商品已经成功存入了，不需要继续找位置了
            }
        }
        System.out.println("您的商品:"+g.name+"已经添加到购物车了");
    }
}

构造器:

真正知道对象具体是通过什么代码完成的?

能够掌握为对象属性赋值的其他写法?

构造器的作用?用于初始化一个类的对象，并返回对象的地址

构造器的定义格式:修饰符  类名(形参列表){      

                                ......

                                }

初始化对象的格式:

类型 变量名称=new 构造器;

Car  c=new Car();

构造器的分类:

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

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

package com.itheima.construtor;

import static java.lang.System.out;

public class Car {
    String name;
    double price;
    //无参构造器
    public Car(){
        out.println("无参数构造器被触发执行");
    }
    
    public Car(String n,double p){
        out.println("有参数构造器被触发执行");
        name=n;
        price=p;
    }
}
package com.itheima.construtor;
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("宝马x6",80);
        System.out.println(c2.name);
        System.out.println(c2.price);
    }
}
注意事项:

任何类定义出来，确认就自带了无参数构造器，写不写都有

一旦定义了有参数构造器，无参数构造器就没有了，此时就需要自己写一个无参构造器了

构造器的作用:

初始化类的对象，并返回对象的地址

构造器有几种，各自的作用是什么?

无参数构造器:初始化的对象时，成员变量的数据均采用默认值

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

构造器有哪些注意事项?

任何类定义出来，默认就启动了自带的无参数构造器，写不写都有

一旦定义了有参数构造器，无参数构造器就没有了，此时就需要自己写一个无参数构造器了

this关键字：

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

this在有参数构造器中的用法

package com.itheima.thisDemo;

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

package com.itheima.thisDemo;

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

this关键字的作用?

代表当前对象的地址

this关键字在构造器中，成员方法可以做什么?

可以用于访问当前对象的成员变量

package com.itheima.thisDemo;

public class Car {
    String name;
    double price;
    public Car(String name,double price){
        this.name=name;
        this.price=price;
    }
    public void goWith(String name){
        System.out.println(this);
        System.out.println(this.name+"正在和"+name+"比赛!");
    }
}

package com.itheima.thisDemo;

public class Test {
    public static void main(String[] args) {
        Car c=new Car("奔驰",45);
        System.out.println(c.name);
        System.out.println(c.price);
        System.out.println("-------------");
        c.goWith("宝马");
    }
}
封装:

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

什么是封装?合理隐藏，合理暴漏

如何封装呢？一般对成员变量使用private(私有)关键字修饰进行隐藏，pricate修饰后该成员变量就只能在当前类中访问

提供public 修饰的公开的getter、setter方法暴露其取值和赋值

封装是什么,一般封装怎样体现出来?

面向对象的三大特征之一,合理隐藏，合理暴漏

一般的成员变量使用private隐藏起来

通过getter和setter方法暴漏其访问

封装有什么好处?

加强了程序代码的安全性

适当的封装可以提升开发效率，同时可以让程序更容易理解和维护

package com.itheima.encapaulation;

public class Student {
    private int age;
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        if(age>=0&&age<=200){
            this.age=age;
        }else{
            System.out.println("年龄不符合");
        }

    }
}

package com.itheima.encapaulation;

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

标准javaBean

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

标准javaBean须满足如下需求:

成员变量使用private修饰

提供每一个成员变量对应的setXxx()\getXxx()

必须提供一个无参构造器

package com.itheima.javabean;

public class User {
    //成员变量似有
    private String name;
    private double height;
    private double salary;
    //无参构造器
    public User() {
    }
    //有参构造器
    public User(String name, double height, double salary) {
        this.name = name;
        this.height = height;
        this.salary = salary;
    }
    //必须提供成套的getter setter方法暴露的成员变量的取值和赋值
    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;
    }
}

package com.itheima.javabean; public class Test {

public static void main(String[] args) {

//根据无参数构造器创建对象

User u=new User();

u.setName("黑马吴彦祖");

u.setHeight(100.5);

u.setSalary(1000);

System.out.println(u.getName());

System.out.println(u.getHeight());

System.out.println(u.getSalary());

//调用有参数构造器创建对象

User u1=new User("黑马关之琳",169.5,1000);

System.out.println(u1.getName());

System.out.println(u1.getSalary());

System.out.println(u1.getSalary()); } }

成员变量和局部变量的区别: