【Java SE 代码回顾】——day04_列表、静态方法、构造方法

简介: 【Java SE 代码回顾】——day04_列表、静态方法、构造方法

这个系列是对javaSE课程代码的回顾,所有Demo都是亲自动手实现的,并做了小小的change,为了方便自己理解和后期复习,代码里加了大量的注释。现对所有知识点的代码进行复习整理,进一步理解、完善代码,对注释进行补充。其中重要的知识点会单独说明,但主要以代码为主。


说明:博客是对学习内容的巩固,很多注释是为了自己理解,所以不会很专业。


------------------------------------------------------ArrayList------------------------------------------------  

package cn.tjpu.javase04.ArrayList;
import java.util.ArrayList;
/**
 * ArrayList用法,<>中填入的是泛型参数,即数据类型
 * ArrayList是一种集合数据类型,可以装入任意多个数据且长度可变
 * size():ArrayList长度; add(值):添加数据 ;get(索引):读数据 ;remove(索引):移除数据
 */
public class ArrayListDemo01 {
  public static void main(String[] args) {
    // 创建一个用来装整数数据的ArrayList对象
    ArrayList<Integer> arylt = new ArrayList<Integer>();
    // 向arraylist中添加数据
    arylt.add(3);
    arylt.add(4);
    arylt.add(7);
    arylt.add(1);
    // 从arraylist中读取数据
    int a = arylt.get(2);
    int b = arylt.get(0);
    System.out.println(a + "," + b);
    System.out.println("------------------------------");
    // 遍历arraylist,按照角标顺序打印
    for (int i = 0; i < arylt.size(); i++) {
      System.out.println(arylt.get(i));
    }
    System.out.println("------------------------------");
    // 移除arraylist中数据
    arylt.remove(1);
    for (int i = 0; i < arylt.size(); i++) {
      System.out.println(arylt.get(i));
    }
    System.out.println("------------------------------");
    // 更改list中指定位置的数据
    arylt.set(2, arylt.get(0));
    // 可直接打印list
    System.out.println(arylt);
  }
}

------------------------------------------------------各种方法定义------------------------------------------------  

package cn.tjipu.javase04.function;
/**
 * 定义不同方法的类
 */
public class NumberPair {
  public int a;
  public int b;
  //无参有返回值的方法
  public int GetSum() {
    int sum = this.a + this.b;
    return sum;
  }
  // 没有返回值的方法
  public void say() {
    System.out.println("我吃了");
  }
  // 有参没有返回值的方法,同名方法,参数列表不一样,叫方法的重载
  public void say(String name) {
    System.out.println(name + "吃了");
  }
  // 带多个参数但没有返回值的方法
  public void say(String name1, String name2) {
    System.out.println(name1 + "和" + name2 + "都吃了");
  }
  // 有参且有返回值的方法
  public int Sum(int a, int b) {
    return a + b;
  }
}
package cn.tjipu.javase04.function;
/**
 * 不同方法的测试
 */
public class FunctionDemo1 {
  public static void main(String[] args) {
    NumberPair pair = new NumberPair();
    //给成员变量赋值
    pair.a = 10;
    pair.b = 33;
    /*
     //方法未封装,直接在主程序中计算
     int sum=pair.a+pair.b;
     System.out.println(sum);
    */
    // 在类中定义方法,用实例化的对象调用方法计算
    System.out.println(pair.GetSum());
    // 调没有返回值的方法
    pair.say();
    // 调用有参数,但没有返回值的方法
    pair.say("小明");
    pair.say("小明", "小红");
    // 调用有参且有返回值的方法
    int sum = pair.Sum(10, 2);
    System.out.println(sum);
  }
}

------------------------------------------------静态方法、list排序--------------------------------------------  

package cn.tjipu.javase04.function;
import java.util.ArrayList;
/**
 * list处理工具类(都是静态方法)
 * 静态方法 :
 * 和具体对象没有任何关系的方法(没有用到类的成员变量)可以定义为静态方法--类的方法 
 * 静态方法直可以用类名来调用
 */
