文章目录
1. 设计对象并使用
1.1 设计类，创建对象并使用
-
类： 是相同事物共同特征的描述（设计图）
-
对象： 是类的具体实例（万物皆对象）
-
如何设计类？
public class类名{
~~~~~~~ 1.成员变量（代表属性，一般是名词）
~~~~~~~ 2.成员方法（代表行为，一般是动词）
~~~~~~~ 3.构造器
~~~~~~~ 4.代码块
~~~~~~~ 5.内部类
} -
如何创建对象？
类名 对象名 = new 类名() -
访问对象信息
对象.成员变量;
对象.成员方法(...)
1.2 定义类的几个补充注意事项
- 类名首字母建议大写，且有意义，满足“驼峰模式”，不能用关键字，满足标志符模式
- 一个Java文件中可以定义多个class类，但
只能一个类是public修饰，而且public修饰的类名必须成为代码文件名。实际开发中建议一个文件定义一个class类 - 成员变量的完整定义格式是：
修饰符 数据类型 变量名称 = 初始值;一般无需指定初始化值，存在默认值
| 数据类型 | 明细 | 默认值 |
|---|---|---|
| 基本类型 | byte、short、char、int、long | 0 |
| 基本类型 | float、double | 0.0 |
| 基本类型 | boolean | false |
| 引用类型 | 类、接口、数组、String | null |
2. 对象内存图
- 对象放在那个位置？
堆内存 - Car c = new Car()，c变量名中存储的是什么？
存储的是对象在堆内存中的地址 - 成员变量（namw、price）的数据放在哪里，存于哪个位置？
对象中，存在于堆内存中
- 垃圾回收
当堆内存中的对象，没有被任何变量引用（指向）时，就会被判定为内存中的“垃圾”；Java存在自动垃圾回收器，会定期进行清理
3. 面向对象编程训练:模拟购物车
public class Goods {
int id;
String name;
double price;
int buyNumber;
}
import java.util.Scanner;
public class ShopCarTest {
public static void main(String[] args) {
boolean flag = true;
//1.定义商品类
//2.定义购物车对象
Goods[] shopCar = new Goods[100];
//3.搭建操作架构
while (flag) {
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,sc);
flag = false;
break;
default:
System.out.println("没有该功能!");
}
}
}
//商品添加到购物车
private static void addGoods(Goods[] shopCar,Scanner sc) {
//录入用户输入的商品信息
System.out.println("请输入商品的编号:");
int id = sc.nextInt();
System.out.println("请输入商品的名称:");
String name = sc.next();
System.out.println("请输入商品的价格:");
double price = sc.nextDouble();
System.out.println("请输入商品的数量:");
int buyNumber = sc.nextInt();
Goods g = new Goods();
g.id = id;
g.name = name;
g.price = price;
g.buyNumber = buyNumber;
for (int i = 0; i < shopCar.length; i++) {
if(shopCar[i] == null){
shopCar[i] = g;
break;
}
}
System.out.println("商品" + g.name + "已添加到购物车");
}
//查询购物车信息
private static void queryGoods(Goods[] shopCar) {
System.out.println("=====查询购物车信息如下=====");
System.out.println("编号\t\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" + g.price + "\t\t" +g.buyNumber);
}else {
break;
}
}
}
//修改购买商品的数量
private static void updateGoods(Goods[] shopCar,Scanner sc) {
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 buyNumber = sc.nextInt();
g.buyNumber = buyNumber;
System.out.println("修改完成!");
queryGoods(shopCar);
break;
}
}
}
public static Goods getGoodsByid(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一样的商品
}
//求总金额
private static void payGoods(Goods[] shopCar,Scanner sc) {
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);
}
}
4. 构造器
作用： 定义在类中的，可以用于初始化一个类的对象，并返回对象的地址
格式：修饰符 类名(形参列表){.....}
调用构造器得到对象的格式：类 变量名称 = new 构造器
分类和作用：
- 无参数构造器(默认存在的)：初始化对象时，成员变量的数据均采用默认值
- 有参数构造器：初始化对象时，同时可以接收参数作为对象进行赋值
注意事项：
- 任何类定义出来，默认就自带了无参数构造器，写不写都有
- 一旦定义了有参数构造器，那么无参数构造器就没有了，如果还想用无参数构造器，此时就需要自己手写一个无参数构造器了
public class Car {
String name;
double price;
public void start(){
System.out.println(name + "启动了");
}
public void run(){
System.out.println("价格是:" + price + "的" + name + "跑的很快");
}
//无参数构造器
public Car(){
System.out.println("这是无参数构造器!");
}
//有参数构造器 (暂无this关键字)
public Car(String n,double p){
System.out.println("这是有参数构造器!");
name = n;
price = p;
}
}
public class Test1 {
public static void main(String[] args) {
//创建汽车对象
Car c1 = new Car();
c1.name = "宝马";
c1.price = 38.9;
System.out.println(c1.name);
System.out.println(c1.price);
c1.start();
c1.run();
System.out.println("===============");
Car c2 = new Car("奔驰",41.7);
System.out.println(c2.name);
System.out.println(c2.price);
c2.start();
c2.run();
}
}
5. this关键字
- 可以出现在构造器、方法中
- 代表当前对象的地址
- 可以用于指定当前对象的成员变量、成员方法
public class Car {
String name;
double price;
public Car(){
System.out.println("这是无参数构造器中的this: " + this);
}
public void run(){
System.out.println("方法中的this: " + this);
}
//this出现在有参数构造器中的用法
public Car(String name,double price){
this.name = name;
this.price = price;
}
//this出现在成员方法中的用法
public void goWith(String name){
System.out.println(this.name +"正在和"+ name + "一起比赛!");
}
}
public class Test1 {
public static void main(String[] args) {
Car c = new Car();
c.run();
System.out.println(c);
System.out.println("-------------");
Car c0 = new Car("奔驰",39.8);
System.out.println(c0.name);
System.out.println(c0.price);
System.out.println("-------------");
c0.goWith("宝马");
}
}
//这是无参数构造器中的this: Car@6cd8737
//方法中的this: Car@6cd8737
//Car@6cd8737.
//-------------
//奔驰
//39.8
//-------------
//奔驰正在和宝马一起比赛!
6. 封装
封装思想概述
- 面向对象的三大特征：
封装、继承、多态 - 封装： 如何正确设计对象的属性和方法
- 封装原则： 对象代表什么，就得封装对应的数据，并提供数据对应的行为
如何更好地封装
- 一般建议对成员变量使用
private(私有、隐藏)关键字修饰进（private修饰的成员只能在当前类中访问） - 为每个成员变量提供配套public修饰的
getter、setter方法暴露其取值和赋值
7. 标准 JavaBean
JavaBean 也可以称为实体类（例如学生类，老师类，票类）——创建对象 + 封装数据
书写要求：
- 成员变量使用
private修饰 - 提供成员变量对应的
setXxx()/getXxx()方法 - 必须提供
一个无参数构造器；有参数构造器是可写可不写的
8. 补充知识：成员变量、局部变量区别
| 区别 | 成员变量 | 局部变量 |
|---|---|---|
| 代码位置不同 | 类中,方法外 | 常见于方法中 |
| 初始化值不同 | 有默认值,无需初始化 | 没有默认值,使用之前需要完成赋值 |
| 内存位置不同 | 堆内存 | 栈内存 |
| 生命周期不同 | 随着对象的创建而存在,随着对象的消失而消失 | 随着方法的调用而存在,随着方法的运行结束而消失 |
| 作用域 | 在所归属的大括号中 |
9. 面向对象编程(oop) 综合案例
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;
}
//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;
}
}
public class TestMovie {
public static void main(String[] args) {
//定义一个电影类型的数组,存储3部电影对象
Movie[] movies = new Movie[3];
movies[0] = new Movie("《长津湖》",9.7,"吴京");
movies[1] = new Movie("《我和我的父辈》",9.6,"吴京");
movies[2] = new Movie("《五个扑水少年》",9.5,"王川");
//遍历数组
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());
}
}
}
5675
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
