美文网首页
4.记事本

4.记事本

作者: Joypang | 来源:发表于2018-11-08 19:12 被阅读5次

    记事本

    • 能存储记录
    • 不限制能存储的记录属两个（任意存储）
    • 能知道已经存储的记录的数量
    • 能查看存进去的每一条记录
    • 能删除一条记录
    • 能列出所有的记录
    接口设计

    人机交互：输入输出的部分
    业务逻辑：计算机计算的部分
    界面（UI）和业务逻辑要分离

    记事本应该实现业务逻辑

    • add(String note);
    • getSize();
    • getNote(int index);
    • removeNote(int index);
    • list();

    定义接口

    package notebook;

public class NoteBook {
    //先来定义接口
    public void add(String s){
        
    }
    
    public int getSize(){
    //先把接口定义出来，没有返回语句，就有错误提示
        return 0;
    }
    public String getNote(int index){//返回某一条NoteyongString
        return "";
    }
    
    public boolean removeNote(int index){
        return true;//boolean到底有没有删除成功？
    }
    
    //第一种设计list()
    public void list(){//列出所有的东西
        System.out.println();
    }
    //第二种设计返回一个string[]数组
    public String[] list(){
        
    }
    public static int main(String[] args) {
        // TODO Auto-generated method stub

    }

}

    范型容器类

    ArrayList<String>类
    称作Arraylist of String，用来存放string 的Arraylist，这种类型叫做范型类，这种类了是一种容器
    容器类

    • ArrayList<String> notes=new ArrayList<String>();
    • 容器类有俩个类型
      • 容器的类型
      • 元素的类型
    package notebook;

import java.util.ArrayList;

public class NoteBook {
    //需要定义一个成员变量
    private ArrayList<String> notes=new ArrayList<String>();//ArrayList<>类,notes是一个对象管理者
    //private int size=0;
    
    //先来定义接口
    public void add(String s){
        //要存放很多东西可以使用是数组但是要无限制
        //要无限制的存放，应该使用容器
        notes.add(s);
        //size++;//add一次SIze加一次
        //notes.add(10);只能接受String不能接受int 
    }
    
    public int getSize(){//存放了多少个
    //先把接口定义出来，没有返回语句，就有错误提示
        //return size();
        return notes.size();//arraylist中有size这个函数，他知道我们存放了多少个函数
    }
    public String getNote(int index){//返回某一条NoteyongString
        return "";
    }
    
    public boolean removeNote(int index){
        return true;//boolean到底有没有删除成功？
    }
    
    //第一种设计list()
    //public void list(){//列出所有的东西
    //  System.out.println();
    //}
    //第二种设计返回一个string[]数组
    public String[] list(){
        return new String[10];
    }
    public static void main(String[] args) {
        String[]a=new String[2];
        a[0]="first";
        a[1]="second";
        NoteBook nb=new NoteBook();//创建一个对象
        nb.add("first");
        nb.add("second");
        System.out.println(nb.getSize());
    }

}

    ARRAYLIST 的操作1

    ARRAYLIST是有顺序的
    下标也是从0开始的，可以帮助我们获取其中一个元素

    package notebook;

import java.util.ArrayList;

public class NoteBook {
    //需要定义一个成员变量
    private ArrayList<String> notes=new ArrayList<String>();//ArrayList<>类,notes是一个对象管理者
    //private int size=0;
    
    //先来定义接口
    public void add(String s){
        //要存放很多东西可以使用是数组但是要无限制
        //要无限制的存放，应该使用容器
        notes.add(s);
        //size++;//add一次SIze加一次
        //notes.add(10);只能接受String不能接受int 
    }
    
    //上述add只是将一个东西加到后面，下面的接口可以将一些东西加载前面
    public void add(String s,int location){
        notes.add(location,s);
    }
    
    public int getSize(){//存放了多少个
    //先把接口定义出来，没有返回语句，就有错误提示
        //return size();
        return notes.size();//arraylist中有size这个函数，他知道我们存放了多少个函数
    }
    public String getNote(int index){//返回某一条NoteyongString
        return notes.get(index);
    }
    
    public void removeNote(int index){//Boolean是没有意义的
        notes.remove(index);//boolean到底有没有删除成功？
    }
    
    //第一种设计list()
    //public void list(){//列出所有的东西
    //  System.out.println();
    //}
    //第二种设计返回一个string[]数组
    public String[] list(){
        //构造有个数组
        String[]a=new String[notes.size()];
//      for(int i=0;i<notes.size();i++)
//      {
//          a[i]=notes.get(i);
//      }
        notes.toArray(a);//相当于上述循环
        return a;
    }
    public static void main(String[] args) {
        NoteBook nb=new NoteBook();//创建一个对象
        nb.add("first");
        nb.add("second");
        nb.add("third",1);//把它放在1 的前面
        System.out.println(nb.getSize());//2
        System.out.println(nb.getNote(0));//fist
        System.out.println(nb.getNote(1));//third
        //System.out.println(nb.getSize(10));出错下标会越界
        nb.removeNote(1);//将third移走
        String[]a=nb.list();
        for(String s:a){
            System.out.println(s);
        }
    }

}

    输出结果是：
    3
    first
    third
    first
    second

    ARRAYLIST操作2

    String []a=new String [10];
    String组成10个管理者

    • 对象数组中的每一个元素都是对象的管理者而非对象本身
    • 即创建数组的时候，他的对象还不存在，需要在创建

    for-each
    对于对象数组不一样的

    package notebook;

