java面向对象技巧

java面向对象技巧

学生成绩管理系统

需求

定义一个学生信息类，

姓名，学号，年龄，成绩总分

然后根据类创建3个具体的学生对象：

然后，将这些学生对象存入一个数组中；

然后将数组根据学生的成绩倒序排序；

实现步骤

Student.java

package student;

/**

* 类代表一系列数据的模板

*

* @author cho

*

*/

public class Student {

int age;

String name;

double score;

String id;

String addr;

}

StudentManage.java

package student;

public class StudentManage {

public static void main(String[] args) {

// 造一些数据，封装到一个Student对象中

Student stu1 = new Student();

stu1.name = "张三丰";

stu1.age = 200;

stu1.id = "1";

stu1.score = 99;

stu1.addr = "武当山";

Student stu2 = new Student();

stu2.name = "欧阳锋";

stu2.age = 180;

stu2.id = "2";

stu2.addr = "白驼山";

stu2.score = 80;

Student stu3 = new Student();

stu3.name = "黄药师";

stu3.age = 120;

stu3.id = "3";

stu3.addr = "桃花岛";

stu3.score = 82;

// 创建一个对象数组,打印信息

Student[] stus = new Student[3];

stus[0] = stu1;

stus[1] = stu2;

stus[2] = stu3;

for (int i = 0; i < stus.length; i++) {

Student t = stus[i];

System.out.println("====================");

System.out.println("姓名: " + t.name);

System.out.println("年龄: " + t.age);

System.out.println("学号: " + t.id);

System.out.println("地址: " + t.addr);

System.out.println("分数: " + t.score);

}

}

}

涉及的知识点

类: 一个用来封装多个数据的模板

自定义数据的类型,不需要管具体的数据

public class 类名{

...

}

public class Student{

int age;

String name;

String addr;

int id;

double score;

}

对象: 根据类模板创建出来的一套具体数据(可以用该类型的变量来引用)

Student stu = new Student();

为对象赋值

对象.属性 = ...

stu.name = "..."

stu.age = ...

获取对象属性

对象.属性

System.out.println("姓名: "+stu.name)

订单管理系统

需求

定义一个类，描述订单信息

订单id

订单所属用户(用户对象)

订单所包含的商品(不定数量个商品对象)

订单总金额

订单应付金额：

总金额满1000，打折98折

总金额满2000，打折95折

总金额满3000，打折90折

在此基础上，还要看用户的vip等级

用户vip等级为：黄金vip，则折上折：98

用户vip等级为：钻石vip，则折上折：96

用户vip等级为：至尊vip，则折上折：92

写一个工具类ListUtils

里面定义这几个工具方法

方法1：为传入的一个整数list进行排序 sort

方法2：从传入的一个整数list中找到其中的最大值，并返回 getMax

方法3：从传入的一个整数list中找到其中的最小值，并返回 getMin

方法4：从传入的一个整数list中求出平均值，并返回 getAvg

实现步骤

User.java

package order;

/**

* 用户类

*

* @author cho

*

*/

public class User {

String userId;

String userName;

String vipLevel;

public User() {

}

public User(String userId, String userName, String vipLevel) {

super();

this.userId = userId;

this.userName = userName;

this.vipLevel = vipLevel;

}

}

Product.java

package order;

/**

* 商品类

*

* @author cho

*

*/

public class Product {

public String pId;

public String pName;

public float price;

public int number;

public Product() {

}

public Product(String pId, String pName, float price, int number) {

this.pId = pId;

this.pName = pName;

this.price = price;

this.number = number;

}

}

Order.java

package order;

import java.util.ArrayList;

/**

* 订单类

* 订单id

* 订单所属用户(用户对象)

* 订单所包含的商品(不定数量个商品对象)

* 订单总金额

* 订单应付金额：

* @author cho

*

*/

public class Order {

// 订单id

public String orderId;

// 订单所属用户(用户对象)

public User user;

// 订单所包含的商品

public ArrayList pdts;

// 订单总金额

public float amountFee;

// 订单应付金额

public float toPayFee;

public void setAmountFee() {

float sum = 0;

for (int i = 0; i < this.pdts.size(); i++) {

sum += (i).price * (i).number;

}

this.amountFee = sum;

}

public void setToPayFee() {

float tmp = this.amountFee;

// 根据总金额进行打折

if (this.amountFee >= 1000 && this.amountFee < 2000) {

tmp = this.amountFee * 0.98f;

}

if (this.amountFee >= 2000 && this.amountFee < 3000) {

tmp = this.amountFee * 0.95f;

}

if (this.amountFee >= 3000) {

tmp = this.amountFee * 0.90f;

}

// 根据用户vip等级打折

if (user.vipLevel.equals("黄金vip")) {

tmp = tmp * 0.98f;

}

if (user.vipLevel.equals("钻石vip")) {

tmp = tmp * 0.96f;

}

if (user.vipLevel.equals("至尊vip")) {

tmp = tmp * 0.92f;

}

// 把计算出来的结果赋值给对象上的toPayFee成员变量

}

}

ListUtils.java

package order;

import java.util.ArrayList;

import java.util.Collections;

/**

* 工具类

*

* @author cho

*

*/

public class ListUtils {

/**

* 对传入的list排序

*

* @param list

*/

public static void sort(ArrayList list) {

Collections.sort(list);

}

/**

* 从传入的list中找到最大值

*

* @param list

*/

public static int getMax(ArrayList list) {

int tmp = (0);

for (int i = 1; i < list.size(); i++) {

if ((i) > tmp) {

tmp = (i);

}

}

// 返回结果

return tmp;

}

/**

* 从传入的list中找到最小值

*

* @param list

*/

public static int getMin(ArrayList list) {

int tmp = (0);

for (int i = 1; i < list.size(); i++) {

if ((i) < tmp) {

tmp = (i);

}

}

// 返回结果

return tmp;

}

/**

* 求传入的list的数据平均值

*

* @param list

*/

public static float getAvg(ArrayList list) {

int sum = 0;

for (int i = 0; i < list.size(); i++) {

sum += (i);

}

return (float) sum / list.size();

}

}

