java基础增强

Posted 2020-10-13 小不点啊

1. 静态导入和自动装箱拆箱

(1).静态导入： 导入java里面类的静态成员 import static 包名 类名 静态属性/静态方法/*
(2).自动装箱拆箱：
自动装箱：把基本数据类型赋值给对应的包装类（对象）
自动拆箱：把包装类的对象赋值给对应的基本数据类型

 1 package com.study.lgs;
 2 import static java.lang.System.out;
 3 
 4 import java.util.ArrayList;
 5 import java.util.Iterator;
 6 import java.util.List;
 7 public class ZhuangXiangChaiXiang {
 8 
 9     public static void main(String[] args) {
10         // TODO Auto-generated method stub
11         //1、静态导入
12         //out.println("aaa");
13         
14         //2.自动装箱拆箱：
15         Integer i=1;//自动装箱  jdk1.5+才能这样写 否则这样写：Integer i=new Integer(1)
16         int j=i;//自动拆箱
17         
18         //3.自动装箱拆箱的典型应用
19         List l=new ArrayList();
20         l.add(1);//装箱 把对象1装到list对象l里面去
21         l.add(2);
22         l.add(3);
23     
24         //迭代器遍历输出
25         Iterator k=l.iterator();
26         while(k.hasNext()){
27             int j1=(Integer)k.next();
28             out.println(j1);
29             
30             
31         }
32         /*ArrayList<Integer> al=new ArrayList<Integer>();
33         al.add(1);
34         al.add(2);
35         al.add(3);
36         for(Integer k:al){
37             out.println(k);
38         }*/
39     }
40 
41 }

2. 增强for循环

    用途：遍历数组或者遍历实现Iterable泛型接口的集合

  1 package cn.study.lgs;
  2 import static java.lang.System.out;
  3 
  4 import java.util.ArrayList;
  5 import java.util.HashMap;
  6 import java.util.Iterator;
  7 import java.util.List;
  8 import java.util.Map;
  9 import java.util.Map.Entry;
 10 import java.util.Set;
 11 
 12 import org.junit.Test;
 13 
 14 public class StrongFor {
 15     
 16     @Test
 17     public void test1(){
 18         //1、遍历数组
 19         int i[]={1,2,3};
 20         for(int k:i){
 21             out.println(k);
 22         }
 23     }
 24     @Test
 25     public void test2(){
 26         //2、遍历集合
 27         List l=new ArrayList();
 28         l.add(1);
 29         l.add(2);
 30         l.add(3);
 31     //    l.add("aaa");
 32         
 33         for(Object o:l){
 34 //            out.println(o); //不用包装直接以对象的形式输出 也可以
 35             int i=(Integer) o;
 36             out.println(i);
 37         }
 38         }
 39     @Test
 40     public void testMap(){
 41         Map m=new HashMap();
 42         m.put("1", "aaa");
 43         m.put("2", "bbb");
 44         m.put("3", "ccc");
 45         //1、传统方案取出Map里面的值 1
 46         Set s=m.keySet();//通过keyset方法把map里面的每个key存到s里面去
 47         Iterator i=s.iterator();//迭代遍历s里面的key值
 48         while(i.hasNext()){
 49 //            String key=(String) i.next();
 50 //            String value=(String) m.get(key);
 51 //            out.println(key+"对应的值为："+value);
 52             String st=(String) i.next();
 53             System.out.println(st+ "对应的值为"+m.get(st));
 54             
 55 //            System.out.println(i.next());  //有错 两次的i.next()不一样
 56 //            System.out.println(m.get(i.next()));
 57         
 58             
 59         }
 60         
 61         
 62     }
 63     @Test
 64     public void testMap2(){
 65         Map m=new HashMap();
 66         m.put("1", "aaa");
 67         m.put("2", "bbb");
 68         m.put("3", "ccc");
 69         //1、传统方案取出Map里面的值 2
 70         Set s=m.entrySet();//通过entrySet方法把每组键值存到s中
 71         Iterator i=s.iterator();//迭代遍历输出s中的值
 72         while(i.hasNext()){
 73             Map.Entry me=(Entry) i.next();
 74             System.out.println(me.getKey()+"对应的值为"+me.getValue());
 75         }
 76         
 77         
 78         
 79     }
 80 
 81     @Test
 82     public void testMap3(){
 83         Map m=new HashMap();
 84         m.put("1", "aaa");
 85         m.put("2", "bbb");
 86         m.put("3", "ccc");
 87         //1、增强for循环 1 (keySet实现Iterable泛型接口)
 88         for(Object o:m.keySet()){
 89 //            String s=(String) o;
 90 //            String value=(String) m.get(o);
 91 //            System.out.println(o+" "+value);
 92             out.println(o+" "+m.get(o));
 93         }
 94         
 95         
 96     }
 97     @Test
 98     public void testMap4(){
 99         Map m=new HashMap();
100         m.put("1", "aaa");
101         m.put("2", "bbb");
102         m.put("3", "ccc");
103         //1、增强for循环 2 (entrySet实现Iterable泛型接口)
104         for(Object o:m.entrySet()){
105          Map.Entry me=(Entry) o;
106          System.out.println(me.getKey()+" "+me.getValue());
107         }
108         
109         
110     }
111     
112     @Test //增强for循环应该注意的问题 增强for循环只能取数组或者集合里面的数据 不能更改数据；要改数据的话只能用传统方法
113     public void test3(){
114 //        int []i=new int[]{1,2,3};
115 //        for(int j:i){
116 //            j=10;//j仅仅是指向取出来的值而已 并不能改变数组里面的值
117 //            
118 //        }
119 //        //传统方法改变数组的值
120 //        for(int j=0;j<i.length;j++){
121 //            i[j]=10;
122 //        }
123 //        out.println(i[0]);
124 //        out.println(i[1]);
125 //        out.println(i[2]);
126 //        
127 
128         List l=new ArrayList();
129         l.add("a");
130         l.add("b");
131         l.add("c");
132         for(Object k:l){
133             k="d";//k仅仅是指向取出来的值而已 并不能改变集合里面的值
134             
135         }
136         //传统方案删除集合里面的元素
137         for(int i=0;i<l.size();i++){
138             
139             l.removeAll(l);
140             
141             
142             
143         }
144         l.add("e");
145         l.add("e");
146         l.add("e");
147         System.out.println(l.get(0));
148         System.out.println(l.get(1));
149         System.out.println(l.get(2));
150         
151     
152     }
153 }