import java.util.ArrayList;
class Value{
    private int i;
    public void set(int i){this.i=i;}
    public int get(){return i;}
}
public class NoteBook {
    //需要定义一个成员变量
    private ArrayList<String> notes=new ArrayList<String>();//ArrayList<>类,notes是一个对象管理者
    //private int size=0;
    
    //先来定义接口
    public void add(String s){
        //要存放很多东西可以使用是数组但是要无限制
        //要无限制的存放，应该使用容器
        notes.add(s);
        //size++;//add一次SIze加一次
        //notes.add(10);只能接受String不能接受int 
    }
    
    //上述add只是将一个东西加到后面，下面的接口可以将一些东西加载前面
    public void add(String s,int location){
        notes.add(location,s);
    }
    
    public int getSize(){//存放了多少个
    //先把接口定义出来，没有返回语句，就有错误提示
        //return size();
        return notes.size();//arraylist中有size这个函数，他知道我们存放了多少个函数
    }
    public String getNote(int index){//返回某一条NoteyongString
        return notes.get(index);
    }
    
    public void removeNote(int index){//Boolean是没有意义的
        notes.remove(index);//boolean到底有没有删除成功？
    }
    
    //第一种设计list()
    //public void list(){//列出所有的东西
    //  System.out.println();
    //}
    //第二种设计返回一个string[]数组
    public String[] list(){
        //构造有个数组
        String[]a=new String[notes.size()];
//      for(int i=0;i<notes.size();i++)
//      {
//          a[i]=notes.get(i);
//      }
        notes.toArray(a);//相当于上述循环
        return a;
    }
    public static void main(String[] args) {
        Value[] a=new Value[10];
        for(int i=0;i<a.length;i++){
            a[i]=new Value();
            a[i].set(i);
        }
        for(Value v:a){
            System.out.println(v.get());
            v.set(0);
        }
        for(Value v:a){
            System.out.println(v.get());
        }
//      NoteBook nb=new NoteBook();//创建一个对象
//      nb.add("first");
//      nb.add("second");
//      nb.add("third",1);//把它放在1 的前面
//        System.out.println(nb.getSize());//2
//        System.out.println(nb.getNote(0));//fist
//        System.out.println(nb.getNote(1));//third
//        //System.out.println(nb.getSize(10));出错下标会越界
//        nb.removeNote(1);//将third移走
//        String[]a=nb.list();
//        for(String s:a){
//          System.out.println(s);
//        }
    }

}
    • 输出结果
      0
      1
      2
      3
      4
      5
      6
      7
      8
      9
      0
      0
      0
      0
      0
      0
      0
      0
      0
      0

    for-each 对象数组是能拿到管理者的

    package notebook;

import java.util.ArrayList;
class Value{
    private int i;
    public void set(int i){this.i=i;}
    public int get(){return i;}
}
public class NoteBook {
    //需要定义一个成员变量
    private ArrayList<String> notes=new ArrayList<String>();//ArrayList<>类,notes是一个对象管理者
    //private int size=0;
    
    //先来定义接口
    public void add(String s){
        //要存放很多东西可以使用是数组但是要无限制
        //要无限制的存放，应该使用容器
        notes.add(s);
        //size++;//add一次SIze加一次
        //notes.add(10);只能接受String不能接受int 
    }
    
    //上述add只是将一个东西加到后面，下面的接口可以将一些东西加载前面
    public void add(String s,int location){
        notes.add(location,s);
    }
    
    public int getSize(){//存放了多少个
    //先把接口定义出来，没有返回语句，就有错误提示
        //return size();
        return notes.size();//arraylist中有size这个函数，他知道我们存放了多少个函数
    }
    public String getNote(int index){//返回某一条NoteyongString
        return notes.get(index);
    }
    
    public void removeNote(int index){//Boolean是没有意义的
        notes.remove(index);//boolean到底有没有删除成功？
    }
    
    //第一种设计list()
    //public void list(){//列出所有的东西
    //  System.out.println();
    //}
    //第二种设计返回一个string[]数组
    public String[] list(){
        //构造有个数组
        String[]a=new String[notes.size()];
//      for(int i=0;i<notes.size();i++)
//      {
//          a[i]=notes.get(i);
//      }
        notes.toArray(a);//相当于上述循环
        return a;
    }
    public static void main(String[] args) {
        ArrayList<String>a=new ArrayList<String>();
        a.add("first");
        a.add("second");
        for(String s:a){
            System.out.println(s);
        }
//      Value[] a=new Value[10];
//      for(int i=0;i<a.length;i++){
//          a[i]=new Value();
//          a[i].set(i);
//      }
//      for(Value v:a){
//          System.out.println(v.get());
//          v.set(0);
//      }
//      for(Value v:a){
//          System.out.println(v.get());
//      }
//      NoteBook nb=new NoteBook();//创建一个对象
//      nb.add("first");
//      nb.add("second");
//      nb.add("third",1);//把它放在1 的前面
//        System.out.println(nb.getSize());//2
//        System.out.println(nb.getNote(0));//fist
//        System.out.println(nb.getNote(1));//third
//        //System.out.println(nb.getSize(10));出错下标会越界
//        nb.removeNote(1);//将third移走
//        String[]a=nb.list();
//        for(String s:a){
//          System.out.println(s);
//        }
    }

}

    输出结果是：
    first
    second
    所以说明容器；类for-each循环也可以用

    集合SET

    不重复的元素

    package notebook;