OrderTest.java

package order;

import java.util.ArrayList;

public class OrderTest {

public static void main(String[] args) {

Order o1 = new Order();

// 创建订单所属的用户对象

User u_zwj = new User("1", "张无忌", "黄金vip");

o1.user = u_zwj;

// 创建商品列表

ArrayList pdts = new ArrayList();

Product p1 = new Product("p1", "打神鞭", 18.8f, 10);

Product p2 = new Product("p12", "捆仙索", 28.8f, 5);

pdts.add(p1);

pdts.add(p2);

o1.pdts = pdts;

// 在Order对象o1上调用方法setAmountFee()来计算总金额并给对象上的属性amountFee赋值

o1.setAmountFee();

// 在Order对象o1上调用方法setToPayFee()来计算总金额并给对象上的属性toPayFee赋值

o1.setToPayFee();

System.out.println("订单总金额：" + o1.amountFee);

System.out.println("订单应付金额：" + o1.toPayFee);

}

}

涉及的知识点

一个类中包含其他类

public class Order{

User ...

Product ...

}

不定长数组 ArrayList<>

ArrayList q = new ArrayList();

添加: q.add(...)

获得: q.get(...)

移除: q.remove(...)

类方法和静态方法

静态方法可以使用类名直接调用(在类中可以直接使用)

类方法要使用对象来调用

class X{

static void f1(){

...

}

void f2(){

...

}

}

X x = new X();

X.f1();

x.f1();

x.f2();

自动售货系统

需求

实现步骤

涉及的知识点

toString() 自定义对象输出

public String toString() {

return this.productId + "," + this.productName + "," + this.price + "," + this.num;

}

HashMap的使用

HashMap map = new HashMap();

map.put("1","zhangsan");

<("1");

HashSet的使用

HashSet set = map.keySet(); // 取出HashSet

添加: set.add(...)

移除: ve(...)

HashMap的遍历

1. 迭代器

Iterator it = set.iteraotr();

while(it.hasNext()){

String s = it.next();

...

}

it.hasNext()

<()

2. 增强for循环

for(String s:set){

...

}

接口Interface

1. 接口中的方法只能有定义,不能有具体的实现

2. 接口是更加抽象的类,但是不能被new,只能使用一个类来实现接口

3. 一个类实现一个接口,那么接口的方法都要实现,当然也可以增加额外的方法

class 类名 implements 接口1,接口2...{

实现方法

}

4. 接口的作用: 在业务实现类和调用者之间定义一个功能规范

同事A和同事B共同开发,同事A写类的工作量比较大,但是B需要用到A写的类,怎么办?

先设计好一个接口的内容,然后给B使用,B可以先写着接口中的方法,等A把具体的类写好了,再new一下即可

接口 对象 = null; // 没有接口之前

接口 对象 = new 具体类(); // 向上转型

JUnit单元测试

有一个框架,叫做junit

它可以帮我们调用各种测试方法,那么我们就可以不用main方法来测试了

@Test

要运行哪个测试方法，就在这个方法上添加@Test注解，然后在方法名上点右键，选run as-->Junit

public class UserDaoImplJunitTest {

@Test // 要运行哪个测试方法，就在这个方法上添加@Test注解，然后在方法名上点右键，选run as-->Junit

public void testAdd() {

UserDaoImpl userDaoImpl = new UserDaoImpl();

User u2 = new User();

u2.set("lisi", "123");

userDaoImpl.addUser(u2);

boolean ex = userDaoImpl.checkUserIfExsit("lisi");

System.out.println(ex);

}

@Test

public void testFind() {

UserDaoImpl userDaoImpl = new UserDaoImpl();

User xx = userDaoImpl.findUserByName("ccc");

System.out.Password());

}

}

静态代码块

静态代码块: static {...}

普通代码块: {}

静态代码块的作用: 预加载数据

jvm在为一个类构造对象时,

1. 首先执行静态代码,如果有多份静态代码,则从上往下顺序执行

2. 然后执行普通代码块

3. 然后再执行构造函数

public class OrderDatabase {

public static String orderVersion = "500";

static {

System.out.println("静态代码块执行了....");

System.out.println("在静态代码赋值前，order版本是：" + orderVersion);

orderVersion = "1000";

System.out.println("在静态代码赋值后，order版本是：" + orderVersion);

}

{

System.out.println("哈哈,普通代码块执行了.......");

}

public OrderDatabase() {

System.out.println("空参构造函数运行了....");

System.out.println("在构造代码赋值前，order版本是：" + orderVersion);

orderVersion = "2000";

System.out.println("在构造代码赋值后，order版本是：" + orderVersion);

}

public void sayHello() {

System.out.println("哈哈，sayHello执行了......");

}

}

泛型参数的基本概念

泛型: 抽象的数据类型

// T就是一种类型,什么类型不知道,等调用者传递进来

class ArrayList{

priavte T[] array;

public void add(T e){...}

public void remove(int index){...}

public T get(int index){...}

}

JDK自带的排序工具

数组工具类: Arrays

集合工具类: Collections

Arrays.sort()

Collection.sort()

sort(array,new Comparator(){

@Override

public int compare(T o1,T o2){

...

return 小于0,0,大于0; // ()

}

})

对象要排序有哪几种方式

1. 调用sort时候传递一个 new Comparotor(){}

2. 类实现一个 Comparable 接口