标签：抽象方法 处理 obj map [1] out += 外部 泛型
(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 }
用途：遍历数组或者遍历实现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 }
使用可变参数的精髓：就是看需要什么类型的数据，需要对象就传入对象/对象数组，需要基本数据类型就传基本数据类型/基本数组
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.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 }
标签：抽象方法 处理 obj map [1] out += 外部 泛型
原文地址：http://www.cnblogs.com/leeSmall/p/7787075.html
