java100-138
泛型
尖括号<>引起来的参数类型，都是引用数据类型 使用了泛型后就可以确定集合中放入的数据类型，便于后续遍历 ArrayList al = new ArrayList(); <>尖括号没写东西的是钻石泛型
package generic;
import java.util.ArrayList;
public class Test1 {
public static void main(String[] args) {
ArrayList al = new ArrayList();
//集合中存入的是不同的数据，这样不利于进行限制
al.add(98);
al.add("abc");
for(Object obj: al){
System.out.println(obj);
}
}
}
引入泛型
package generic;
import java.util.ArrayList;
import java.util.Iterator;
public class Test1 {
public static void main(String[] args) {
ArrayList<Integer> al = new ArrayList<Integer>();
//加入泛型，在编译的时候就能进行检查
al.add(98);
//al.add("abc");
for(Integer i: al){//这里可以把Object改成泛型对应的类
System.out.println(i);
}
}
}
泛型类
package generic;
//这个类是泛型类
public class Test2<E> {
int age;
String name;
E sex;
public void a(E n){
}
public void b(E[] m){
}
}
class SubTest extends Test2<Integer>{
//父类指定了泛型
}
class SubTest2<E> extends Test2<E>{
//父类没有指定泛型
}
class Demo{
public static void main(String[] args) {
//父类指定了泛型后，子类就不需要再指定了，可以直接用
SubTest st = new SubTest();
st.a(12);
}
}
class Demo2{
public static void main(String[] args) {
SubTest2<String> st2 = new SubTest2<>();
st2.sex = "nv";
st2.a("abc");
}
}
class Test{
public static void main(String[] args) {
//实列化时候不指定类型，那么认为此泛型为Object
Test2 t = new Test2();
t.a(12);
t.a("abc");
t.b(new String[]{"a", "b"});
//实例化时候指定泛型为String,推荐这种方法
Test2<String> t1 = new Test2<>();
t1.sex = "nan";
t1.a("abc");
t1.b(new String[]{"123"});
}
}
泛型使用注意点
通配符？
package generic;
import java.util.ArrayList;
import java.util.List;
public class Test6 {
public void a(List<?> list){
for(Object a: list){//内部遍历的时候不用加？
System.out.println(a);
}
//数据写入操作
// list.add("abc");不能随意添加数据
list.add(null);
//数据读取操作
Object s= list.get(0);
}
}
class Demo6{
public static void main(String[] args) {
List<Object> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>();
List<Integer> list3 = new ArrayList<>();
//加入通配符？之后，可以产生继承关系
List<?> list = null;
list = list1;
list = list2;
list = list3;
}
}
泛型受限
package generic.generic2;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
//a, b, c,这三个是并列关系
List<Object> a = new ArrayList<>();
List<Person> b = new ArrayList<>();
List<Student> c = new ArrayList<>();
/*
* List<? extends Person> 是List<Person>的父类，是List<Person>子类的父类
*
List<? extends Person> list = null;
list = a;//不可以赋值
list = b;
list = c;
}
*/
//List<? super Person>相当于是是List<Person>的父类，也是是List<Person>的父类的父类
List<? super Person> list1 = null;
list1 = a;
list1 = b;
list1 = c;//不可以赋值
}
}
集合
分类：接口和存储
collection接口——List接口——ArrayList类和LinkedList类
Set接口——HashSet类和TreeSet类
存储map接口——HashMap和TreeMap
它表示一组对象 下面是collection的主要实现类 ├——-List 接口：元素按进入先后有序保存，可重复 │—————-├ LinkedList 接口实现类，链表，插入删除，没有同步，线程不安全 │—————-├ ArrayList 接口实现类， 数组，随机访问，没有同步 线程不安全 │—————-└ Vector 接口实现类 数组， 同步，线程安全 │ ———————-└ Stack 是Vector类的实现类 └——-Set 接口： 仅接收一次，不可重复，并做内部排序 ├—————-└HashSet 使用hash表（数组）存储元素 │————————└ LinkedHashSet 链表维护元素的插入次序 └ —————-TreeSet 底层实现为二叉树，元素排好序 数组与集合的区别 数组长度固定，集合长度可变 数组可以存储基本类型也可以存储引用类型，集合只能存储引用类型 数组只能存储同一种元素而集合可以存储不同的元素
List与Set的区别
List ， Set 都是继承自Collection 接口 List 特点：一个有序（元素存入集合的顺序和取出的顺序一致）容器，元素可以重复，可以插入多个null元素，元素都有索引。常用的实现类有 ArrayList、LinkedList 和 Vector。 Set 特点：一个无序（存入和取出顺序有可能不一致）容器，不可以存储重复元素，只允许存入一个null元素，必须保证元素唯一性。Set 接口常用实现类是 HashSet、LinkedHashSet 以及TreeSet。 另外 List 支持for循环，也就是通过下标来遍历，也可以用迭代器，但是set只能用迭代，因为他无序，无法用下标来取得想要的值。 Set和List对比 Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。 List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变
collection接口
package collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
public class Test1 {
public static void main(String[] args) {
//collection常用方法
//增加add, addAll
//删clear,remove
//修改
//查看iterator
//判断contains,equals,isEmpty
//创建对象，接口不能创建对象，利用实现类创建对象
//集合有一个特点，只能存放引用数据类型
Collection col = new ArrayList();
col.add(12);
col.add(13);
System.out.println(col.toString());
List<Integer> list = Arrays.asList(new Integer[] {12,34,65});
((ArrayList) col).addAll(list);
System.out.println(col);
//col.clear();
System.out.println(col);
System.out.println(col.size());
System.out.println(col.isEmpty());
boolean isRmove = col.remove(12);
System.out.println(col);
System.out.println(isRmove);
Collection col2 = new ArrayList();
col2.add(13);
System.out.println(col2);
System.out.println(col == col2);
System.out.println(col.equals(col2));
System.out.println(col.contains(13));
//遍历
for(Object o :col){
System.out.println(o);
}
//Iterator迭代器遍历
Iterator it = col.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
}
List接口
package list;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
/*
List接口中常用方法
增加：add(int index,E element)
删除：remove(int index) remove(Object o)
改： set(int index, E element)
查看：get(int index)
*/
List list = new ArrayList();
list.add(12);
list.add(45);
list.add(44);
list.add("abc");
System.out.println(list);
list.add(2,66);
System.out.println(list);
list.set(3,77);
System.out.println(list);
list.remove(2);
System.out.println(list);
list.remove("abc");
System.out.println(list);
Object o = list.get(1);//集合中有多种数据类型，所以接收是用Object
System.out.println(o);
//普通for循环遍历
for(int i =0; i <list.size(); i++){
System.out.println(list.get(i));
}
//增强for循环
for(Object object: list){
System.out.println(object);
}
//迭代器
Iterator it = list.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
}
LinkedList实现类
package linkedlist;
import java.util.Iterator;
import java.util.LinkedList;
public class Test1 {
public static void main(String[] args) {
//linkedlist常用方法
/**
* 增加 addFirst() addLast()
* offer() offerFirst() offerLast()添加到末尾
* 删除 remove() removeFirst() removeLast()
* poll() pollFirst() pollLast()
* 修改
* 查看 element()
* indexOf(Object 0) LastIndexOf()
* getFirst() getLast() peek()
* peekFirst() peekLast()
* 判断
*/
LinkedList<String> list = new LinkedList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("bbb");//可以加入重复的数据
list.addFirst("jj");
list.addLast("hh");
list.offer("kk");
list.offerLast("oo");
list.offerFirst("uu");
list.poll();//删除第一个元素
list.pollFirst();//删除第一个元素
list.pollLast();
list.remove();//删除第一个元素
list.removeFirst();
list.removeLast();
System.out.println(list);
//list.clear();
//System.out.println(list);
//System.out.println(list.poll());//这句返回null
//System.out.println(list.remove());//这句报错
//遍历
System.out.println("_______普通for循环________");
for(int i=0; i < list.size(); i++){
System.out.println(list.get(i));
}
System.out.println("________增强for循环_____________");
for(String s:list){
System.out.println(s);
}
System.out.println("______迭代器__________");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("_________迭代器节省内存___________");
for(Iterator<String> iterator1 = list.iterator(); iterator.hasNext();){
System.out.println(iterator.next());
}
}
}
迭代器
1）Iterator对象称为迭代器，主要用于遍历Collection集合中的元素。 2）所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器。 3）Iterator仅用于遍历集合，Iterator本身并不存放对象。 Idea中itit快捷键生成迭代器
import java.util.Iterator;
import java.util.TreeSet;
public class jihe {
public static void main(String[] args) {
TreeSet set = new TreeSet();
set.add("Tom");
set.add("Jerry");
set.add("Jim");
System.out.println(set);//[Jerry, Jim, Tom]
Iterator <String> iterator = set.iterator();
while (iterator.hasNext()){
String value = iterator.next();
if (value == "Tom")iterator.remove();
System.out.println(iterator.next());
//Jerry
//Jim
}
}
}
增强for循环
增强for循环可以代替Iterator迭代器，可以把它看做简化版的Iterator，和迭代器本质一样，其实它的底层实现就是Iterator迭代器，只能用于遍历集合或数组。 Idea中大写I可以快捷生成增强for循环
mport java.util.ArrayList;
import java.util.List;
public class zengqiangforxunhuan {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(11);
list.add(22);
list.add(33);
System.out.println("增强for循环遍历集合");
for (Integer i: list) {
System.out.println(i);
}
System.out.println("增强for循环遍历数组");
int[] arr = {1, 3, 4};
for(int i: arr){
System.out.println(i);
}
}
}
增强for循环底层也是使用了迭代器获取的，只不过获取迭代器由jvm完成，不需要我们获取迭代器而已，所以在使用增强for循环变量元素的过程中不准使用集合对象对集合的元素个数进行修改。
迭代器遍历元素与增强for循环变量元素的区别：使用迭代器遍历集合的元素时可以删除集合的元素，而增强for循环变量集合的元素时，不能调用迭代器的remove方法删 除 元素。
普通for循环与增强for循环的区别：普通for循环可以没有遍历的目标，而增强for循环一定要有遍历的目标。
int[] arr = {5,11,2,4,9,18};
普通for循环的遍历方式
for(int i = 0 ; i
System.out.println("元素："+ arr[i]);
}
//使用增强for循环实现
for(int item :arr){
System.out.println("元素："+ item);
}
HashSet set = new HashSet();
//添加元素
set.add("张狗蛋");
set.add("张全蛋");
set.add("张傻蛋");
//使用迭代器遍历Set的集合.
Iterator it = set.iterator();
while(it.hasNext()){
String temp = it.next();
System.out.println("元素："+ temp);
it.remove();
}
//使用增强for循环解决
for(String item : set){
System.out.println("元素："+ item);
}
Iterator(), iterator(), Iterable关系
iterator方法实现了接口Iterable,iterator的返回值类型是Iterator ArrayList集合——List接口——Collection接口——Iterable接口——抽象方法iterator(){抽象方法在ArrayList中得到实现}
public Iterator<E> iterator() {
return new Itr();
}
public interface Iterator<E> {
boolean hasNext();
E next();
default void remove() {
throw new UnsupportedOperationException("remove");
}
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
private class Itr implements Iterator<E> {
}
}
ListIterator
package iterator;
import java.util.ArrayList;
import java.util.ListIterator;
public class Test1 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("aa");
arrayList.add("bb");
arrayList.add("cc");
ListIterator<String> iterator = arrayList.listIterator();
while (iterator.hasNext()){//迭代中添加元素
if("bb".equals(iterator.next())){
iterator.add("ee");
}
}
//逆向遍历
System.out.println(iterator.hasPrevious());
while (iterator.hasPrevious()){
System.out.println(iterator.previous());
}
System.out.println(iterator.hasNext());
System.out.println(arrayList);
}
}
HashSet实现类
package set;
import java.util.HashSet;
public class Test1 {
public static void main(String[] args) {
HashSet<Integer> hs = new HashSet<>();//创建一个HashSet集合
hs.add(19);
hs.add(12);
hs.add(34);
hs.add(19);//放入的数据是唯一，无序的
System.out.println(hs.size());//3
System.out.println(hs);//[34, 19, 12]
}
}
package set;
import java.util.HashSet;
public class TestStudent {
public static void main(String[] args) {
//自定义类型不满足唯一无序特点
HashSet<Student> hs = new HashSet<>();
hs.add(new Student(12, "lili"));
hs.add(new Student(13, "vivo"));
hs.add(new Student(23, "kiki"));
hs.add(new Student(12, "lili"));
System.out.println(hs.size());//4
System.out.println(hs);//[Student{age=12, name='lili'}, Student{age=12, name='lili'}, Student{age=23, name='kiki'}, Student{age=13, name='vivo'}]
}
}
LinkedHashset实现类
package set;
import java.util.HashSet;
import java.util.LinkedHashSet;
public class Test1 {
public static void main(String[] args) {
//LinkedHashSet在HashSet基础上多了一个总链表，将放入的元素穿在一起，方便有序地遍历
LinkedHashSet<Integer> hs = new LinkedHashSet<>();//放入的数据是唯一的，有序的
hs.add(19);
hs.add(12);
hs.add(34);
hs.add(19);
System.out.println(hs.size());//3
System.out.println(hs);//[19, 12, 34]
}
}
比较器的使用
内部比较器
package set;
public class Student implements Comparable<Student>{
private int age;
private double height;
private String name;
public int getAge() {
return age;
}
public double getHeight() {
return height;
}
public String getName() {
return name;
}
public Student(int age, double height, String name) {
this.age = age;
this.height = height;
this.name = name;
}
@Override
public int compareTo(Student o) {
//内部比较器
//return this.getAge() - o.getAge();//比较int
//return ((Double)this.getHeight()).compareTo((Double)(o.getHeight()));比较double
return this.getName().compareTo(o.getName());//比较String
}
}
外部比较器
package set;
import java.lang.annotation.Target;
import java.util.Comparator;
public class Student2 {
private int age;
private double height;
private String name;
public int getAge() {
return age;
}
public double getHeight() {
return height;
}
public String getName() {
return name;
}
public Student2(int age, double height, String name) {
this.age = age;
this.height = height;
this.name = name;
}
}
//外部比较器
实际开发中外部比较器用得多
class Bijiaoqi implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
return o1.getAge()-o2.getAge();
}
}
class Bijiaoqi2 implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
return o1.getName().compareTo(o2.getName());
}
}
package set;
public class TestStudet2 {
public static void main(String[] args) {
Student s1 = new Student(10, 145.3, "lili");
Student s2 = new Student(12, 156.5, "luli");
//使用内部比较器
System.out.println(s1.compareTo(s2));
//使用外部比较器
Bijiaoqi bj1 = new Bijiaoqi();
System.out.println(bj1.compare(s1, s2));
Bijiaoqi2 bj2 = new Bijiaoqi2();
System.out.println(bj2.compare(s1, s2));
}
}
Map
Map<K,V>
HashMap
package map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test1 {
public static void main(String[] args) {
//map常用方法
/**
* 增加 put(key, value)
* 删除 remove(Object key) clear()
* 修改
* 查看 entrySet() get(Object key) keySet() size() values()
* 判断 containsKey(Object key) contains(value) equals() isEmpty()
*/
Map<String,Integer> map = new HashMap<>();
map.put("lili", 1212);
map.put("nana", 1213);
map.put("feifei", 1214);
map.put("lili", 1215);//会覆盖之前的key
System.out.println(map.size());//无序，唯一
//map.clear();
System.out.println(map);//{nana=1213, lili=1215, feifei=1214}
System.out.println(map.containsKey("lili"));
System.out.println(map.containsValue(1214));
Map<String,Integer> map2 = new HashMap<>();
map2.put("lili", 1212);
System.out.println(map.equals(map2));
System.out.println(map.isEmpty());
map.remove("lili",1212);
System.out.println(map.keySet());//[nana, lili, feifei]
System.out.println("________________");
Set<String> set = map.keySet();
for(String s: set){
System.out.println(s);
}
System.out.println("________________");
Collection<Integer> values = map.values();
for(Integer i: values){
System.out.println(i);
}
System.out.println(map.values());//[1213, 1215, 1214]
System.out.println("________________");
Set<Map.Entry<String, Integer>> entries= map.entrySet();
for(Map.Entry<String, Integer> e:entries){
System.out.println(e.getKey()+"-"+ e.getValue());
}
}
}
TreeMap
package map;
import java.util.Map;
import java.util.TreeMap;
public class Test2 {
public static void main(String[] args) {
Map<String,Integer> map = new TreeMap<>();
map.put("alili", 1212);
map.put("bnana", 1213);
map.put("bfeifei", 1214);
map.put("alili", 1215);
System.out.println(map);
}
}
package map;
public class Student implements Comparable<Student>{
private int age;
private double height;
private String name;
public int getAge() {
return age;
}
public double getHeight() {
return height;
}
public String getName() {
return name;
}
public Student(int age, double height, String name) {
this.age = age;
this.height = height;
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
", height=" + height +
", name='" + name + '\'' +
'}';
}
@Override
public int compareTo(Student o) {
//内部比较器
//return this.getAge() - o.getAge();//比较int
//return ((Double)this.getHeight()).compareTo((Double)(o.getHeight()));比较double
return this.getName().compareTo(o.getName());//比较String
}
}
package map;
import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
public class Test3 {
public static void main(String[] args) {
//匿名外部比较器
Map<Student,Integer> map = new TreeMap<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return ((Double)(o1.getHeight())).compareTo((Double)(o2.getHeight()));
}
});
map.put(new Student(12, 180.0, "1lili"), 1001);
map.put(new Student(14, 143.0, "blili"), 1002);
map.put(new Student(14, 173.0, "clili"), 1002);
System.out.println(map);
System.out.println(map.size());
}
}
TreeSet
public class jihe {
public static void main(String[] args) {
TreeSet set = new TreeSet();
set.add("Tom");
set.add("Jerry");
set.add("Jim");
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
线程
方式1：继承Thread
package buyTicket;
public class BuyTicket extends Thread {
public BuyTicket(String name){
super(name);
}
static int ticketNum = 10;
@Override
public void run(){
for (int i = 1; i <= 100 ; i++) {
if(ticketNum > 0){
System.out.println("我在"+this.getName()+"买到了第" + ticketNum--+ "张火车票");
}
}
}
}
package buyTicket;
public class Test {
//三个窗口三个线程
public static void main(String[] args) {
BuyTicket t1 = new BuyTicket("窗口1");
t1.start();
BuyTicket t2 = new BuyTicket("窗口2");
t2.start();
BuyTicket t3 = new BuyTicket("窗口3");
t3.start();
}
}
我在窗口3买到了第10张火车票
我在窗口2买到了第10张火车票
我在窗口1买到了第9张火车票
我在窗口2买到了第7张火车票
我在窗口3买到了第8张火车票
我在窗口2买到了第5张火车票
我在窗口1买到了第6张火车票
我在窗口2买到了第3张火车票
我在窗口2买到了第1张火车票
我在窗口3买到了第4张火车票
我在窗口1买到了第2张火车票
Process finished with exit code 0
方式2：实现Runnable接口
package BuyTicket2;
public class BuyTicketThread implements Runnable{
int ticketNum = 10;
@Override
public void run(){
for (int i = 0; i <= 100 ; i++) {
if (ticketNum > 0){
System.out.println("我在"+ Thread.currentThread().getName()+"买到了"+ ticketNum-- +"张车票");
}
}
}
}
package BuyTicket2;
public class Test {
public static void main(String[] args) {
BuyTicketThread t = new BuyTicketThread();
Thread t1 = new Thread(t, "窗口1");
t1.start();
Thread t2 = new Thread(t, "窗口2");
t2.start();
Thread t3 = new Thread(t, "窗口3");
t3.start();
}
}
方式3：实现Callable 接口
package thread3;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class TestRandomNum implements Callable {
@Override
public Integer call() throws Exception{
return new Random().nextInt(10);
}
}
class Test{
public static void main(String[] args) throws ExecutionException, InterruptedException {
TestRandomNum trn = new TestRandomNum();
FutureTask ft = new FutureTask(trn);
Thread t = new Thread(ft);
t.start();
//获取线程得到的返回值
Object o = ft.get();
System.out.println(o);
}
}
设置线程优先级
package thread;
public class TestThread extends java.lang.Thread {
@Override
public void run(){
for (int i = 0; i <= 10; i++) {
System.out.print(i + "\t");
}
}
}
class TestThread2 extends java.lang.Thread {
@Override
public void run(){
for (int i = 20; i <= 30; i++) {
System.out.print(i + "\t");
}
}
}
class Test1 {
public static void main(String[] args) {
TestThread t = new TestThread();
t.setPriority(1);
t.start();
TestThread2 t2 = new TestThread2();
t2.setPriority(10);
t2.start();
}
}
项目练习
小鲨鱼记账
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
//定义一个字符串，用来接收收支的明细
String details = "";
//定义一个变量，用来接收余额
int balance = 0;
while (true){
System.out.println("-------------欢迎使用小鲨鱼记账系统----------");
System.out.println("1.收支明细");
System.out.println("2.登记收入");
System.out.println("3.登记支出");
System.out.println("4.退出");
System.out.println("请输入你要选择的功能：");
Scanner sc = new Scanner(System.in);
int choice = sc.nextInt();
while (choice!=1 && choice!=2 && choice!=3 && choice!=4){
System.out.println("请重新录入");
int newChoice = sc.nextInt();
choice = newChoice;
}
switch (choice){
case 1:
System.out.println("记账系统》收支明细");
if(details != ""){
System.out.println(details.substring(0, details.length()-1));
}else {
System.out.print(details);
}
break;
case 2:
System.out.println("记账系统》登记收入");
System.out.println("请录入收入金额：");
int income = sc.nextInt();
System.out.println("请录入收入的说明：");
String incomeDetail = sc.next();
balance += income;
details = details +"收入："+income+",收入说明："+incomeDetail+",账户余额："+balance+"\n";
break;
case 3:
System.out.println("记账系统》登记支出");
System.out.println("请录入支出金额：");
int expend = sc.nextInt();
System.out.println("请录入支出说明");
String expendDetal = sc.next();
balance -= expend;
details = details +"支出："+expend+",支出说明："+expendDetal+",账户余额："+balance+"\n";
break;
case 4:
System.out.println("记账系统》退出");
System.out.println("确定要退出吗？Y/N：");
String isExit = sc.next();
switch (isExit){
case "Y":
System.out.println("系统退出，欢迎再次使用");
}
return;//结束当前程序
}
}
}
}
双色球彩票
数组，生成随机数，switch，if，while
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
int[] balls = new int[7];
int count = 0;
//定义一个变量用来设定是否购买彩票
boolean isBuy = false;
while (true){
System.out.println("------欢迎进入双色球购买系统------");
System.out.println("1.购买彩票");
System.out.println("2.查看开奖");
System.out.println("3.退出");
System.out.println("请选择你要完成的功能：");
Scanner sc = new Scanner(System.in);
int choice = sc.nextInt();
switch (choice){
case 1:
System.out.println("双色球系统》购买彩票");
System.out.println("请选择你要购买几注：");
count = sc.nextInt();
for (int i = 1; i <= 7; i++) {
if(i != 7){
System.out.println("请录入第"+i+ "个红球：");
int redBall = sc.nextInt();
balls[i-1] = redBall;
}else{
System.out.println("请录入蓝色球");
int buleBall = sc.nextInt();
balls[6] = buleBall;
}
}
System.out.println("你购买了"+count+"注彩票，一共消费了"+count*2+"元，你购买的彩票的号码为：");
for(int num:balls){
System.out.print(num+"\t");
}
System.out.println();
isBuy = true;
break;
case 2:
if(isBuy == true){
int[] lucyBall = getLucyBall();
int level = getLevel(balls, lucyBall);
switch (level){
case 1:
System.out.println("恭喜你中了一等奖，获得奖金"+count*500+"万");
break;
case 2:
System.out.println("恭喜你中了二等奖，获得奖金"+count*200+"万");
break;
case 3:
System.out.println("恭喜你中了三等奖，获得奖金"+count*100+"万");
break;
case 4:
System.out.println("恭喜你中了四等奖，获得奖金"+count*10+"万");
break;
case 5:
System.out.println("恭喜你中了五等奖，获得奖金"+count*5+"万");
break;
}
System.out.println("双色球系统》查看开奖");
}else {
System.out.println("对不起，请先购买");
}
break;
case 3:
System.out.println("双色球系统》退出");
return;
}
}
}
//定义一个方法，用来生成中将号码
public static int[] getLucyBall(){
//int[] lucyBall = {1, 2,3,4,5,6,7};
int[] lucyBall = new int[7];
for (int i = 1; i <= 7 ; i++) {
if(i !=7){
//生成1-33随机数
lucyBall[i-1] = (int)(Math.random()*33+1);
}else{
lucyBall[6] = (int)(Math.random()*16+1);
}
}
return lucyBall;
}
//定义一个方法，用来比对中将号码和购买号码
public static int getLevel(int[] balls, int[] lucyBall){
int level = 1;
//计数器，比较红球,篮球相等个数
int redCount = 0;
int bulueCount = 0;
//将购买的球一个个跟中奖号码比对
for (int i = 0; i <= 6 ; i++) {
if(i != 6){
for (int j = 0; j <= 5 ; j++) {
if(balls[i] == lucyBall[j]){
redCount ++;
}
}
}else {
if(balls[6] == lucyBall[6]){
bulueCount ++;
}
}
}
System.out.println("红球有"+redCount+"个相等");
System.out.println("蓝球有"+bulueCount+"个相等");
//根据红球篮球相等个数得到level
if(redCount==6 && bulueCount==1 ){
level = 1;
}else if(redCount==6){
level =2;
}else if(redCount==5 && bulueCount ==1) {
level = 3;
}else if(redCount==5 || (redCount ==4 && bulueCount ==1)) {
level = 4;
}else if(redCount==4 || (redCount ==3 && bulueCount ==1)) {
level = 5;
}else {
level = 6;
}
return level;
}
}
贪吃蛇小游戏
循环分支
方法的抽取
数组的使用
面向对象
继承，子类方法的重写
接口，接口的实现
图形化界面：GUI（并不流行）
GUI中的组件:窗口，弹窗，文本框，列表框，按钮，图片，监听事件
Test
package game;
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
public class GamePanel extends JPanel {
//创建面板
//蛇的长度
int length;
//定义一个数组，专门存放x,y的坐标
int[] snakerx = new int[200];
int[] snakery = new int[200];
boolean isStart = false;
String direction;
public void init(){
length = 4;
snakerx[0] = 175;
snakery[0] = 275;
snakerx[1] = 150;
snakery[1] = 275;
snakerx[2] = 125;
snakery[2] = 275;
direction = "R";
}
public GamePanel(){
init();
this.setFocusable(true);
//加入监听
this.addKeyListener(new KeyListener() {
@Override
public void keyTyped(KeyEvent e) {
}
@Override
public void keyPressed(KeyEvent e) {
}
@Override
public void keyReleased(KeyEvent e) {
}
});
}
//这个方法属于图形版的main方法
@Override
protected void paintComponent(Graphics g) {
init();
super.paintComponent(g);
//填充背景颜色
this.setBackground(new Color(159, 168, 167));
//painticon对应4个参数，this指的是当前面板，g指的是画笔，xy对应坐标
//画头部图片
Images.headerImg.paintIcon(this,g,10,10);
//调整画笔颜色
g.setColor(new Color(120, 100, 152));
//画一个矩形
g.fillRect(10,70,770,685);
//画小蛇
//画蛇头
if("R".equals(direction)){
Images.rightImg.paintIcon(this,g,snakerx[0],snakery[0]);
}
if("L".equals(direction)){
Images.leftImg.paintIcon(this,g,snakerx[0],snakery[0]);
}
if("D".equals(direction)){
Images.downImg.paintIcon(this,g,snakerx[0],snakery[0]);
}
if("U".equals(direction)){
Images.upImg.paintIcon(this,g,snakerx[0],snakery[0]);
}
Images.rightImg.paintIcon(this,g,snakerx[0],snakery[0]);
//Images.bodyImg.paintIcon(this,g ,snakerx[1],snakery[1]);
//Images.bodyImg.paintIcon(this,g ,snakerx[2],snakery[2]);
for (int i = 1; i <length; i++) {
Images.bodyImg.paintIcon(this,g ,snakerx[i],snakery[i]);
}
}
}
package game;
import javax.swing.*;
import java.net.URL;
public class Images {
//用来获取游戏中所涉及的图片
//将图片封装为一个对象
public static URL bodyURL = Images.class.getResource("/images/body.PNG");
public static ImageIcon bodyImg = new ImageIcon(bodyURL);
public static URL downURL = Images.class.getResource("/images/down.PNG");
public static ImageIcon downImg = new ImageIcon(downURL);
public static URL upURL = Images.class.getResource("/images/up.PNG");
public static ImageIcon upImg = new ImageIcon(upURL);
public static URL leftURL = Images.class.getResource("/images/left.PNG");
public static ImageIcon leftImg = new ImageIcon(leftURL);
public static URL rightURL = Images.class.getResource("/images/right.PNG");
public static ImageIcon rightImg = new ImageIcon(rightURL);
public static URL headerURL = Images.class.getResource("/images/header.PNG");
public static ImageIcon headerImg = new ImageIcon(headerURL);
}
package game;
import javax.swing.*;
import java.awt.*;
public class StartGame {
//程序的入口
public static void main(String[] args) {
//创建一个窗体
JFrame jf = new JFrame();
//给窗体一个标题
jf.setTitle("小游戏 大逻辑");
//设置窗体弹出的坐标
int width = Toolkit.getDefaultToolkit().getScreenSize().width;
int height = Toolkit.getDefaultToolkit().getScreenSize().height;
jf.setBounds((width-800)/2,(height-800)/2,800,800);
//设置窗体大小不可调节
jf.setResizable(false);
//关闭窗口的同时程序随之关闭
jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
//创建面板
GamePanel gp = new GamePanel();
jf.add(gp);
//默认情况下窗体是隐藏的，需要显示出来
jf.setVisible(true);
}
}
鼠标点击
package test;
import java.awt.*;
import java.awt.event.InputEvent;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
public class MouseHook {
public static void main(String[] args) throws AWTException {
Robot robot = new Robot();
//robot.mouseWheel(5);
//robot.mousePress(InputEvent.BUTTON1_MASK);
//robot.mouseRelease(InputEvent.BUTTON1_MASK);
//LocalDateTime now = LocalDateTime.now();
//DateTimeFormatter df = DateTimeFormatter.ofPattern("hh:mm");
//String str1 = df.format(now);
System.out.println(LocalDateTime.now());
for (int i = 1; i <= 1000 ; i++) {
String str = DateTimeFormatter.ofPattern("hh:mm").format(LocalDateTime.now());
if("06:30".equals(str)){
i = 1000;
System.out.println("到截止时间了");
}else {
robot.setAutoDelay(60000);
robot.mouseMove(500,500);
System.out.println("单击第"+ i +"次");
}
}
System.out.println("单击完成");
System.out.println(LocalDateTime.now());
}
}