public class ListUtils {
  /**
   * 该方法是对传入的list排序
   */
    public static void sort(ArrayList<Integer> list){
      for(int i=0;i<list.size()-1;i++){
        for(int j=0;j<list.size()-1-i;j++){
          if(list.get(j)>list.get(j+1)){
            //先把list中第j和j+1位置的内容取出来
            int tmp=list.get(j);//把j的值赋给tmp
            //再利用set方法将调换过的值放到指定列表的位置
            list.set(j, list.get(j+1));//把j+1的值赋给j
            list.set(j+1, tmp);// 把tmp的值赋给j+1
          }
        }
      }
    }
  /**
   * 该方法是从传入的list中找最大值(找最大值需要一个临时变量)
   */
    public static int getMax(ArrayList<Integer> list){
      int tmp=list.get(0);
      for(int i=1;i<list.size();i++){
        if(list.get(i)>tmp){
          tmp=list.get(i);
        }
      }
      return tmp;
    }
  /**
   * 该方法是从传入的list中找最小值(改变判断语句中的符号)
   */
    public static int getMin(ArrayList<Integer> list){
      int tmp=list.get(0);
      for(int i=1;i<list.size();i++){
        if(list.get(i)<tmp){
          tmp=list.get(i);
        }
      }
      return tmp;
    }
  /**
   * 该方法是求传入的list的数据平均值
   */
    public static float getAvg(ArrayList<Integer> list){
      int sum=0;
      for(int i=0;i<list.size();i++){
        sum+=list.get(i);
      }
      return ((float)sum/list.size());
    }
}
package cn.tjipu.javase04.function;
import java.util.ArrayList;
/**
 * 测试list处理工具类 ,直接用类调用方法
 */
public class ListUtilsTest {
  public static void main(String[] args) {
    // 造一些ArrayList的数据
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(3);
    list.add(4);
    list.add(1);
    list.add(9);
    list.add(5);
    // 测试list排序,方法无返回值,执行完方法list覆盖原有顺序,遍历打印即排好的顺序
    ListUtils.sort(list);
    for (int i = 0; i < list.size(); i++) {
      System.out.println(list.get(i));
    }
    System.out.println(list);
    // 测试最大值
    int max = ListUtils.getMax(list);
    System.out.println("max is:" + max);
    // 测试最小值
    int min = ListUtils.getMin(list);
    System.out.println("min is:" + min);
    // 测试平均值
    float avg = ListUtils.getAvg(list);
    System.out.println("avg is:" + avg);
  }
}

------------------------------------------------------订单管理------------------------------------------------  

package cn.tjipu.javase04.ProductOder;
/**
 * 用户类
 */
public class User {
  public String userId;
  public String userName;
  public String vipLeval;
  //空参构造方法
  public User() {
  }
  //带参构造方法
  public User(String userId, String userName, String vipLeval) {
    this.userId = userId;
    this.userName = userName;
    this.vipLeval = vipLeval;
  }
}
package cn.tjipu.javase04.ProductOder;
/**
 * 商品类
 */
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;
  }
  public String toString() {
    String tmp = this.pId + "," + this.pName + "," + this.price + ","
        + this.Number;
    return tmp;
  }
  public float GetAmount() {
    return this.price * this.Number;
  }
}
package cn.tjipu.javase04.ProductOder;
import java.util.ArrayList;
/**
 * 订单类
 */
