目录
一.设计对象并使用
1.设计类，创建对象并使用
类是什么?
类(设计图)︰是对象共同特征的描述;
对象:是真实存在的具体实例。
结论:在Java中，必须先设计类，才能创建对象并使用。
如何设计类
public class类名{
1、成员变量（代表属性,一般是名词)
2、成员方法（代表行为,一般是动词)
3、构造器（后几节再说)
4、代码块（后面再学)
5、内部类(后面再学)
}
//Car.java
package com.wjh.createObject;
public class Car {
/*
成员变量
*/
String name;
double price;
/*
方法
*/
public void start(){
System.out.println(name+"启动了");
}
public void run(){
System.out.println("价格是："+price+"W的"+"跑的很快");
}
}
//Test1.java
package com.wjh.createObject;
/* 目标：
* 学会使用对象并使用
*
* */
public class Test1 {
public static void main(String[] args) {
//创建汽车对象
Car c = new Car(); //类名 对象名 = new 类名();
c.name = "兰博基尼"; //给属性赋值
c.price = 398.4; //给属性赋值
System.out.println(c.name); //兰博基尼
System.out.println(c.price); //398.4
c.start(); //访问c对象的行为 //兰博基尼启动了
c.run(); //访问c对象的行为 //价格是：398.4W的跑的很快
System.out.println("---------------------");
Car c2 = new Car();
c2.name = "劳斯莱斯";
c2.price = 152.5;
System.out.println(c2.name); //劳斯莱斯
System.out.println(c2.price); //152.5
c2.start(); //劳斯莱斯启动了
c2.run(); //价格是：152.5W的跑的很快
}
}
//Student.java
package com.wjh.createObject;
public class Student {
//属性（成员变量）
String name;
int age;
String sex;
int sleepRoom;
public void room(){
System.out.println(age+"的"+name+"在"+sleepRoom+"宿舍");
}
public void mess(){
//行为（方法）
System.out.println(name+"的信息：");
System.out.println(age+"岁"+" "+"性别:"+sex);
}
}
//Test.java
package com.wjh.createObject;
/* 目标：
* 学会使用对象并使用
*
* */
public class Test1 {
public static void main(String[] args) {
Student s = new Student();
s.name = "吊毛";
s.sex = "男";
s.sleepRoom = 5664;
s.age = 18;
s.room();
s.mess();
System.out.println("-----------------------");
Student s2 = new Student();
s2.name = "周义";
s2.sex = "女";
s2.sleepRoom = 6458;
s2.age = 20;
s2.room();
s2.mess();
}
}
print：
18的吊毛在5664宿舍
吊毛的信息：
18岁 性别:男
-----------------------
20的周义在6458宿舍
周义的信息：
20岁 性别:女2.定义类的几个补充注意事项
定义类的补充注意事项
类名首字母建议大写，且有意义，满足“驼峰模式”。
一个Java文件中可以定义多个class类，但只能一个类是public修饰，而且public修饰的类名必须成为代码文件名。
实际开发中建议还是一个文件定义一个class类。
成员变量的完整定义格式是: 修饰符 数据类型 变量名称=初始化值 ;一般无需指定初始化值，存在默认值。
默认值的规则：
byte short int long 0
double float 0.0
boolean false
String null 
二.对象内存图
1.多个对象的内存图
Student.java
package com.wjh.createObject;
public class Student {
public String name; //默认值：null
boolean flag;
}
class animal {
}
class Dog{
}
Test1.java
package com.wjh.createObject;
/* 目标：
*
*
* */
public class Test1 {
public static void main(String[] args) {
//1.类名首字母建议大写，且有意义，满足“驼峰模式”。
//2.一个Java文件中可以定义多个class类，但只能一个类是public修饰，而且public修饰的类名必须成为代码文件名。
//实际开发中，建议一个代码文件只定义一个类
//3.成员变量的完整定义格式是: 修饰符 数据类型 变量名称=初始化值 ;一般无需指定初始化值，存在默认值。
Student s = new Student();
System.out.println(s); //输出一串地址
System.out.println(s.flag); //输出该地址中flag的值
}
}
2.两个变量指向同一个对象内存图
Test1.java
package com.wjh.createObject;
/* 目标：
*理解两个变量指向同一个对象内存运行机制
* */
public class Test1 {
public static void main(String[] args) {
Student s1 = new Student();
s1.name = "周扒皮";
s1.sex = '男';
s1.hobby = "吃奥利给,看美女！";
s1.study();
//把s1变量赋值给一个学生类型的变量s2
Student s2 = s1; //同样的变量类型可以赋值
System.out.println(s2);
System.out.println(s1);
s2.hobby = "男同";
System.out.println(s2.name);
System.out.println(s2.sex);
System.out.println(s1.hobby);
s2.study();
}
}
Student.java
package com.wjh.createObject;
public class Student {
String name;
char sex;
String hobby;
public void study(){
System.out.println("名字："+name+",性别"+sex+",爱好"+hobby+",开始学习了");
}
}
名字：周扒皮,性别男,爱好吃奥利给,看美女！,开始学习了
com.wjh.createObject.Student@5b480cf9
com.wjh.createObject.Student@5b480cf9
周扒皮
男
男同
名字：周扒皮,性别男,爱好男同,开始学习了
垃圾回收
注意:当堆内存中的对象，没有被任何变量引用（指向）时，就会被判定为内存中的“垃圾”。
面向对象编程训练:模拟购物车模块
1.需求分析、架构搭建
需求: 模拟购物车模块的功能，需要实现添加商品到购物车中去，同时需要提供修改商品的
购买数量，结算商品价格功能（请使用面向对象编程来解决）。
分析 (1)购物车中的每个商品都是一个对象，需要定义一个商品类。
(2)购物车本身也是一个对象:可以使用数组对象代表它。
(3)完成界面架构，让用户选择操作的功能。
2.添加商品到购物车、查看购物车信息
需求: 让用户输入商品信息，并加入到购物车中去，且可立即查看购物车信息。
分析: 需要让用户录入商品信息，创建商品对象封装商品信息。
并把商品对象加入到购物车数组中去。
查询购物车信息，就是遍历购物车数组中的每个商品对象。
3.修改购买数量
4.结算金额
shopTest.java
package com.wjh.goShop;
import java.util.Scanner;
public class shopTest {
public static void main(String[] args) {
//1.定义商品类，用于后期创建商品对象。
//2.定义购物车对象：使用一个数组对象表示。
Goods[] shopCar = new Goods[100]; //商品类型的数组，长度是100 [null, null, ... , 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 "1":
case "add": //添加商品到购物车
addGoods(shopCar,sc);
break;
case "2":
case "query": //查询购物车的商品
queryGoods(shopCar);
break;
case "3":
case "update": //修改商品购买数量
updateShopCount(shopCar,sc);
break;
case "4":
case "pay": //结算购买商品总价
addShopPay(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 buyCount = sc.nextInt();
System.out.println("请输入商品的价格：");
double price = sc.nextDouble();
//2.把这些购买商品的信息封装成一个商品对象
Goods g = new Goods();
g.id = id;
g.name = name;
g.buyCount = buyCount;
g.price = price;
//3.把这个商品对象添加到数组中去
//shopCar = [a, a1, null, ..., null]
//索引： i
for (int i = 0; i < shopCar.length; i++) {
if(shopCar[i] == null){
//此位置为null，说明此位置没有元素，把我们新买的商品添加到此处
shopCar[i] = g;
break; //结束:因为商品已经占到位置了
}
}
System.out.println("您的商品" + g.name + "添加成功");
System.out.println();
}
/**
查询购物车中的商品对象信息，并展示出来
*/
private static void queryGoods(Goods[] shopCar) {
System.out.println("=============查询到购物车商品如下=============");
System.out.println("编号:\t\t名称\t\t\t数量\t\t\t价格");
System.out.println();
//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\t" + g.name+"\t\t\t" + g.buyCount + "\t\t\t" + g.price);
}else {
//结束这个商品
break;
}
}
System.out.println();
}
/**
完成商品的购买数量
*/
private static void updateShopCount(Goods[] shopCar, Scanner sc) {
//让用户输入要修改商品的id，根据id查询出要修改的商品对象
while (true) {
System.out.println("请输入商品的id：");
int id = sc.nextInt();
Goods g = GetGoodsId(shopCar,id);
if(g == null){
//没有该商品
System.out.println("对不起，没有该商品！");
}else{
//说明存在该商品对象
System.out.println("请您输入商品"+g.name+"最新的购买数量：");
int buyCount = sc.nextInt();
g.buyCount = buyCount; //重新赋值把他替换掉
System.out.println("修改完成！");
queryGoods(shopCar);
break;
}
}
System.out.println();
}
public static Goods GetGoodsId(Goods[] shopCar,int id){
//shopCar = [g1, g2, g3, null, null, ...]
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个商品都没有找到id一样的商品
}
/**
完成商品的购物车结算金额
*/
private static void addShopPay(Goods[] shopCar) {
double CarCount=0;
for (int i = 0; i < shopCar.length; i++) {
Goods g = shopCar[i];
if(g != null) {
CarCount += (g.price * g.buyCount);
}else{
break;
}
}
queryGoods(shopCar);
System.out.println("您的购物车总金额为："+CarCount+"元");
System.out.println();
}
}
Goods.java
package com.wjh.goShop;
public class Goods {
int id; //编号
String name; //名称
double price; //价格
int buyCount; //数量
}
控制台：
请您选择如下命令进行操作：
添加商品到购物车：add
查询购物车的商品：query
修改商品购买数量：update
结算购买商品总价：pay
请您输入命令：
1
请您输入商品的编号（不重复）：
1
请您输入商品的名称：
hs'
请您输入商品的数量：
15
请输入商品的价格：
10.2
您的商品hs'添加成功
请您选择如下命令进行操作：
添加商品到购物车：add
查询购物车的商品：query
修改商品购买数量：update
结算购买商品总价：pay
请您输入命令：
1
请您输入商品的编号（不重复）：
2
请您输入商品的名称：
jk
请您输入商品的数量：
1100
请输入商品的价格：
15.99
您的商品jk添加成功
请您选择如下命令进行操作：
添加商品到购物车：add
查询购物车的商品：query
修改商品购买数量：update
结算购买商品总价：pay
请您输入命令：
2
=============查询到购物车商品如下=============
编号: 名称 数量 价格
1 hs' 15 10.2
2 jk 1100 15.99
请您选择如下命令进行操作：
添加商品到购物车：add
查询购物车的商品：query
修改商品购买数量：update
结算购买商品总价：pay
请您输入命令：
3
请输入商品的id：
2
请您输入商品jk最新的购买数量：
500
修改完成！
=============查询到购物车商品如下=============
编号: 名称 数量 价格
1 hs' 15 10.2
2 jk 500 15.99
请您选择如下命令进行操作：
添加商品到购物车：add
查询购物车的商品：query
修改商品购买数量：update
结算购买商品总价：pay
请您输入命令：
4
=============查询到购物车商品如下=============
编号: 名称 数量 价格
1 hs' 15 10.2
2 jk 500 15.99
您的购物车总金额为：8148.0元
请您选择如下命令进行操作：
添加商品到购物车：add
查询购物车的商品：query
修改商品购买数量：update
结算购买商品总价：pay
请您输入命令：
三.构造器
构造器的作用
定义在类中的，可以用于初始化一个类的对象，并返回对象的地址。
构造器的格式
修饰符 类名(形参列表){
......
}
public class Car {
......
//无参数构造器
public Car(){
......
}
//有参数构造器
public Car(String n, double p){
......
}
}Car c = new Car(); //Car();就是无参构造器调用构造器得到对象的格式
类 变量名称 = new 构造器;Car c = new Car();Car c1 = new Car("奔驰"，39.8);构造器的分类和作用
1.无参数构造器（默认存在的)∶初始化对象时，成员变量的数据均采用默认值。
2.有参数构造器:在初始化对象的时候，同时可以接收参数为对象进行赋值。
Test.java
package com.wjh.constructor;
/*
目标：认识构造器，明白两种类型的构造器的作用
*/
public class Test {
public static void main(String[] args) {
//通过调用构造器得到对象
Car c = new Car(); //调用的无参数构造器
System.out.println(c.name); //null(默认值)
System.out.println(c.price); //0.0
System.out.println();
c.name = "宝马";
c.price = 39.9;
System.out.println(c.name); //宝马
System.out.println(c.price); //39.9
System.out.println();
//调用有参数构造器
Car c1 = new Car("奔驰",35.4);
System.out.println(c1.name); //奔驰
System.out.println(c1.price); //35.4
}
}
Car.java
package com.wjh.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;
}
}
控制台：
======无参数构造器被调用了======
null
0.0
宝马
39.9
======有参数构造器被调用了======
奔驰
35.4
进程已结束，退出代码为 0
构造器的注意事项
任何类定义出来，默认就自带了无参数构造器，写不写都有。
一旦定义了有参数构造器，那么无参数构造器就没有了，如果还想用无参数构造器，此时就需要自己手写一个无参数构造器了。
四.this关键字
this关键字是什么
可以出现在构造器、方法中
代表当前对象的地址。
public class Car {
public Car(){
system.out.print1n( "this在构造器中:" + this );
}
public void run(){
system.out.print1n( "this在方法中:" + this);
}
}
public class Test2{
public static void main( String[] args){
Car c = new Car();
c.run();
system.out.println(c);
}
}
Test.java
package com.wjh.thisDemo;
/*
目标：理解this关键字的作用
*/
public class Test {
public static void main(String[] args) {
//创建汽车对象
Car c = new Car();
c.run(); //这是方法中的this：com.wjh.thisDemo.Car@682a0b20
System.out.println(c); //com.wjh.thisDemo.Car@682a0b20
}
}Car.java
package com.wjh.thisDemo;
public class Car {
/**
*无参数构造器
*/
public Car(){
System.out.println("无参数构造器中的this：" + this); //无参数构造器中的this：com.wjh.thisDemo.Car@682a0b2
}
public void run(){
System.out.println("这是方法中的this：" + this);
}
}
控制台：
无参数构造器中的this：com.wjh.thisDemo.Car@682a0b20
这是方法中的this：com.wjh.thisDemo.Car@682a0b20
com.wjh.thisDemo.Car@682a0b20this关键字的作用
可以用于指定访问当前对象的成员变量、成员方法。
this出现在有参数构造器中的用法
Test.java
package com.wjh.thisDemo;
/*
目标：理解this关键字的作用
*/
public class Test {
public static void main(String[] args) {
//创建汽车对象
Car c = new Car();
c.run(); //这是方法中的this：com.wjh.thisDemo.Car@682a0b20
System.out.println(c); //com.wjh.thisDemo.Car@682a0b20
System.out.println("-------------------------------------");
Car c1 = new Car("奔驰",89.2);
System.out.println(c1.name); //null
System.out.println(c1.price); //0.0
// 返回默认值原因：当值传递到有参构造函数时，由于 name = name;price = price 他最终无法到达对象中的String name;double price;
/*解决方法：
public Car(String name, double price){
this.name = name; //前面加this
this.price = price; //前面加this
}
*/
System.out.println(c1.name); //奔驰
System.out.println(c1.price); //89.2
}
}Car.java
package com.wjh.thisDemo;
public class Car {
String name;
double price;
/**
*无参数构造器
*/
public Car(){
System.out.println("无参数构造器中的this：" + this); //无参数构造器中的this：com.wjh.thisDemo.Car@682a0b2
}
public Car(String name, double price){
this.name = name;
this.price = price;
}
public void run(){
System.out.println("这是方法中的this：" + this);
}
}
五.封装
1.封装思想概述
封装:
面向对象的三大特征:封装，继承，多态。
封装:告诉我们，如何正确设计对象的属性和方法。
需求:
请设计一个人对象，且要求这个对象有名称、年龄，能吃饭、睡觉。
封装的原则:对象代表什么，就得封装对应的数据，并提供数据对应的行为。
理解封装思想有啥好处?
2.如何更好的封装
一般建议对成员变量使用private(私有、隐藏)关键字修饰进(private修饰的成员只能在当前类中访问)。
为每个成员变量提供配套public修饰的的getter、setter方法暴露其取值和赋值。
Test.java
package com.wjh.thisDemo;
/*
* 目标：学习如何进行更好的封装
*/
public class Test2 {
public static void main(String[] args) {
Student s = new Student();
s.setAge(23); //set是赋值
System.out.println(s.getAge()); //get是取值
s.setAge(-23);
System.out.println(s.getAge()); //0
}
}
Student.java
package com.wjh.thisDemo;
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;
}
}
23
你的年龄数据有问题
23
六.标准JavaBean
JavaBean
也可以称为实体类，其对象可以用于在程序中封装数据。
标准JavaBean须满足如下书写要求:
1.成员变量使用private修饰。
2.提供成员变量对应的setXxx() l getXxx()方法。
3.必须提供一个无参构造器;有参数构造器是可写可不写的。
Test.java
package com.wjh.JavaBean;
/*
* 目标：记住JavaBean的书写要求
* */
public class Test {
public static void main(String[] args) {
//1.无参构造器创建对象封装一个用户信息
User u1 = new User();
u1.setName("周义");
u1.setHeight(150.4);
u1.setSalary(2000.2);
System.out.println(u1.getName());
System.out.println(u1.getHeight());
System.out.println(u1.getSalary());
System.out.println("------------------------");
//2.有参构造器创建对象封装一个用户信息
User u2 = new User("周扒皮",156.2,1000.2);
System.out.println(u2.getName());
System.out.println(u2.getHeight());
System.out.println(u2.getSalary());
}
}
User.java
package com.wjh.JavaBean;
public class User {
//1.成员变量建议使用private私有
private String name;
private 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.必须为成员变量提供成套的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;
}
}
控制台：
周义
150.4
2000.2
------------------------
周扒皮
156.2
1000.2七.补充知识:成员变量、局部变量区别
成员变量和局部变量的区别
八.面向对象综合案例
Test.java
package com.wjh.MovieDemo;
/**
目标：完成电影信息中的展示案例，理解面向对象编程的代码
“《长津湖》”，9.7，“吴京”
“《我和我的父亲》”，9.6，“吴京”
“《觉醒年代》”，9.4，“李大招”
*/
public class Test {
public static void main(String[] args) {
//1.设计电类
//2.创建3个电影对象，封装电影的信息
Movie m1 = new Movie("长津湖",9.7,"吴京");
Movie m2 = new Movie("我和我的父亲",9.6,"吴京");
Movie m3 = new Movie("觉醒年代",9.4,"李大招");
//3.定义一个电影类型的数组，存输3部电影对象
Movie[] movies = new Movie[3];
movies[0] = m1;
movies[1] = m2;
movies[2] = m3;
//或者 movies[0] = new Movie("长津湖",9.7,"吴京");
//4.遍历数组中的每个电影对象，然后获取他的信息展示出来
for (int i = 0; i < movies.length; i++) {
Movie m = movies[i];
System.out.println("------------------------");
System.out.println("电影名称:"+" "+m.getName());
System.out.println("电影评分:"+" "+m.getScore());
System.out.println("电影主演:"+" "+m.getStar());
}
System.out.println("------------------------");
}
}
Movie.java
package com.wjh.MovieDemo;
public class Movie {
private String name;
private double score;
private String star; //主演
//3.还有一个无参构造器
public Movie() {
}
//可有可无的有参构造器
public Movie(String name, double score, String star) {
this.name = name;
this.score = score;
this.star = star;
}
//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 getStar() {
return star;
}
public void setStar(String star) {
this.star = star;
}
}
控制台：
------------------------
电影名称: 长津湖
电影评分: 9.7
电影主演: 吴京
------------------------
电影名称: 我和我的父亲
电影评分: 9.6
电影主演: 吴京
------------------------
电影名称: 觉醒年代
电影评分: 9.4
电影主演: 李大招
------------------------
扫一扫
906
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
