目录
一、设计对象并使用
1.设计类，创建对象并使用
类(设计图)：是对象共同特征的描述
对象：是真实存在的具体实例
结论：在Java中必须先设计类，才能创建对象并使用
类的结构：public class 类名{1.成员变量(代表属性，一般是名词) 2.成员方法(代表行为，一般是动词) 3.构造器 4.代码块 5.内部块}
package com.pikaqiu.createobject;
public class Car {
//成员变量
String name;
double price;
//方法
public void start(){
System.out.println(name + "启动了~~~");
}
public void run(){
System.out.println("价格是:" + price + "的" + name + "跑的快");
}
}
package com.pikaqiu.createobject;
public class Test1 {
public static void main(String[] args) {
//创建汽车对象
Car c = new Car();
c.name = "宝马";
c.price = 389000;
System.out.println(c.name);
System.out.println(c.price);
c.start();
c.run();
System.out.println("--------------------");
Car c2 = new Car();
c2.name = "奔驰";
c2.price = 399000;
System.out.println(c2.name);
System.out.println(c2.price);
c2.start();
c2.run();
}
}
2.定义类的几个补充注意事项
1.类名的首字母建议大写，满足"驼峰模式"，不能使用关键字，必须是合法字符，且有意义；
2.一个Java文件中可以定义多个class类，但只能一个类是public修饰，而且public修饰的类名必须成为代码文件名；注意：实际开发中还是建议一个代码文件只定义一个类
3.成员变量的完整定义格式是：修饰符 数据类型 变量名称 = 初始值; 一般无需指定初始化值，存在默认值
默认值的规则：byte、short、int、long---0；double、float---0.0；boolean---false；String等引用类型---null
package com.pikaqiu.createobject;
public class Student {
public String name;
boolean flag;
}
//class Animal{
//
//}
//
//class Dog{
//
//}
package com.pikaqiu.createobject;
public class Test2 {
public static void main(String[] args) {
Student s = new Student();
System.out.println(s.name);
System.out.println(s.flag);
}
}
二、对象在内存中的运行机制
1.多个对象的内存图
对象存放在堆内存中；
Car c = new Car(); c变量存储的是对象在堆内存中的地址；
成员变量的数据存放在对象中，即存放在堆内存中
2.两个变量指向同一个对象内存图
垃圾回收：当堆内存中的对象，没有被任何变量引用(指向)时，就会被判定为内存中的"垃圾"
package com.pikaqiu.memory;
public class Student {
String name;
char sex;
String hobby;
public void study(){
System.out.println("姓名:" + name + " " + "性别:" + sex + " " + "爱好:" + hobby);
}
}
package com.pikaqiu.memory;
public class Test {
public static void main(String[] args) {
//创建学生对象
Student s1 = new Student();
s1.name = "张三";
s1.sex = '男';
s1.hobby = "睡觉,游戏,学习";
s1.study();
//把s1变量赋值给一个学生类型的变量s2
Student s2 = s1;
//s1和s2地址一样
System.out.println(s2); //s2的地址com.pikaqiu.memory.Student@1b6d3586
System.out.println(s1); //s1的地址com.pikaqiu.memory.Student@1b6d3586
s2.hobby = "爱提问";
System.out.println(s2.name); //张三
System.out.println(s1.sex); //男
System.out.println(s1.hobby); //爱提问
s2.study(); //姓名:张三 性别:男 爱好:爱提问
}
}
三、面向对象编程训练：模拟购物车模块
package com.pikaqiu.demo;
public class Goods {
int id; //编号
String name; //名称
double price; //价格
int buyNumber; //购买数量
}
package com.pikaqiu.demo;
import java.util.Scanner;
public class ShopCarTest {
public static void main(String[] args) {
//1.定义商品类，方便创建商品对象
//2.定义购物车对象，使用一个数组对象表示
Goods[] shopCar = new Goods[100]; //[null,null,...]
//3.搭建操作架构
boolean flag = true;
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.print("请您输入命令: ");
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);
flag = false;
break;
default:
System.out.println("输入功能有误!");
}
}
}
public static void pay(Goods[] shopCar) {
queryGoods(shopCar);
//首先定义一个求和变量累加金额
double money = 0;
//然后遍历购物车数组中的全部商品对象，累加单价*数量
for (int i = 0; i < shopCar.length; i++) {
Goods good = shopCar[i];
if(good != null){
money += (good.price * good.buyNumber);
}else{
break;
}
}
System.out.println("订单总金额为:" + money);
}
public static void updateGoods(Goods[] shopCar , Scanner sc) {
//让用户输入要修改的商品id，根据id查询出要修改的商品对象
while (true) {
System.out.print("请您输入要修改的商品id: ");
int id = sc.nextInt();
Goods good = getGoodsById(shopCar,id);
if(good == null){
//没有这个商品
System.out.println("对不起，您没有购买这个商品~~~");
}else{
//存在这个商品，可以修改了
System.out.print("请您输入:" + good.name + "商品最新的购买数量:");
int buyNumber = sc.nextInt();
good.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 good = shopCar[i];
if(good != null){
//判断商品id是否为我们所要寻找的
if(good.id == id){
return good;
}
}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购买数量");
for (int i = 0; i < shopCar.length; i++) {
Goods good = shopCar[i];
if(good != null){
//展示这个商品
System.out.println(good.id + "\t\t" + good.name + " "
+ good.price + "\t" + good.buyNumber);
}else{
//遍历结束
break;
}
}
}
//完成商品添加到购物车的功能
public static void addGoods(Goods[] shopCar , Scanner sc) {
//1.录入用户输入的购买商品的信息
System.out.print("请您输入购买商品的编号(不重复): ");
int id = sc.nextInt();
System.out.print("请你输入购买商品的名称: ");
String name = sc.next();
System.out.print("请您输入购买商品的数量: ");
int buyNumber = sc.nextInt();
System.out.print("请您输入购买商品的价格: ");
double price = sc.nextDouble();
//2.把商品购买的信息封装成为一个对象
Goods good = new Goods();
good.id = id;
good.name = name;
good.buyNumber = buyNumber;
good.price = price;
//3.将商品对象添加到购物车数组里面去
for (int i = 0; i < shopCar.length; i++) {
if(shopCar[i] == null){
//说明此处没有元素存入，把我们新买的商品添加到此处即可
shopCar[i] = good;
break; //结束，商品已经成功存入
}
}
System.out.println("您的商品:" + good.name + "添加到购物车完成!");
}
}
四、构造器
构造器的作用：定义在类中的，可以用于初始化一个类的对象，并返回对象的地址
构造器的格式：修饰符 类名(形参列表){...}
调用构造器得到对象的格式：类 变量名称 = new 构造器;
构造器的分类和作用：1.无参数构造器(默认存在的):初始化对象时，成员变量的数据均采用默认值；2.有参数构造器:在初始化对象的时候，同时可以接收参数为对象进行赋值
构造器的注意事项：1.任何类被定义出来，默认就自带了无参数构造器，写不写都有；2.一旦定义了有参数构造器，那么无参数构造器就没有了，如果还想用无参数构造器，此时就需要自己手写一个无参数构造器
package com.pikaqiu.constructor;
public class Car {
String m_name;
double m_price;
//无参数构造器
public Car(){
System.out.println("无参数构造器被调用了~~~");
}
//有参数构造器
public Car(String name , double price){
System.out.println("有参数构造器被调用了~~~");
m_name = name;
m_price = price;
}
}
package com.pikaqiu.constructor;
public class Test {
public static void main(String[] args) {
//通过调用构造器构造对象
//无参构造
Car c = new Car();
System.out.println(c.m_name);
System.out.println(c.m_price);
//有参构造
Car c1 = new Car("奔驰",800000);
System.out.println(c1.m_name);
System.out.println(c1.m_price);
}
}
五、this关键字
this关键字是什么：可以出现在构造器、方法中；代表当前对象的地址
this关键字的作用：可以用于指定访问当前对象的成员变量、成员方法
package com.pikaqiu.thisdemo;
public class Car {
String name;
double price;
//定义无参构造
public Car(){
System.out.println("无参数构造器中的this:" + this);
}
public Car(String name , double price){
// //下面这种赋值并不会为对象赋值
// name = name;
// price = price;
this.name = name;
this.price = price;
}
public void goWith(String name){
//System.out.println(name + "正在和" + name + "比赛~~~");
System.out.println(this.name + "正在和" + name + "比赛~~~");
}
//定义方法
public void run(){
System.out.println("方法中的this:" + this);
}
}
package com.pikaqiu.thisdemo;
public class Test {
public static void main(String[] args) {
Car c = new Car();
c.run();
System.out.println(c);
System.out.println("--------------------");
Car c1 = new Car("奔驰",800000);
System.out.println(c1.name);
System.out.println(c1.price);
System.out.println("--------------------");
c1.goWith("宝马");
}
}
六、封装
1.封装思想概述
面向对象的三大特征之一：封装、继承、多态
封装：告诉我们，如何正确设计对象的属性和方法
封装的原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为
2.如何更好的封装
1.一般建议对成员变量使用private(私有、隐藏)关键字修饰(private修饰的成员只能在当前类中访问)；2.为每个成员变量提供配套public修饰的getter、setter方法暴露其取值和赋值
package com.pikaqiu.encapsulation;
public class Student {
//成员变量设置为私有
private int age;
//1.定义方法暴露取值和赋值
public void setAge(int age){
if(age >= 0 && age <= 150){
this.age = age;
}else{
System.out.println("您输入的年龄有问题!!!");
}
}
public int getAge(){
return age;
}
}
package com.pikaqiu.encapsulation;
public class Test2 {
public static void main(String[] args) {
Student s1 = new Student();
s1.setAge(200);
System.out.println(s1.getAge());
}
}
七、标准JavaBean
JavaBean也可以称为实体类，其对象可以用于在程序中封装数据
标准JavaBean须满足以下要求：1.成员变量使用private修饰；2.提供成员变量对应的set/get方法；3.必须提供一个无参构造器，有参构造器可写可不写
package com.pikaqiu.javabean;
public class User {
//1.成员变量使用private修饰
private String name;
private double height;
private double salary;
//提供成员变量对应的set/get方法
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;
}
//必须提供一个无参构造器，有参构造器可写可不写
public User() {
}
public User(String name, double height, double salary) {
this.name = name;
this.height = height;
this.salary = salary;
}
}
package com.pikaqiu.javabean;
public class Test {
public static void main(String[] args) {
//1.无参构造器创建对象，封装一个用户信息
User u1 = new User();
u1.setName("皮卡丘");
u1.setHeight(182);
u1.setSalary(50000);
System.out.println(u1.getName());
System.out.println(u1.getHeight());
System.out.println(u1.getSalary());
//2.有参构造器创建对象，封装一个用户信息
User u2 = new User("妙蛙种子" , 175 , 30000);
System.out.println(u2.getName());
System.out.println(u2.getHeight());
System.out.println(u2.getSalary());
}
}
八、成员变量、局部变量的区别
区别：
1.类中的位置不同。成员变量在类中、方法外；局部变量常见于方法中。
2.初始化值不同。成员变量有默认值，无需初始化；局部变量没有默认值，使用之前需要完成赋值。
3.内存位置不同。成员变量在堆内存；局部变量在栈内存。
4.生命周期不同。成员变量随着对象的创建而存在，随着对象的消失而消失；局部变量随着方法的调用而存在，随着方法的运行结束而消失。
5.作用域不同。局部变量在所归属的大括号中。
九、面向对象(oop)综合案例
需求：使用面向对象编程，模仿电影信息的展示
package com.pikaqiu.demo2;
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 com.pikaqiu.demo2;
public class Test {
public static void main(String[] args) {
//定义一个电影类型的数组，存放三部电影
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());
System.out.println("--------------------");
}
}
}
3033
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