3. 可变参数

使用可变参数的精髓：就是看需要什么类型的数据，需要对象就传入对象/对象数组，需要基本数据类型就传基本数据类型/基本数组

 1 package com.study.lgs;
 2 import java.util.Arrays;
 3 import java.util.List;
 4 
 5 import org.junit.Test;
 6 
 7 public class KeBianCanShu {
 8     
 9     @Test
10     public void testSum(){
11         int []i={1,2,3};
12         sum(i);//可变参数里面可以看成一个数组，所以可以向里面传入数组i
13         sum(1,2,3);
14     }
15     //可变参数按数组方式进行处理，只能放在参数列表的最后，一个参数列表中只能有一个可变参数
16     
17     public void sum(int...nums){
18         int sum=0;
19         for(int k:nums){
20             sum+=k;
21         }
22         System.out.println(sum);
23     }
24     @Test
25     public void testArrays(){
26         List l=Arrays.asList("1","2","3");//传入普通字符串对象
27         System.out.println(l);
28         
29         String [] s={"1","2","3","4"};//传入字符数组对象
30         l=Arrays.asList(s);
31         System.out.println(l);
32         
33         //int []i={1,2,3,4,5};
34         Integer []i={1,2,3,4,5};
35         l=Arrays.asList(i);//传入基本数据类型整型数组对象 List的l会吧i数组看作一个对象，所以输出的l为一个地址，必须使用包装类的对象以对象方式传入才可输出实际的值
36         System.out.println(l);
37     }
38 
39 }

4. 枚举

4.1 枚举的作用和特性

  作用：限定某些程序运行时所需要数据的取值范围

  特性：

      (1) 枚举类也是一种特殊形式的java类

      (2) 枚举类中声明的每一个枚举值代表枚举类的一个实例对象

      (3) 与java中的普通类一样，在声明枚举类时，也可以声明属性、方法和构造函数，但枚举类的构造函数必须是私有的(因为枚举类的作用就是限定某些程序运行时所需要数据的取值范围，如果构造函数公有，别人就可以随便更改)

      (4) 枚举类也可以实现接口、继承抽象类

      (5) jdk5扩展了switch语句，它除了可以接收int,byte,char,short外，还可以接收一个枚举类型

      (6) 若枚举类只有一个枚举值，则可以单作单态设计模式使用

 1 package enumeration;
 2 
 3 import org.junit.Test;
 4 
 5 //枚举的作用：限定某些程序运行时所需要数据的取值范围
 6 enum Grade{
 7     A,B,C,D
 8 }
 9 public class DefineEnum {
10     @Test
11     public void test(){
12         DefineEnum.printGrade(Grade.A);
13     }
14     public static void printGrade(Grade a){
15         switch(a){
16         case A:
17             System.out.println("90");
18              break;
19         case B:
20             System.out.println("80");
21             break;
22         case C:
23             System.out.println("70");
24             break;
25         case D:
26             System.out.println("60");
27             break;
28         default:
29             System.out.println("传入参数有错");
30             
31         }
32     }
33 }