public class Order {
  // 订单id
  public String oderId;
  // 订单所属用户(用户对象)
  public User user;
  // 订单所包含的商品(不定数量个商品对象)
  public ArrayList<Product> prods;
  // 订单总金额
  public float amountFee;
  // 订单应付金额
  public float topayFee;
  // 计算订单总金额的方法
  public void setamountFee() {
    float sum = 0;
    for (int i = 0; i < this.prods.size(); i++) {
      sum += this.prods.get(i).price * this.prods.get(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.vipLeval.equals("黄金vip")) {
      tmp = this.amountFee * 0.98f;// 根据vip等级打折后的实际金额
    }
    if (user.vipLeval.equals("钻石vip")) {
      tmp = this.amountFee * 0.96f;
    }
    if (user.vipLeval.equals("至尊vip")) {
      tmp = this.amountFee * 0.92f;
    }
    // 把计算出来的结果赋值给toPayFee成员变量
    this.topayFee = tmp;
  }
}
package cn.tjipu.javase04.ProductOder;
/**
 * 订单管理测试
 */
import java.util.ArrayList;
public class OrderTest {
  public static void main(String[] args) {
    // 创建一个订单
    Order o1 = new Order();
    o1.oderId = "001";
    // 创建订单所属用户对象
    User zs = new User("111", "张三", "黄金vip");// 先创建一个用户对象
    o1.user = zs;
    // 创建商品列表
    ArrayList<Product> prod = new ArrayList<Product>();
    // 造一些商品数据
    // 1.使用无参构造方法
    Product pt1 = new Product();
    pt1.pId = "101";
    pt1.pName = "牛奶";
    pt1.price = 5.5f;
    pt1.Number = 2;
    // 2.使用有参构造方法(可以直接给对象初始化)
    Product pt2 = new Product("102", "面包", 3.5f, 3);
    Product pt3 = new Product("103", "火腿", 1.5f, 5);
    // 将商品数据加入到商品列表中
    prod.add(pt1);
    prod.add(pt2);
    prod.add(pt3);
    // 创建订单所包含商品
    o1.prods = prod;
    // 用实例化的order对象调用方法setAmountFee()来计算总金额并给对象上的属性amountFee赋值
    o1.setamountFee();
    // 用实例化的order对象调用方法setToPayFee()来应付金额并给对象上的属性toPayFee赋值
    o1.settopayFee();
    // 调用成员变量打印
    System.out.println("总金额:" + o1.amountFee);
    System.out.println("应付金额:" + o1.topayFee);
  }
}
相关文章
|
4天前
|
安全 Java 编译器
深入理解Java中synchronized三种使用方式:助您写出线程安全的代码
`synchronized` 是 Java 中的关键字,用于实现线程同步,确保多个线程互斥访问共享资源。它通过内置的监视器锁机制,防止多个线程同时执行被 `synchronized` 修饰的方法或代码块。`synchronized` 可以修饰非静态方法、静态方法和代码块,分别锁定实例对象、类对象或指定的对象。其底层原理基于 JVM 的指令和对象的监视器,JDK 1.6 后引入了偏向锁、轻量级锁等优化措施,提高了性能。
20 3
|
29天前
|
Java
java小工具util系列4:基础工具代码(Msg、PageResult、Response、常量、枚举)
java小工具util系列4:基础工具代码(Msg、PageResult、Response、常量、枚举)
52 24
|
11天前
|
前端开发 Java 测试技术
java日常开发中如何写出优雅的好维护的代码
代码可读性太差,实际是给团队后续开发中埋坑,优化在平时,没有那个团队会说我专门给你一个月来优化之前的代码,所以在日常开发中就要多注意可读性问题,不要写出几天之后自己都看不懂的代码。
49 2
|
25天前
|
Java 编译器 数据库
Java 中的注解(Annotations):代码中的 “元数据” 魔法
Java注解是代码中的“元数据”标签,不直接参与业务逻辑,但在编译或运行时提供重要信息。本文介绍了注解的基础语法、内置注解的应用场景,以及如何自定义注解和结合AOP技术实现方法执行日志记录,展示了注解在提升代码质量、简化开发流程和增强程序功能方面的强大作用。
66 5
|
25天前
|
存储 算法 Java
Java 内存管理与优化:掌控堆与栈,雕琢高效代码
Java内存管理与优化是提升程序性能的关键。掌握堆与栈的运作机制,学习如何有效管理内存资源,雕琢出更加高效的代码,是每个Java开发者必备的技能。
49 5
|
28天前
|
Java API 开发者
Java中的Lambda表达式:简洁代码的利器####
本文探讨了Java中Lambda表达式的概念、用途及其在简化代码和提高开发效率方面的显著作用。通过具体实例,展示了Lambda表达式如何在Java 8及更高版本中替代传统的匿名内部类,使代码更加简洁易读。文章还简要介绍了Lambda表达式的语法和常见用法,帮助开发者更好地理解和应用这一强大的工具。 ####
|
25天前
|
安全 Java API
Java中的Lambda表达式:简化代码的现代魔法
在Java 8的发布中,Lambda表达式的引入无疑是一场编程范式的革命。它不仅让代码变得更加简洁,还使得函数式编程在Java中成为可能。本文将深入探讨Lambda表达式如何改变我们编写和维护Java代码的方式,以及它是如何提升我们编码效率的。
|
Java 索引 编译器
|
1天前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类:`Producer`(生产者)、`Consumer`(消费者)、`Resource`(公共资源)和`TestMain`(测试类)。通过`synchronized`和`wait/notify`机制控制线程同步,但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`,解决了多次生产和消费的问题,但仍可能因`notify()`随机唤醒线程而导致死锁。因此,引入了`notifyAll()`来唤醒所有等待线程,但这会带来性能问题。
Java—多线程实现生产消费者
|
3天前
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中,`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性,通过锁机制确保线程安全;`volatile` 仅保证可见性和有序性,不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结:`volatile` 确保不同线程对共享变量操作的可见性,使一个线程修改后,其他线程能立即看到最新值。