import java.util.ArrayList;
import java.util.HashSet;
class Value{
    private int i;
    public void set(int i){this.i=i;}
    public int get(){return i;}
}
public class NoteBook {
    //需要定义一个成员变量
    private ArrayList<String> notes=new ArrayList<String>();//ArrayList<>类,notes是一个对象管理者
    //private int size=0;
    
    //先来定义接口
    public void add(String s){
        //要存放很多东西可以使用是数组但是要无限制
        //要无限制的存放，应该使用容器
        notes.add(s);
        //size++;//add一次SIze加一次
        //notes.add(10);只能接受String不能接受int 
    }
    
    //上述add只是将一个东西加到后面，下面的接口可以将一些东西加载前面
    public void add(String s,int location){
        notes.add(location,s);
    }
    
    public int getSize(){//存放了多少个
    //先把接口定义出来，没有返回语句，就有错误提示
        //return size();
        return notes.size();//arraylist中有size这个函数，他知道我们存放了多少个函数
    }
    public String getNote(int index){//返回某一条NoteyongString
        return notes.get(index);
    }
    
    public void removeNote(int index){//Boolean是没有意义的
        notes.remove(index);//boolean到底有没有删除成功？
    }
    
    //第一种设计list()
    //public void list(){//列出所有的东西
    //  System.out.println();
    //}
    //第二种设计返回一个string[]数组
    public String[] list(){
        //构造有个数组
        String[]a=new String[notes.size()];
//      for(int i=0;i<notes.size();i++)
//      {
//          a[i]=notes.get(i);
//      }
        notes.toArray(a);//相当于上述循环
        return a;
    }
    public static void main(String[] args) {
        ArrayList<String>a=new ArrayList<String>();
        a.add("first");
        a.add("second");
        a.add("first");
        for(String s:a){
            System.out.println(s);
        }
        
        System.out.println("------------------");
        HashSet<String> s=new HashSet<String>();
        s.add("first");
        s.add("second");
        s.add("first");
//      for(String k:a){
//          System.out.println(k);
//      }
        System.out.println(s);
//      Value[] a=new Value[10];
//      for(int i=0;i<a.length;i++){
//          a[i]=new Value();
//          a[i].set(i);
//      }
//      for(Value v:a){
//          System.out.println(v.get());
//          v.set(0);
//      }
//      for(Value v:a){
//          System.out.println(v.get());
//      }
//      NoteBook nb=new NoteBook();//创建一个对象
//      nb.add("first");
//      nb.add("second");
//      nb.add("third",1);//把它放在1 的前面
//        System.out.println(nb.getSize());//2
//        System.out.println(nb.getNote(0));//fist
//        System.out.println(nb.getNote(1));//third
//        //System.out.println(nb.getSize(10));出错下标会越界
//        nb.removeNote(1);//将third移走
//        String[]a=nb.list();
//        for(String s:a){
//          System.out.println(s);
//        }
    }

}

    输出结果：
    first
    second
    first

    [second, first]

    HASH表

    查找金钱名称的
    1.定义接口
    键是一定唯一的
    留下的知识最后一次的

    package coins;

import java.util.HashMap;
import java.util.Scanner;

public class Coin {
    //Hash表，由一对数表示而成，key键值
    private HashMap<Integer,String>coinnames=new HashMap<Integer,String>();
    //初始化需要构造器
    
    public Coin(){
        coinnames.put(1,"penney");//coiinnames.put(key,value);
        coinnames.put(10,"dime");
        coinnames.put(25,"quater");
        coinnames.put(50,"half-dollar");
        coinnames.put(50,"五毛");
        System.out.println(coinnames.keySet().size());
        System.out.println(coinnames);
        //遍历Hash表
        for(Integer k:coinnames.keySet()){
            String s=coinnames.get(k);//拿出来元素
            System.out.println(s);
        }
    }
    public String getName(int amount){
        if(coinnames.containsKey(amount))
            return coinnames.get(amount);
        else
            return "NOT FOUND";
    }
  
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int amount=in.nextInt();
        Coin coin=new Coin();
        String name=coin.getName(amount);
        System.out.println(name);
    }

}

    输出结果是：
    10
    4
    {50=五毛, 1=penney, 25=quater, 10=dime}
    五毛
    penney
    quater
    dime
    dime

    相关文章

      网友评论

          本文标题：4.记事本

          本文链接：https://www.haomeiwen.com/subject/whsvxqtx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|4.记事本|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！