4.2 定义枚举的字段、构造函数、方法去封装更多的信息

 1 package enumeration;
 2 
 3 import org.junit.Test;
 4 
 5 //枚举的作用：限定某些程序运行时所需要数据的取值范围
 6 //怎样定义枚举的字段、构造函数、方法去封装更多的信息
 7 enum Grade{
 8     A("100-90"),B("89-80"),C("79-70"),D("69-60");//对枚举进行实例化
 9     private String value;//定义每个枚举类型里面存的值
10     private Grade(String value){
11         this.value=value;
12     }
13     public String getValue(){ //外部对象获取每个枚举类型里面存的值
14         return this.value;
15     }
16 }
17 public class DefineEnum {
18     @Test
19     public void test(){
20         printGrade(Grade.B);
21     }
22     public void printGrade(Grade a){
23         System.out.println(a.getValue());
24     }
25 }

4.3 带抽象方法的枚举 实例化时必须实现抽象方法

 1 package enumeration;
 2 
 3 import org.junit.Test;
 4 
 5 //枚举的作用：限定某些程序运行时所需要数据的取值范围
 6 //带抽象方法的枚举 实例化时必须实现抽象方法
 7 enum Grade{
 8     A("100-90") {
 9         @Override
10         public String getLocalValue() {
11             // TODO Auto-generated method stub
12             return "优";
13         }
14     },
15     B("89-80") {
16         @Override
17         public String getLocalValue() {
18             // TODO Auto-generated method stub
19             return "良";
20         }
21     },
22     C("79-70") {
23         @Override
24         public String getLocalValue() {
25             // TODO Auto-generated method stub
26             return "中";
27         }
28     },
29     D("69-60") {
30         @Override
31         public String getLocalValue() {
32             // TODO Auto-generated method stub
33             return "差";
34         }
35     };//对枚举进行实例化 必须实现抽象方法
36     
37     private String value;//定义每个枚举类型里面存的值
38     private Grade(String value){
39         this.value=value;
40     }
41     public String getValue(){ //外部对象获取每个枚举类型里面存的值
42         return this.value;
43     }
44     //带抽象方法的枚举
45     public abstract String getLocalValue();
46 }
47 public class DefineEnum {
48     @Test
49     public void test(){
50         printGrade(Grade.B);
51     }
52     public void printGrade(Grade a){
53         System.out.println(a.getValue());
54         System.out.println(a.getLocalValue());
55         
56     }
57 }

4.4 普通单例设计模式与枚举单例设计模式

 1 package enumeration;
 2 
 3 //定义普通单态设计模式
 4 class Single{
 5     private static Single sin=null;
 6     private Single(){}
 7     private Single(Single sin){
 8         this.sin=sin;
 9     }
10     public static Single createShiLi(){
11         if(sin==null){
12             sin=new Single();
13         }
14         return sin;
15         
16     }
17 }
18 //定义枚举类型单态设计模式 当枚举里面只有一个对象时也属于单态设计模式
19 enum EnumSingle{
20     A;//枚举中声明的每一个枚举值表示枚举类的一个实例化对象
21       //m枚举类的构造函数必须是私有的，因为枚举就是用来限制实例化的对象的，如果构造函数为公有的就可以实例化新的对象，不符合枚举规范    
22 }
23 public class DefineSingle {
24 
25     public static void main(String[] args) {
26         // TODO Auto-generated method stub
27         //普通设计模式的实例化
28         Single s1=Single.createShiLi();
29         Single s2=Single.createShiLi();
30         Single s3=Single.createShiLi();
31         System.out.println(s1);
32         System.out.println(s2);
33         System.out.println(s3);
34         
35         
36 
37     }
38 
39 }