随笔档案

 1 FileWriter fw = null;
 2 try
 3 {
 4     fw = new FileWriter("src/1.txt");
 5 }
 6 catch(IOException e)
 7 {
 8     e.printStractTrace();
 9 }
10 finally
11 {
12     try{if(fw!=null)fw.close();}catch(IOException){e.printStackTrace();}
13 }

 1 --Test:序列化与反序列化..
 2 package com.java.kudy_Say;
 3 
 4 import java.io.FileNotFoundException;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 import java.io.ObjectOutputStream;
 8 import java.io.Serializable;
 9 import java.util.ArrayList;
10 import java.io.ObjectInputStream;
11 import java.io.FileInputStream;
12 /*
13     序列化与反序列化的过程
14 */
15 public class Test {
16     
17     public static void main(String[]args) throws FileNotFoundException, IOException,ClassNotFoundException
18     {
19             
20 /*        Student s1 = new Student("张三",18);
21         Student s2 = new Student("王五",19);
22         Student s3 = new Student("李四",20);
23         Student s4 = new Student("大毛",21);
24         ObjectOutputStream oos = 
25                 new ObjectOutputStream(new FileOutputStream("f:/a.txt"));
26         ArrayList<Student> al = new ArrayList<Student>();
27         al.add(s1);
28         al.add(s2);
29         al.add(s3);
30         al.add(s4);
31         oos.writeObject(al);
32         oos.close();//关闭流
33         //首先我们把内容放到一个集合里面去
34 */
35         ObjectInputStream ois = 
36                 new ObjectInputStream(new FileInputStream("f:/a.txt"));
37         ArrayList<Student> al = (ArrayList<Student>)ois.readObject();
38         for(Student s :al)
39             System.out.println(s);
40         ois.close();
41     
42     
43         
44     }
45 }
46 
47 //必须要实现一个类
48 class Student implements Serializable
49 {
50     private String name;
51     private int age;
52     Student(){}
53     Student(String name,int age)
54     {
55         this.name = name;
56         this.age = age;
57     }
58     public String toString()
59     {
60         return name+"@"+age;
61     }
62 }

 1 package com.javami.kudy.Code13;
 2 import java.io.IOException;
 3 import java.io.Reader;  //读取字符流的抽象类
 4 import java.io.IOException;
 5 /*
 6  * 自定义MyBufferedReader包装Reader,提供了一个缓冲区的功能.提供了ReadLine功能.
 7  * 1.用一个次组合,拿到被包装的Reader对象
 8  * 2.定义一个字符数组作为缓冲区
 9  * 3.实现一个read方法,填充缓冲区,从缓冲区那里返回一个字符
10  * 4.定义一个readLine方法,内部调用read方法,循环读取一行,进行返回
11  * 5.定义一个close方法,关闭地底层所包装的流
12  */
13 public class MyBufferedReader  extends Reader{
14     private Reader r;
15     char[] buf = new char[1024];
16     int len =0;
17     int pos = 0;
18     public MyBufferedReader(Reader r)
19     {
20         this.r = r;
21     }
22     /*
23      * 实现read()方法,实现缓存的功能
24      * 分析:
25      * 1.当别人第一次调用该方法的时,一次性的去填充缓冲区
26      * 2.定义一个len变量记住缓冲区的可用字符的数量
27      * 3.将数组的第一个元素返回
28      * 4.当别人第二次调用的时,将数组的二个元素返回
29      * 5.每次返回元素 len --
30      * 6.当len为零时,说明数组没有可用字符啦,那么这时候返回一个-1
31      * 
32      * 思路:
33      * 1.定义两个成员变量,len记住可用字符数量,pos记住当前字符的角标
34      * 2.判断len是否为0,如果为零要填充缓冲区.并且pos为零
35      * 3.判断len,如果为-1,则返回-1
36      * 4.将pos位置的元素返回.pos++
37      */
38     public int read() throws IOException
39     {
40         if(len ==0)
41         {
42             len = r.read(buf);
43             pos = 0;
44         }
45         if(len==-1)
46             return -1;
47         len--;
48         return buf[pos++];
49     }
50     
51     /*
52      * 实现readLine方法,实现读一行的功能,
53      * 1.循环调用自己的方法的read方法,读取字符
54      * 2.知道回车的字符,方法就结束
55      */ 
56     public String readLine() throws IOException
57     {
58         StringBuilder sb = new StringBuilder();
59         int ch;
60         while((ch=read())!=-1)
61         {
62             if(ch=='\r')
63                 continue;
64             if(ch=='\n')
65                 break;
66             sb.append((char)ch);
67             if(ch==-1&&sb.length()==0)
68                 return null;
69         }
70         return sb.toString(); //转换成字符串
71     }
72     @Override
73     public void close() throws IOException {
74         r.close();
75     }
76 
77     @Override
78     public int read(char[] cbuf, int off, int len) throws IOException {
79         int count=0;
80         for(int i=0; i<off+len; i++)
81         {
82             int ch = read();
83             if(ch==-1)
84                 break;
85             count++;
86             buf[i] = (char)ch;
87         }
88         return count;
89     }
90 
91     
92     
93 }

 1 package com.javami.kudy.Code13;
 2 import java.io.IOException;
 3 import java.io.Writer;
 4 
 5 public class MyBufferedWriter  extends Writer{
 6     
 7     private Writer w;
 8     private char[] buf = new char[1024];
 9     private int pos = 0;
10     
11     public MyBufferedWriter(Writer w)
12     {
13         this.w = w;
14     }
15     /*
16      * 定义Writer方法,实现写一个字符,实现缓存的功能
17      * 1.定义一个变量pos记住当前的写入位置
18      * 2.每次调用都使用这个方法都会传入一个字符,将字符缓存到数组pos位置里面去
19      * 3.pos++
20      * 4.每次上来就判断,如果pos =1024,刷新缓冲区 ,pos = 0
21      */
22     public void Writer(int ch)throws IOException
23     {
24         if(pos == 1024)
25         {
26             flush(); //刷新一下缓冲区.并且初始化为零
27             pos = 0;
28         }
29         buf[pos++] = (char)ch;
30     }
31     @Override
32     public void close() throws IOException {
33         flush();
34         w.close();
35     }
36 
37     @Override
38     public void flush() throws IOException { 
39         w.write(buf,0,pos); //把buf0-pos位置的内容写入进去
40     }
41     public void writer(String data)throws IOException
42     {
43         char[] chars = data.toCharArray(); //转换成字符
44         for(char c : chars)
45             write(c);
46     }
47     public void newline()throws IOException
48     {
49         write("\r\n"); //所谓的换行就是一个
50     }
51     @Override
52     public void write(char[] cbuf, int off, int len) throws IOException {
53         for(int i=0; i<off+len; i++)
54         {
55             w.write(buf[i]);
56         }
57         
58     }
59 
60 }

 1 package com.javami.kudy.Code13;
 2 import java.io.IOException;
 3 import java.io.Reader;
 4 import java.io.Writer;
 5 public class CloseUtil {
 6     private CloseUtil(){}
 7     public static void close(Reader r,Writer w)throws IOException
 8     {
 9         try
10         {
11             if(r!=null)
12                 r.close();
13         }
14         finally
15         {
16             if(w!=null)
17             w.close();
18         }
19     }
20 }

 1 package com.javami.kudy.Code13;
 2 import java.io.FileReader;
 3 import java.io.FileWriter;
 4 import java.io.IOException;
 5 
 6 public abstract class BufferedTest {
 7 
 8     /**
 9      * @param args
10      */
11     public static void main(String[] args)
12     {
13         MyBufferedReader mr = null;
14         MyBufferedWriter mw = null;
15         try
16         {
17             mr = new MyBufferedReader(new FileReader("src/a.txt"));
18             mw = new MyBufferedWriter(new FileWriter("src/b.txt"));
19             int len;
20             while((len=mr.read())!=-1)
21             {
22                 mw.Writer(len);
23             }
24         }
25         catch(IOException e)
26         {
27             e.printStackTrace();
28         }
29         finally
30         {
31             try
32             {
33                 CloseUtil.close(mr, mw);
34             }
35             catch(IOException e)
36             {
37         }
38         }
39     }
40 }

  1 Collections 的应用:
  2 
  3 1.
  4 package com.javami.kudyMap;
  5 import java.util.ArrayList;
  6 import java.util.Collections;
  7 import java.util.Comparator;
  8 import java.util.List;
  9 public class ColletionsTest {
 10     public static void main(String[]args)
 11     {
 12         /*
 13          * Collections工具类:提供关于集合的常用操作.
 14          */
 15         ArrayList<String> al = new ArrayList<String>();
 16         al.add("ab");
 17         al.add("aadc");
 18         al.add("aaa");
 19         al.add("hgdfakjg");
 20         al.add("xhyns");
 21         al.add("yyiouop");
 22         al.add("qq");
 23         al.add("zdff");
 24         
 25         /*
 26         for(String s : al)
 27             System.out.println(s+" ");
 28         */
 29         
 30         /*Collections.sort(al);  //list是一个接口  父类型的应用可以指向子类型的对象..
 31         for(String s : al)
 32             System.out.println(s+" ");*/
 33         Collections.sort(al, new StringComparator());
 34         /*
 35          * 第一种方法 : 通过比较器来对比排序   可以在构造方法里面.
 36          * 或者在对象里面实现这个比较器.当new 这个实现接口.它会自动调用比较器的方法进行比较
 37         */
 38         System.out.println("通过StringComparator()方法已经排序好-----");
 39         for(String s : al)
 40             System.out.print(s+" ");
 41         /*
 42          * 使用了API里面的方法!
 43         //binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 
 44         int pos = Collections.binarySearch(al,"aaa",new StringComparator());
 45         System.out.println(pos);//因为我们需要通过比较才可以!
 46         */
 47         int pos = MyCollections.binarySearch(al,"dasdas",new StringComparator());
 48         System.out.println(pos);
 49     }
 50     
 51 }
 52 
 53 /*
 54  * 比较器: 先比较  长短,再比较顺序
 55  */
 56 class StringComparator implements Comparator<String>
 57 {
 58 
 59     @Override
 60     public int compare(String s1, String s2)
 61     {
 62         //首先比较长度,再按照字典顺序
 63         int num = s1.length()- s2.length();
 64         if(num !=0)
 65             return num;
 66         return s1.compareTo(s2);
 67         
 68     }
 69     
 70 }
 71 
 72 //实现一个二分查找
 73 class MyCollections
 74 {
 75     private MyCollections(){}//私有化
 76     public static<T> int binarySearch(List<T> l,T key,Comparator<T> com)
 77     {
 78         int min = 0;
 79         int max = l.size()-1;
 80         int mid = 0;
 81         while(max >=min)
 82         {
 83             mid = (min+max) / 2;
 84             //判断比较器里面有没有!
 85             if(com.compare(key,l.get(mid))>0)//找到集合位置的值
 86                 min = mid+1;
 87             else if(com.compare(key, l.get(mid))<0)
 88                 max = mid-1;
 89             else
 90                 return mid;
 91         }
 92         
 93         //判断mid位置的元素和key的大小
 94         if(com.compare(key, l.get(mid))>0)
 95             return -mid-2;
 96         return -mid-1;
 97             
 98     }
 99 }
100 
101 2.必须要通过比较器比较才能实现二分查找:
102 
103 package com.javami.kudyAPI;
104 import java.util.ArrayList;
105 import java.util.Collections;
106 import java.util.Comparator;
107 
108 public class Test {
109     public static void main(String[]args)
110     {
111         ArrayList<String> al = new ArrayList<String>();
112         al.add("as");
113         al.add("scx");
114         al.add("dsad");
115         al.add("hellsda");
116         al.add("dsazxc");
117         al.add("dascxxc");
118         //在通过二分查找之前我们要经过排序'
119         System.out.println("还没有排序之前");
120         for(String s : al)
121             System.out.print(s+" ");
122         
123         
124         //第二部 : 当你调用二分查找之后.会调用比较器进行比较.是经过排序后的才可以进行二分查找
125         //比较器一定要传过来
126         int num = Collections.binarySearch(al, "dsaas",new Comparator<String>(){
127 
128             @Override
129             public int compare(String s1, String s2) {
130                 int num = s1.length() - s2.length();//比较长度
131                 if(num != 0)
132                     return num;
133                 return s1.compareTo(s2); //按字典顺序排
134             }
135             
136         });
137         System.out.println(num+1);
138     }
139 }
140 
141 
142 日期的应用:
143 
144 package com.javami.kudyAPI;
145 import java.util.Calendar;
146 public class CalendarTest {
147 
148     /**
149      * @param args
150      */
151 
152     public static void main(String[] args)
153     {
154         Calendar calendar = Calendar.getInstance();
155         printCalendar(calendar);
156         int nums = getDayNum(2012);
157         System.out.println(nums);
158         
159         //----------------
160         Calendar startDay = Calendar.getInstance();//获取当前的日历
161         Calendar finishDay = getFinishDay(startDay);
162         int num = finishDay.get(Calendar.DAY_OF_YEAR) - calendar.get(Calendar.DAY_OF_YEAR);
163         System.out.println(num+"天数");
164     }
165     
166     //计算出某年的2月份有多少天
167     public static int getDayNum(int year)
168     {
169         //1.获取一个日历
170         Calendar calendar = Calendar.getInstance();
171         
172         /*
173          * set(int year, int month, int date) 
174           设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。
175          */
176         calendar.set(year,2,1); //2月份其实就是中国的三月
177         //日历字段  DAY_OF_YEAR获取到年中的月份  , -1  其实就是2月份
178         calendar.add(Calendar.DAY_OF_YEAR,-1);
179         return calendar.get(Calendar.DAY_OF_MONTH); //获取到二月份的天数
180     }
181     
182     //一个项目做100天，周末休息，五一和十一各休息一天，今天开始做，哪天完工
183     //一个项目做100天，周末休息，五一和十一各休息一天，今天开始做，哪天完工
184     public static Calendar getFinishDay(Calendar c) {
185         for(int i=0; i<100; i++) {
186             
187             //如果是星期六或者星期天(get 和 set 的字段数字，指示一个星期中的某天。)
188             if(c.get(Calendar.DAY_OF_WEEK)==1||c.get(Calendar.DAY_OF_WEEK)==7)
189                 i--;
190             //(get 和 set 的字段数字，指示一个月中的某天。)
191             else if(c.get(c.DAY_OF_MONTH)==1&&(c.get(c.MONTH)==4||c.get(c.MONTH)==9))
192                 i--;
193             c.add(Calendar.DAY_OF_YEAR, 1);
194         }
195         return c;
196     }
197     //代表是一个时间
198     public static void printCalendar(Calendar calendar)
199     {
200         int year = calendar.get(calendar.YEAR); //年
201         int month = calendar.get(calendar.MONTH); //月
202         int day = calendar.get(calendar.WEEK_OF_MONTH);//日
203         int week = calendar.get(calendar.DAY_OF_WEEK);//星期
204         int hour = calendar.get(calendar.HOUR_OF_DAY); //时间
205         int minute = calendar.get(calendar.MINUTE);//分
206             
207         String StringWeek = null;
208         switch(week)
209         {
210         
211             case 1:
212                     StringWeek = "星期天";
213                     break;
214             case 2:
215                     StringWeek = "星期一";
216                     break;
217             case 3:
218                     StringWeek = "星期二";
219                     break;
220             case 4:
221                     StringWeek = "星期三";
222                     break;
223             case 5:
224                     StringWeek = "星期四";
225                     break;
226             case 6:
227                     StringWeek = "星期五";
228                     break;
229             case 7:
230                     StringWeek = "星期六";
231                     break;
232         }
233         //并接成字符串
234         String str = ""+year+"-"+(month+1)+"-"+day+"-"+week+"-"+hour+"-"+minute;
235         System.out.println(str);
236     }
237 
238 
239 }

 1 package com.javami.kudy.javaapin.StringStudy;
 2 
 3 public class Test {
 4         public static void main(String[]args)
 5         {
 6             show(33,45,7657,332,11,5465);
 7         }
 8         
 9         public static void show(int ... i)
10         {
11             for(int num : i)
12                 System.out.println(num);
13         }
14 }

package com.javami.kudy.javaapi1.StringStudy;

public class StringDemo {
    /*面试题：
     * 1.Stirng s = "abc" String s = new String("abc"); //有什么区别?
     * 2.String s = new String("abc"); 创建了几个对象 2个(池里没有)或1个(池里有了)，
     * 3.String s = "a" + "b" + "c" + "d"; 创建了几个对象？ 创建了1个对象
     * 4.String s1 = "a"; String s2 = "b"; String s3 = s1 + s2;  s3=="ab"?
     */
    
    public static void main(String[]args)
    {
        /*
         * 1.String池,由于字符串操作很频繁.java针对String对象提供了缓冲池
         * s1首先会在缓冲池里面看一下有没有"abc" 如果没有的.那么把对象创建的引用返回给s1
         * 当s2开始执行.会检查缓冲池里面有没有.如果有的.直接把对象的地址返回给s2 .所以是相等的.。
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);
        */
        
        /*
        String s1 = "abc";
        String s2 = new String(s1); 
        outcome ： false
        s2在堆内存中创建了一个对象(把地址返回来~),并且在堆内存里面的缓冲池里面创建一个"abc"(这个是对象里面的一个拷贝副本)
        做java的日常维护.所以那么这两个地址一比较.就会不相等..
        */
        
        /*
        String s1 = "a"+"b"+"c";
        String s2 ="abc";
        outCome = "true";
        因为java编译器有个合并已知量的功能,在编译阶段"a"+"b"+"c" 合并为"abc"并且保存在缓冲池里面
        所以s2在检测缓冲池里面.检测到已经有了.直接把对象的引用所返回来.那么证明了s1  s2 是同一个地址/所以比较出来为true
        */
        
        /*
        String s1 = new String("abc");
        String s2 = new String("abc");
        这两个里面创建了多少个对象呢?
        解答：  首先会在堆内存中创建一个对象.在检测池里面有没有,没有也在了缓冲池里面创建了一个.做日常的维护
        s2也会在堆内存中创建一个对象.这时候检测到池里面已经有了.所以就不再创建/
        说百了也就是3个..
        一般面试简单的就直接说：2个就可以.
        */
        
        /*
         * String 是一个常量,是不能改变的量
         * 内部实现：
         * StringBuilder sb = new StringBuilder(s1);
         * sb.append(s2);
         * s3 = sb.toString(); //转换回字符串
         * 返回调用方法的都是创建一个对象的
         * 
         */
        String s1 = "a";
        String s2 = "b";
        String s3 = s1 + s2;
        System.out.println(s3=="ab"); //直接返回一个flase
        
    }

}

package com.javami.kudy.javaapi1.StringStudy;

import java.io.UnsupportedEncodingException;

public class DecodeTest {
    
    /*
     * 解码： 用错误的码再变回来.然后用正确的编码方式就可以
     * 编码错误： 没办法,神仙也救不了
     */
    public static void main(String[]args) throws UnsupportedEncodingException
    {
        String str1 = "中国人";  //使用gb2312编码
        // 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
        byte[] newbyte = str1.getBytes();
        
        String str2 = new String(newbyte);
        System.out.println(str2);
        
        
        String str3 = new String(newbyte,"iso-8859-1");
        //System.out.println(str3);编码的信息出错
        newbyte = str3.getBytes("iso-8859-1");    
        String str4 = new String(newbyte);
        System.out.println(str4);
        
        byte[]new1 = str1.getBytes("iso-8859-1");
        //一开始编码的信息就出错!因为我的计算机根本就没有这个编码
        String s6 = new String(new1);
        new1 = s6.getBytes("iso-8859-1");
        String st7 = new String(new1);
        System.out.println(st7);
    }
}

package com.javami.kudy.javaapi1.StringStudy;

public class StringTest {
    /*String 为什么要重写toString()方法呢?
        解答：因为在String如果不重写Object的toString方法.那么直接复用父类的方法.打印出的是对象.
        这显然不是String想要得到的结果
     */
        public static void main(String[]args) 
        {
            String s1 = "kudy";
            System.out.println(s1.charAt(3)); //索引是从零开始\
            String s2 ="abcde";
            String s3 = "aBcddddd";
            System.out.println(s2.compareToIgnoreCase(s3));
            
            String s4 = "abc";
            String s5 = "def";
            System.out.println((s4.concat(s5)).toString());
            
            boolean is = s4.contains(s5);
            System.out.println(is);
            
            String fileName = "Demo.jdk";
            if(fileName.endsWith(".java"))
                    System.out.println("您是java文件");
            
            String s6 = "cnabcdbvklabcjdhfabcdhla";
            int newint = s6.indexOf("abc",0);  //注意：索引是从零开始
            System.out.println(newint);
            
            String s7 = "abc";
            String s8 = new String("abc");
            s8.intern();
            System.out.println(s7 == s8);
            
            String s9 = "cascascacvdfdjkgksd";
            int num = s9.lastIndexOf("k",s9.length()-1);
            System.out.println(num);
            
            String s10 = "abc";
            String s11 = s10.replace("abc","***");
            System.out.println(s11);
            
            String s12 = "hello.java";
            String s13 = s12.replace("java","jdk" );
            System.out.println(s13);
            
            
            /*
             * 把有逗号的内容去掉。
             */
            String s14 = "ab,cd,ef";
            String [] s15 = s14.split(",");
            for(String num1 : s15)
                    System.out.print(num1);
            
            String s16 = "abcbsbdasdas";
            char[] newchar = s16.toCharArray();
            for(char num2 : newchar)
                    System.out.print(num2);
            System.out.println();
            
            /*
             * 但注意中间的是不能去掉的~~
             */
            String s17 = "   abc      def     ";
            String s18 = s17.trim();
            System.out.println(s18);
        }
}

  1 package com.javami.kudy.javaapi1.StringStudy;
  2 
  3 import java.io.IOException;
  4 
  5 public class StringUtil {
  6     private StringUtil(){} //私有化
  7     
  8     /* 查找子字符串在字符串中出现的位置 例：“ab”在"habjklabljhlabhjdjfla"出现的位置为：1 6  12 
  9      * 思路：
 10      * 1.定义一个StringBuilder容器，用于存储位置，定义一个pos变量记住出现的位置，初始值为0
 11      * 2.定义一个while循环，查找子串出现的位置
 12      * 3.调用indexOf方法，从起始位置开始查找出子串首次出现的位置
 13      * 4.如果pos为-1，说明没找到，应该结束循环
 14      * 5.将位置存入StringBuilder容器，再加一个逗号分隔
 15      * 6.从找到的位置加上子串的长度作为新的起始位置，
 16      * 7.循环结束，将StringBuffer转为String字符串，调用split方法以逗号进行分隔，获得了String数组
 17      * 8.准备一个新的int数组，长度和String数组一样，遍历String数组，将每个元素转为int存入int数组
 18      */
 19     public static int[]findIndexOfSubstr(String str, String substr)
 20     {
 21         StringBuilder sb = new StringBuilder();
 22         int pos = 0;
 23         while(true)
 24         {
 25              pos = str.indexOf(substr,pos);
 26              if(pos ==-1)
 27                  break;
 28              sb.append(pos+",");
 29              pos+=substr.length(); //pos假设找ab 找到1 + 2 等于三.刚好从第三个开始找~
 30         }
 31         if(sb.length() == 0) //容器什么都没有！
 32             return null;  //一个都找不到
 33         String s = sb.toString(); //转换成字符串形式
 34         String[] parts = s.split(",");
 35         int[] arr = new int[parts.length];
 36         for(int i=0; i<parts.length; i++)
 37         {
 38             arr[i] = Integer.parseInt(parts[i]);
 39         }
 40         return arr;
 41     }
 42     
 43     /*
 44      * 设计一个方法，读取键盘输入的一行（只支持英文字母）
 45      * 提示：System.in.read()读取键盘上的一个字符
 46      * 思路： 
 47      * 1.定义一个容器StringBuilder容器
 48      * 2.定义一个while循环,循环读取键盘.
 49      * 3.如果读到回车或者\n 就跳出循环
 50      * 4.存入StringBuilfer容器中
 51      * 5.循环结束,返回一个toString转换为字符串
 52      */
 53         public static String readLine() throws IOException
 54         {
 55             StringBuilder sb = new StringBuilder();
 56             while(true)
 57             {
 58                 int ch = System.in.read();
 59                 if(ch == '\r')  //如果回车 跳出去
 60                     continue;
 61                 if(ch == '\n')  //等上面的执行完毕.再来
 62                     break;
 63                 sb.append((char)ch);
 64             }
 65             return sb.toString(); //转换成字符串
 66         }
 67         
 68         /*
 69          * *将给定的字节数组截取一部分，进行解码，要求输出完整的汉字，例如："abc中国人"截取6个 输出的是abc中
 70          * 思路：
 71          *     1.遍历数组被截取的部分,
 72          * 2.判断正负数，统计负数个数为count
 73          * 3.判断count的奇偶，奇数减去1，偶数不变
 74          * 4.解码
 75          * 汉字是占了2个字节?我们怎么判断它是汉字呢?
 76          * 汉字的第一位字节保证是负数!第二个是正数
 77          * 
 78          */
 79         public static String decode(byte[]buf, int len)
 80         {
 81             int count = 0;
 82             for(int i=0; i<buf.length;i++)
 83                 if(buf[i]<0)
 84                         count++; //如果第一个字节是负数的.是代表汉字马上来到.咱们+1
 85             if(count % 2 == 1)
 86                 len--;
 87             return new String(buf,0,len);
 88             /*程序流程图： 咱们输入一个buf   len = 5
 89              * for 执行5次
 90              * 因为一个汉字是占了2个字节.而第一个字节保证是负数
 91              * 如果 buf[i]里面的是负数的 count +1 = 1
 92              * 如果   % 2  等于1代表的是：   咱们len 传递进来的就减去一个字节.
 93              * 
 94              */
 95         }
 96         
 97         public static String decodeBYGBK(byte[]buf,int len)
 98         {
 99             boolean b = false; 
100             for(int i=0; i<buf.length; i++)
101                 if(b)
102                     b = false;
103                 else if(buf[i]<0)
104                     b = true;
105             if(b)
106                 len --;
107             return new String(buf,0,len);
108             
109         }
110         
111         /*
112          * 查找一个字符串出现次数最多的字符     abvjdabahabballfja   出现次数最多的为:a  6
113          * 思路：
114          * 1.调用toCharArray字符串把字符串转换成字符数组
115          * 2.定义max，用于记住出现最多字符的次数，定义一个maxChar记住出现最多的字符
116          * 3.定义一个循环，每次循环都统计一个字符出现最多的次数，每次让次数和max比.谁最大就换,结束条件。当长度的数组
117          * 为零
118          * 4.定义一个count，记住本次统计字符的次数
119          * 5.循环遍历数组，统计第一个字符出现的次数
120          * 6.让次数和max比，如果max大，让max记住它的次数，让maxchar记住当前的字符
121          * 7.将当前的字符从数组中删除
122          * ------
123          * 将此字符串转换为一个新的字符数组。
124          */
125 
126         public static char searchMaxChar(String str)
127         {
128             char[] buf = str.toCharArray();
129             int max = 0;
130             char maxChar = 0;
131             while(buf.length>0)
132             {
133                 int count = 0; //个数等于0
134                 char firstChar = buf[0];
135                 for(char c : buf)
136                     if(c ==firstChar)
137                         count++;
138                 if(count>max) //max 已经是默认记住上一个的值！
139                 {
140                     max = count;
141                     maxChar = firstChar; //如果你是最多的就让给你~~
142                 }
143                 //把当前的字符删除！
144                 buf = deleteChar(buf,firstChar,count);
145             }
146             return maxChar;
147         }
148 
149         private static char[] deleteChar(char[] buf, char firstChar, int count)
150         {
151             char[]arr = new char[buf.length-count];
152             int pos = 0;
153             for(int i=0; i<buf.length; i++)
154             {
155                 if(buf[i]==firstChar)
156                         continue;
157                 arr[pos++] = buf[i];
158             }
159             return arr;
160         }
161         /* 查找两个字符串中的最大子串  jflwertyakjfa;l    fjdlkwertyjf;ajf 最大子串：werty
162          * 1.判断出两个字符串的长短，找出较长的和较短的
163          * 2.循环遍历较短的字符串的所有子串，由长到短遍历
164          *         定义一个循环，每次遍历一种长度的子串，将i作为长度，i的取值: length~1
165          *         定义一个内层循环，具体遍历某一种长度的子串，j做为子串的开始位置， j取值：0~length-i
166          *         截取子串，substring  起始位置:j  结束位置:j+i
167          * 3.每次变量，都判断子串是否为较长的字符串的子串，如果是，直接返回
168          * 4.循环结束，依然没有返回，说明没有相同子串，返回null
169          */
170         public static String searchMaxSubStr(String s1, String s2) 
171         {
172             String longStr = s1.length() > s2.length() ? s1 : s2;
173             String shortStr = s1.length() > s2.length() ? s2 : s1; 
174             for(int i=shortStr.length(); i>0; i--)
175             {
176                 for(int j=0;j<shortStr.length()-i+1;j++)
177                 {
178                     String sub = shortStr.substring(j, j+i); //例如： abcd 放到sub里面去
179                     //abcd abc ab  a 和它里面的做一个对比  
180                     //当且仅当此字符串包含指定的 char 值序列时，返回 true。 
181                     if(longStr.contains(sub)) 
182                         //判断长的字符串里面是否包含这个
183                         return sub; //如果包含直接返回.没有包含
184                 }
185             }
186             return null;
187         }
188 }
189 
190 
191 ----------------------
192 
193 package com.javami.kudy.javaapi1.StringStudy;
194 
195 public class StringUtilTest {
196         public static void main(String[]args) throws Exception
197         {
198             /*
199             String str = "dsdcvcvxvczxbedfaacff";
200             String substr = "y";
201             //遍历a 出现的位置
202             int[]arr =  StringUtil.findIndexOfSubstr(str, substr);
203             if(arr ==null)
204             {
205                 System.out.println("找不到！");
206                 return ;
207             }
208             for(int num : arr)
209             {
210                     System.out.print(num+" ");
211             }
212             System.out.println();
213             
214             */
215             /*
216              * 再输入byte的时候就结束,不断的去读
217 
218             while(true)
219             {
220                 String str2 = StringUtil.readLine();
221                 if("bye".equals(str2))
222                     break;
223                 System.out.println(str2);
224             }
225             System.out.println("程序结束");    
226             */
227             byte[] buf = "abc中国人".getBytes();
228             //String s3 = StringUtil.decode(buf, 3);
229             String s3 = StringUtil.decodeBYGBK(buf, 5);
230             System.out.println(s3);
231             
232             char maxChar = StringUtil.searchMaxChar("dasfasdfaaaaaaaasfgdagfafgsad");
233             System.out.println(maxChar);
234             
235             String s33 = "jflwertyakjfa;l";
236             String s44 = "fjdlkwertyjf;ajf";
237             String s55 =StringUtil.searchMaxSubStr(s33,s44);
238             System.out.print(s55);
239         }
240 
241 }

 1 /*
 2     子类对象的实例化过程
 3     我们可以用一个类的变量记住它的子类的子类的实例.这时如果调用子类中的方法,只需要强制转换子类就可以
 4     没必要非得强制转换子类的子类.
 5     instanceof关键字：也可以判断子类实例也属于父类的类型.
 6 */
 7 
 8 class A
 9 {
10     A()
11     {
12         //如果程序没有写构造方法的/java会默认给它添加构造方法！
13     }
14     public void a()
15     {
16             System.out.println("a() in A");
17     }
18 }
19 
20 class B extends A
21 {
22     B()
23     {
24         super(); //默认调用父类的无参的构造方法！
25     }
26     public void a()
27     {
28             System.out.println("a()in B");
29     }
30 
31     public void b()
32     {
33             System.out.println("b()in B");
34     }
35 
36 }
37 
38 class C extends B
39 {
40     public void a()
41     {
42             System.out.println("a()in C");
43     }
44     public void b()
45     {
46             System.out.println("b()in C");
47     }
48     public void c()
49     {
50             System.out.println("C()int C");
51     }
52 }
53 class Demo 
54 {
55     public static void main(String[] args) 
56     {
57         A a = new C();
58         if(a instanceof C)
59         {
60             C c =(C)a;
61             c.c();
62         }
63         if(a instanceof B)
64         {
65             B b = (B)a;
66             b.b();
67         }
68     }
69 }

/*
    继承的细节
    1.子类不会继承与父类的私有的成员
    2.构造函数是不会被继承.
    3.只支持单继承,可以多重继承.

    ------------------
    1.以后在设计一个类的时候,父类一定要加上一个不带参数的super,否则子类实例化的时候会报错！
    为什么有这样一个机制：
    解答：别人来继承与这样一个类,一定也需要这个子类具有父类的方法.但是别人并不知道在构造函数里面做了一些特别才能实现这个
    的功能.所以java就规定子类实例化的过程中.一定会默认调用与父类的super()的构造方法.如果你在父类中没有定义一个无参的.
    那么在实例化的过程中是会容易出错的.
*/

class Person
{
    private String name ;
    public Person(String name)
    {
        this.name = name;
    }
    public  Person()
    {
            //咱们加一个无参的构造方法！
    }
    public    void eat()
    {
            System.out.println("是人都要吃东西！");
    }

}

class Student extends Person
{    
    public Student()
    {
        //不带参数的构造函数！
        super(); //默认为这个?  但是有这个父类的构造函数吗?显然没有对吧.。
    }
    public void eat()
    {
            System.out.println("抽一根");
            super.eat();
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Student st = new Student();
        st.eat();
    }
}

/*
    子类的实例化过程：子类在创建做了什么事情呢?
    解答：在创建子类的时候，会调用子类的构造函数，在子类构造函数的第一行会默认调用父类的构造函数
                在子类构造函数中如果没有显式地调用父类的构造函数.它会自动的调用父类的无参的构造函数（在这个问题上你要注意）
            我们可以在构造函数中使用this(实参)来调用自己的带参数的构造方法
            还可以用super(实参)去调用父类型的带了参数的构造方法/
            但要注意：this 与super()只能出现一次.  并且在第一行.
            如果一个构造函数调用了this ,那么就不能从第二个语句使用super()
*/


class Person
{
    private String name ;
    public Person()
    {
            System.out.println("无参的Person()被调用啦！");
    }
    public Person(String name )
    {
        this();
        System.out.println("有参的Person()被调用啦！");
        this.name = name;
    }

}

class Student extends Person
{
    private String name;
    public Student()
    {
            super("kudy");
            System.out.println("无参的Student()被调用啦~");
    }
    public Student(String name)
    {
            this();  //与super()不能同时出现
            System.out.println("有参的Student()被调用啦~");
    }

}

class Demo 
{
    public static void main(String[] args) 
    {
        new Student("abc");
    }
}


/*

输出的结构为：
--------------------------------
无参的Person()被调用啦！
有参的Person()被调用啦！
无参的Student()被调用啦~
有参的Student()被调用啦~
*/

/*
    关于多态：
                不变应万变
*/

abstract class Person
{
    public abstract void eat();
}

class Chinese extends Person
{
    public void eat()
    {
            System.out.println("中国的人还是广东人最好啦！");
    }
}
class Shop
{
    public void shopping(Person p )
    {
            System.out.println("咱们去买好东西吃！");
            p.eat();
    }
}
class Demo
{
    public static void main(String[] args) 
    {
        Shop shop = new Shop();
        shop.shopping(new Chinese());

    }
}

/*
    子类实例化的面试题！
    A1 B2 B1
*/

class A
{
    String name = "张三";
    public A()
    {
            System.out.println("A1");  //A1
    }
    public A(String name)
    {
        this();    
        System.out.println("A2");
    }
}

class B extends A
{
    String name = "王五";
    public B()
    { 
            this("张");  //如果有了this 就是默认没了super()
            System.out.println("B1");
    }
    public B(String name)
    {
    //    super();
        System.out.println("B2"); //B2
    }
}

class Demo 
{
    public static void main(String[] args) 
    {
        new B();
    }
}

/*
    覆盖父类的方法：
    子类当中覆盖父类的方法必须要和父类具有相同的方法名，具有相同的参数类型,具有相同的返回值 返回值类型一定要和
    子类的保持一直.这样就是方法的重写
    子类的方法的权限不能比父类有更严格的访问权限,因为我们经常要把子类当做父类来使用.
    子类去访问父类的方法时,会比较一下子类的访问权限.如果权限比父类小.那么就挂啦

    多态： 把子类当做父类来使用,针对父类进行方法的调用.传入不同的子类.执行的结构是一样的.
    除非父类被子类这个哥们重写啦方法~
*/
class Person
{
    public void run()
    {
            System.out.println("run() in Person");
    }
    public Person getInstance()
    {
            return new Person();
    }
}

class Student extends Person
{
    public void run()
    {
            System.out.println("happy");
            super.run(); //调用了父类的run方法！
    }
    public  Student getInstance() //权限不应该比父类的要小.  如果权限要比父类的小.那么就OH.Sorry
    {
        return new Student();
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Student stu = new Student();
        stu.run();
        run(stu);
    }
    //实现了多态！
    public static void run(Person p )
    {
         p = p.getInstance();
        p.run(); //实现了多态
    }
}

/*
final 关键字：最终的！终态的
1.被fina修饰的属性为常量,是不能被更改的.也就是说：值是不能被改变
2.final所修饰的方法不能被重写,也就是说不能被子类所覆盖
3.final修饰所修饰的类是不能被继承的！

一般fina的用法：public static fina String NAME = "kudy"; 
为什么它一般是和static一起的呢?
解答：
既然一个属性都不能被修改啦.是一个常量啦.咱们可以把他定义一个static的.在类出生的时候.它也会跟着出生.
方便.
*/
/*
final class Person
{
    //被final所修饰的类是不能被继承的！
}
*/
class Person
{
    public static final int NUM = 19 ;//给我修饰的常量是不能被修改的！
    public final void show()
    {
            System.out.println("给我修饰的方法都是不能被重写！");
    }
}
class Student extends Person
{
    /*
    public void show()
    {
            System.out.println("真的是不能被重写噢！");
    }
    */
    public void run (int num)
    {
        //先比较后自加！
        System.out.println(++num);
        System.out.println(num++); 
        //? 为多少呢?  20  //因为第一次自加1  后来第二次的时候。先输出值它自己再加1
    }
}
class  Demo
{
    public static void main(String[] args) 
    {
        Student stu = new Student();
        stu.run(stu.NUM);
    }
}

/*
    设计模式！组合
    组合：当一个对象在运作的过程中必须要用到另外一个对象的时候，然而又不是构成继承的关系的！
*/
class Guo
{
    public void heat()
    {
            System.out.println("已经自动的加热啦~");
    }
}
class Chef
{
    //吃食品的时候一定要把它加热嘛~~
    Guo guo;
    Chef(Guo guo)
    {
        this.guo = guo;
    }
    public void cook()
    {
        guo.heat();
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Chef chef = new Chef(new Guo());
        chef.cook();
    }
}

/*
    这样也是一个简单的组合！
*/
class Card
{
    public void spend()
    {
            System.out.println("一不小心就花了600RMB");
    }
}

class Person
{
    Card card ;
    public Person(Card card)
    {
        this.card = card;
    }
}

class Chinese extends Person
{
    public Chinese(Card card)
    {
        super(card);
    }
}

class Shop
{
    public void Shopping(Person p )
    {
        System.out.println("happy完毕！");
        p.card.spend();
    }
}

class  Demo
{
    public static void main(String[] args) 
    {
        Shop shop = new Shop();
        shop.Shopping(new Chinese(new Card()));
    }
}

/*
    抽象类：

1.没有方法体必须要声明为abstract抽象方法
2.含有抽象方法的类一定是抽象类
3.抽象类的定义：用abstract修饰的类叫做抽象类
4.抽象类是不能被实例化的(也就是说不能创建对象！);
5.可以用一个抽象类来继承一个抽象类.会继承所有的方法
6.如果用一个类来继承抽象类,那么必须要实现抽象类里面所有的方法
7.抽象类的访问权限没有什么特殊之处.主要是看修饰符！
8.抽象类里面不一定有抽象方法.但是包含有抽象方法一定是抽象类
*/

abstract class A
{
    abstract void a();//抽象方法!
    public void run()
    {
            System.out.println("A run()");
    }
}

abstract class B extends A
{
    abstract void b();
}

class C extends B
{
    //必须要把它所继承的所有的抽象方法实现！
    public void a()
    {
            System.out.println("A.class");
    }
    public void b()
    {
            System.out.println("B.class"); //实现B
    }
}
class  Demo
{
    public static void main(String[] args) 
    {
        A a = new C();
        if(a instanceof C)
        {
            C c = (C)a;
            c.a();
            c.b();
            c.run();
        }
    }
}

/*
    如果有多个类具有相同的方法声明,但是方法的实现细节不一样.
    我们就需要定义抽象类. 抽象父类

    里面可用到的新学习的知识  ： 组合哦
*/

abstract class Person
{
    public abstract void eat();
    public void run()
    {
            System.out.println("吃完饭跑步是最好的！");
    }
}

class Man extends Person
{
    public void eat()
    {
            System.out.println("大口大口的吃！");
    }
}

class WoMan extends Person
{
    public void eat()
    {
            System.out.println("小口小口的吃！");
    }
}

class Begin
{
    private Person p;
    public  Begin(Person p)
    {
        this.p = p;
    }
    public void getBegin()
    {
        p.eat();
        p.run();
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Begin begin = new Begin(new Man());
        begin.getBegin();
    }
}

//甲写的代码

class C
{
    public void run(A a)
    {
        a.c();
    }
}
abstract class A
{
    abstract void a();
    abstract void b();
    abstract void c();  //我这里有一个C是被子类所重写啦！
    abstract void d();
    abstract void e();
    abstract void f();
}

abstract class AbstractB extends A  //需要我都可以实现！但是我用到这种方式！
{
    public void a()
    {

    }
    public void b()
    {

    }
    public void c() //哥们.你也有啊！是不是OH啦
    {

    }
    public void d()
    {

    }
    public void e()
    {

    }
    public void f()
    {

    }
}
class B extends A
{
    public void a()
    {

    }
    public void b()
    {

    }
    public void c() //哥们.你也有啊！是不是OH啦
    {
            System.out.println("c() in B");
    }
    public void d()
    {

    }
    public void e()
    {

    }
    public void f()
    {

    }
}

class  Demo
{
    public static void main(String[] args) 
    {
        /*
        C c = new C();
        c.run(new B());
        */
        C  c = new C();
        //为什么抽象的都可以new呢？但要注意.我这个是匿名内部类
        c.run(new AbstractB(){
            public void c()
            {
                    System.out.println(" AbstractB in C");
            }
        }
            );
    }
}

/*
    模板方法的设计模式：
    定义一个抽象类作为模板，将具体做事情方法定义出来，但是不实现
    2.对外提供一个共有的方法作为接口，规定做事情的顺序/这个方法应该为final 避免了让子类重写
    子类继承模板，实现所有的抽象方法()
*/

abstract class AbatractPrint
{
    abstract void opend();
    abstract void print();
    abstract void close();

    //定义成终态的.避免了子类所修改!
    public final void run()
    {
        this.opend();
        print();
        close();  //调用方法!
    }
}

class StringPrint extends AbatractPrint
{
    private String data;
    StringPrint(String data)
    {
        this.data = data;
    }
    public void opend()
    {
            System.out.print("<<");
    }
    public void print()
    {
            System.out.print(data);
    }
    public void close()
    {
            System.out.print(">>");
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        AbatractPrint abatractPrint = new StringPrint("kudy");
        abatractPrint.run();
        //使用匿名内部类做一下这道题目!
        //我现在不是为了抽象类创建对象.而是为了匿名子类!  //也多多态的一种形式！
        //匿名内部类重写了父类的方法！并且调用一把run();
        new AbatractPrint(){
                public void opend()
        {
                System.out.print("<<");
        }
        public void print()
        {
                System.out.print("show");
        }
        public void close()
        {
                System.out.print(">>");
        }
        }.run();
    }
}

//定义抽象类作为接口，实现个模块之间的解耦
/*
        首先第一种方法的：  显示就是三个人不能同时分工协作啦~~

        咱们传入的时候要注意：  我们传入的是子类.  父类型的引用指向了子类型的对象。
*/
//定义一个抽象的数据产生器!
import java.io.*;
abstract class Generator
{
    abstract String getData();
}

//定义一个抽象的数据处理器
abstract class  DataHandler
{
    abstract String    handleData(Generator generator);
}

//甲负责写数据产生器
class OneGenerator extends Generator
{
    public String getData()
    {
            return "hello";  //产生了一个数据！
    }
}

//乙所负责写的数据处理代码
class OneDataHandler extends DataHandler
{
    public String  handleData(Generator generator)
    {
        String data = generator.getData();
        return  "~~"+data+"~~"; 
    }
}

//数据产生器！
class TwoGenerator extends Generator
{
    public String getData()
    {
        return "小细加油";
    }
}

//数据处理器！
class TwoDataHandler extends DataHandler
{
    public String     handleData(Generator generator)
    {
        String data = generator.getData();
        return "~~~"+data+"~~~";
    }
}


/*
    数据显示！
*/
class Demo 
{
    public static void main(String[] args) throws Exception
    {
        BufferedReader br 
                            = new BufferedReader(new InputStreamReader(System.in));
        /*
        DataHandler data = new OneDataHandler();
        Generator gen = new OneGenerator();
        */
        //通过读取键盘获得用户使用的数据产生器名字
        System.out.println("请输入您使用的数据产生器：");
        String generatorClassName = br.readLine();
        //根据类名反射出类
        //Class class -->new Class()对象 --》class.Class
        //1-1根据类名反射出类!
        Class generatorClazz = Class.forName(generatorClassName);  //类
        //又因为返回的是object 类型/所以我们要强制转换.否则没有办法赋值。
        //根据类创建实例对象（数据产生器）
         Generator  generator=( Generator) generatorClazz.newInstance(); //类创建对象。并且是父类型的引用指向子类型的对象。

         //2.通过反射获得数据的处理器对象
         System.out.println("请输入您要使用的数据处理器：");
         String dataHandlerClassName = br.readLine();
         Class dataHandlerClazz = Class.forName(dataHandlerClassName);
         DataHandler dataHandler = (DataHandler)dataHandlerClazz.newInstance();
        String data = dataHandler.handleData(generator);
        System.out.println(data);
    }
}

/*
    内部类：
1.在类中定义的类我们称之为内部类,它是外部类的一个成员。
2.内部类可以直接访问外部类的成员,但是外部类不能直接的去调用外部类的成员、
其实内部类调用外部类的成员的时候.其实是使用到了:类名.this.变量名 来访问外部类的成员。
3.在内部类中的方法可以使用this引用调用这个方法的内部类对象.


*/
class Outer
{
    String name = "张三";
    public void run()
    {
        System.out.println("Outer is Running");
    }
    public void show()
    {
        System.out.println("My name is Outer");
        System.out.println(new Inner().age);
    }
    class Inner
    {
            int age = 19;
            public void run()
            {
                System.out.println("Inner is Running");
            }

            public void eat()
            {
                this.run();  //this.代表方法所调用的对象.它的对象是inner 所以输出的是inner
                show();  //因为创建内部类的时候.外部类的对象已经创建了.  如果虚拟机在内部类中找不到.它会到外部类去找这个show()对象.
                System.out.println(Outer.this.name); //其实同等于：Outer.this.name  //类名.name
                System.out.println("Nnner is Eat");
            }
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Outer.Inner  inner = new Outer().new Inner();  //类型要一致!
        inner.run();
        inner.eat();

    }
}

/*
    可以在方法中定义内部类?
    System.out.println(age);为什么会访问不了呢.编译出错/
    其实：当我们在外部类调用A对象的时候.run()方法由于age是存储在栈内存的临时变量中的. 当我们对象调用完毕过后呢.
    有可能是会被释放调的.而当你再次调用的时候 age 的时候呢.由于虚拟机可能会被释放.所以调用不了.
    那么：虚拟机认为你这样做是编译错误的！
*/

class A
{
    String name = "小细"    ;
    public void run()
    {    
        int age = 19;
        class B
        {
            public void run()
            {
                String name = "王五";
                System.out.println("my name is B");
                //System.out.println(age);
                System.out.println(A.this.name);  //通过类名.this.属性名访问外部类的属性.
            }
        }
        new B().run();
    }
}

class Demo 
{
    public static void main(String[] args) 
    {
        A a = new A();
        a.run();
    }
}

/*
    匿名内部类：

*/
class Fruit
{
    public void qupi()
    {

    }
}

class Person
{
    public void eat(Fruit f)
    {
        f.qupi();
        System.out.println("吃完啦！！");
    }
}

class Demo
{
    public static void main(String[] args) 
    {
        Person p = new Person();
        p.eat(new Fruit(){
            public void qupi()
            {
                System.out.println("Apple把皮弄开！");
            }
        }
            );
    }
}

/*
    static修饰的静态内部类:

    1.静态的内部类可以声明非静态的属性和方法.  但是静态的内部类是不能访问外部类非静态的方法.因为外部类的属性需要创建对象才能调用.
    你内部类是不需要创建对象的.所以调用不了。

    2.静态的内部类不能访问非静态的属性.
*/

class Outer
{
    static  String name = "kudy";
    String ID = "888";
    static class Inner
    {
            int age = 19;
            public void run()
            {
                    System.out.println(age);
                    System.out.println("Inner is happy");
                    System.out.println(Outer.name); //因为是不需要创建对象的.所以可以使用Outer.name访问外部的静态的方法。
                //    System.out.println(Outer.ID);
            }
    }
}

class Demo 
{
    public static void main(String[] args) 
    {
        Outer.Inner inner =  new  Outer.Inner();  //静态的内部类一定要静态的去创建！
        //System.out.println(inner.age);
        inner.run();

    }
}
/*
    类的继承
1.使用extends关键字来声明类的关系
2.子类会自动继承父类的属性与方法
*/

class Person
{
    String name ;
    public void run()
    {
        System.out.println("Person is Running");
    }
}

class Man extends Person
{
    public void toLike()
    {
        System.out.println(name +"运动"); //默认会添加上this的
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Man man = new Man();
        man.name = "小细";
        man.run();
        man.toLike();
    }
}
    

/*
    类的继承是为了实现代码的复用性，如果有多个类具有相同的方法.我们应该尽量把她抽出一个类来
*/
class Person
{
    String name ;
    int age;
    public void eat()
    {
        System.out.println(name+"吃饭"+",年龄为："+age);  //this.name this.age
    }
    public void run()
    {
        System.out.println("需要运动");
    }
}

class Student extends Person
{
    public void eat()
    {
        System.out.println("吃一口饭");
        super.eat();  //调用父类的方法、。
        System.out.println("看一下作业");
    }
}
class Teacher extends Person
{
    public void eat()
    {
        System.out.println("抽一根");
        super.eat();
        System.out.println("再来一根");
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Student student = new Student();
        student.name = "小细";
        student.age = 19;
        student.eat();
        student.run();

    }
}
/*
父类型的引用指向子类型的对象.也就是想上类型转换.不需要强制转换
强制转换的要求：  父类型的引用指向子类型的对象。
3.把父类当做子类来使用是不行的,因为子类有的.父类型不一定有
4.当做子类当做父类来用时,只能使用父类型所拥有的方法。
如果调用子类拥有的方法.编译器会报错！所以需要强制转换.但在强制转换的前提下我们要知道父类型的引用是否是指向了子类型的对象
强制转换之前需要判断一下.
注意：
        1.当你父类型的引用指向子类型的对象的时候.你必须要清楚的就是：你访问的属性是会是父类的.而不是子类的.
        因为java在属性方法是做了静态的绑定.谁是我的类型.我就去谁的类型去找.而方法就刚好相反.
        方法就是：谁指向谁.我就调用谁的方法.。  因为是做了动态的绑定。
*/

class Typist
{
    String name = "小细";
    public void type()
    {
        System.out.println("typeing");
    }
}

class Coder extends Typist
{
    String name = "王五";
    public void type()
    {
        System.out.println("tepeing slowly!!!");
    }
    public void code()
    {
        System.out.println("Codeing");
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        //向上类型转换： 父类型的引用指向子类型的对象.
        Typist typist = new Coder();
        //typist.type();  因为你是指向了子类型的引用.所以java做了动态绑定.也就是说你绑定了一个子类型的方法。
        System.out.println(typist.name); 
        /*
            为什么输出小细呢.因为java在检查的时候.属性是不做动态绑定的.也就是说.类型是谁.他就会找类型里面的属性.
        */
        /*
            Code code = new Typist();
            子类型的引用不能指向父类的对象.因为子类有的.父类型不一定有.
        */
        Coder coder;
        if(typist instanceof Coder)  //父类型的引用指向子类型的对象才可以抢走转换！
        {
             coder = (Coder)typist; //强制转换成子类
             System.out.println(coder.name);
        }
    
        

    }
}

/*
    因为java的属性在父类型的引用指向子类型的情况是做了静态的绑定的.所以我们可以这么做！
*/

class Person
{
    private String name = "无名氏";

    public String getName()
    {
        return name;
    }
    public void eat()
    {
        System.out.println("eating");
    }
}
class A extends Person
{
        private String name = "小细";
        public String getName()
        {
            return name;
        }
}
class B extends Person
{
        String name = "kudy";
}
class Demo
{
    public static void main(String[] args) 
    {
        Person p = new A();
        /*
            因为java的父类型的引用指向子类型的对象的时候.方法使用了动态.而属性只使用了静态.也就是说：类型是那个.属性就是从
            那里去找
        */
        System.out.println(p.getName());//这样就是调用了子类型的属性啦~~
    }
}

/*
    什么情况下使用子类当做父类来使用
    匿名内部类：new一个父类对象，后面跟一个花括号，这时不需要创建父类的实例

*/

class Person
{
 String name = "无名氏";
    public void eat()
    {
        //每个人的爱好不同！
    }
}
class    Restaurant
{
    public void run(Person p)
    {
        p.eat();
    }
}


class Chinese extends Person
{

    public void eat()
    {
        String name = "中国人";  //在方法里面是动态调用的哦。
        System.out.println(name+"我是拿筷子吃的！");
    }
}

class American extends Person
{

    public void eat()
    {
        String name = "美国人";
        System.out.println(name+"我只吃汉堡包！");
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Restaurant r = new Restaurant();
        //r.run(new American());
        r.run(new Chinese());

/*
内部类：
        class JB extends Person
        {
            public void eat()
            {
                System.out.println("我是吃垃圾的！");
            }
        }
        r.run(new JB());
*/
    r.run(getIndia());
    }
    static  Person getIndia()
    {
        String name = "印度菜";
        Person p  = new Person(){  //我创建了一个子类.子类里面有eat方法重写啦.之后呢.再把这个重写好的对象返回来.也就是说：父类型的引用指向子类型的对象
        public void eat()
            {
                System.out.println(this.name+"印度菜");
            }
        };
        return p;
    }
}

class A
{
    String name = "小三";
    public String getName()
    {
        return name;
    }
    public void run()
    {
        System.out.println(name);
    }
}

class B extends A
{
    private String name = "小四";
    public String getName()
    {
        return name;
    }
    public void run()
    {
        System.out.println(name);
    }
    public void show()
    {
        System.out.println("我是子类！");
    }
}

class Demo 
{
    public static void main(String[] args) 
    {
        A a = new B();  //父类型的引用指向子类型的对象. 就可以使用子类型与父类型所共同拥有的方法.但是子类出来的就不行。
    //    a.show();
    /*
    System.out.println(a.name);

    如果这样写出来是小三,而不是小四,但是在方法里面输出来的就是小四.因为她的属性在方法里面运行啦.所以是动态的.
    而你单独如果想输出它的属性的话,它是根据了静态绑定来进行操作.也就是输出了类型里面属性的内容!

    那方法就是： 给所有的变量私有化.给他开一个public方法.返回属性！！因为方法是可以转换为动态的.

    有的人可能会问?不相同可以吗? 如果不相同的话.前面已经说过： 就是子类型所特有的.你父类型是不可以调用.除非需要强制转换！
    */
    String name = a.getName(); //这时候方法已经给重写
    System.out.println(name); //输出的会是小四
    }
}

/*
    对象的比较：
        对象的比较不能使用 == 这样比较的是比较地址.  应该用equals方法

        因为所有的类都是默认的继承与Object！  我们可以重写它里面的equals比较方法。
*/

class Person
{
    private String name ;
    private int age ;
    public Person(String name ,int age)
    {
        this.name = name ;
        this.age = age ;
    }
    
    @Override  //告诉编译器我重写父类型的方法！  大写的O
    //重写父类的方法！
    public boolean equals(Object obj)
    {
        if(this == obj)
            return true;
        if(obj instanceof  Person)      //如果你父类型的引用是指向了子类型的对象的.那么就判断.
        {
            //因为是按照了父类型的引用是指向了子类型的对象.首先我们要判断一下.强制类型转换.要不然我们是调用不了子类型的内容
            Person p =(Person)obj;

            if(this.name.equals(p.name)&&this.age == age)
                return true;
        }
        return false;
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
    
        Person p1 = new Person("张三",19);  //p1就是当前对象！
        Person p2 = new Person("张三",19);
        System.out.println(p1.equals(p2));
        


    }
}
class Person
{
    String name ;
    public void eat()
    {
    }
}

class Restaurant
{
    public void show(Person p)
    {
        p.eat();
    }
}
class Chinese extends Person
{
    String name = "中国人";
    public void eat()
    {
        System.out.println(name+"我吃中国菜！");
    }
}

class Test 
{
    public static void main(String[] args) 
    {
        Restaurant r = new Restaurant();
        r.show(new Chinese());

        /*
            匿名内部类的第一种用法！
        */
        r.show(new Person(){
            public void eat()
            {
                System.out.println("日本人吃日本菜！");
            }
        }
        );
        r.show(getUSA());
    }

    public static Person getUSA()
    {
        Person p = new Person(){
            public void eat()
            {
                String name  = "美国人";
                System.out.println(name+"吃美国菜！");
            }
        };
        return p;
    }
}

一、判断题
1、Java语言是不区分大小写的。 错，Java语言是严格区分大小写的
2、Java程序源文件的扩展名为“.jar”。 错，Java程序源文件的扩展名为”.java” 
3、Java程序一般应含有main方法，因为它是所有java程序的入口。正确
4、声明main方法时，其声明可以写成:
Public static void main(String args[])
也可以写成：
Public static void main(String s[])   
 不正确，P不应该大写，应该小写，其他地方是正确的
6、假设有一个名为Hello的java源程序，那么编译这个文件的命令为javac Hello.java。
  正确
7、当运行java程序时，类加载器将字节码加载到内存中，字节码检验器确认所有的字节码是合法的并且不会破坏java的安全限制，然后解释器读取这些字节码并将它们翻译成计算机能够执行的语言。
正确
8、在java语言中，每个ASCII码英文字符占用8个二进制位，而每个中文汉字字符占用16个二进制位。FALSE
正确 英文字符占1个字节8位，中文字符占2个字节16位
9、short s = 64000语句是否正确。
不正确，超出short的取值范围和应该在64000后面加上分号“；”

二、填空题    
1、Sun公司提供了三种java开发工具：其用于工作站和个人计算机的标准开发工具为_
java se _____，用于企业级开发的工具为_java ee______，用于智能移动产品的工具为__ java me______。

2、Java程序中的数据类型分为哪两种_基本数据类型和引用数据类型__________________________。
8种基本数据类型 数值型（byte short int long float double）字符型 char  
布尔型 (Boolean) true 和false
引用数据类型 类，接口，数组
3、配置java开发和运行环境，通常需要配置哪两个环境变量___path_______和________classpath____。

4、在java源文件中，可以有哪几种类型的注释_____单行注释 多行注释和文档注释___________________________。

5、查看当前java虚似机版本的java命令为___java -version________。

6、设一个java源文件的名字为Test.java，则编译该文件的命令为_javac Test.java_____，运行的命令为___java Test___。

7、Java虚似机运行java程序过程为：首先从后缀为_.class____的文件加载代码到内存中，然后在内存中__字节码检验器检查______代码的合法性和安全性，然后___解释器____执行合法和安全的代码。

8、Java语言在____1995______年由____SUN______公司第一次正式发布的，__
詹姆斯•戈斯林（James Gosling）________被誉为java之父。

9、设Hello.java文件的内容如下：
class Hello
{
    static void main(String args[])
    {
        System.out.println(“Hello World!”);
    }
}
下面说法正确的是：D
A、    无法通过编译，因为main方法声明不对。
B、    可以编译，但不可以运行。
C、    可以编译，并可以输出正常结果。
D、    可以编译，但不可以运行，因为文件中没有public类。
  
10、请写出下面程序的运行结果____12_______：
public class Test
{
    public static void main(String args[])
    {
        int i = 0;
        while(true)
        {
            if(i++>10)
            {
                break;
            }
        }
        System.out.printnln(i);
    }
}
X++和++X的区别： X++是X先参与运算再自增，++X是先自增再参与运算
11、请写出下面程序的运行结果____11_______：
public class Test
{
    public static void main(String args[])
    {
        int i = 0;
        while(true)
        {
            if(++i>10)
            {
                break;
            }
        }
        System.out.printnln(i);
    }
}
12、请写出下面程序的运行结果________4________
class Test
{
    public static void main(String args[])
    {
        int a=1,b=2;
        if((a==0)&(++b==6))
            a = 100;
        System.out.println(a+b);
    }
}
（a==0）这个条件为false  （++b==6）这个条件首先b自增1后再参与比较，b变成了3，但这个条件也不成立，所以”a=100;”这个语句没有执行，最后（a+b）的值为（1+3）=4
13、请写出下面程序的运行结果_____4______________。
class Test
{
    public static int method(int x)
    {
        int j = 1;
        switch(x)
        {
            case 1:
                j++;
            case 2:
                j++;
            case 3:
                j++;
            case 4:
                j++;
            case 5:
                j++;
            default:
                j++;
        }
        return j;
    }
    public static void main(String args[])
    {
        System.out.println(method(4));
    }
}

14、请写出下面程序的运行结果_______7____________。
class Test
{
    public static void main(String args[])
    {
        int a = 2;
        switch(a)
        {
            case 1:
                a +=1;
                break;
            case 2:
                a +=2;
            case 3:
                a +=3;
                break;
            case 4:
                a +=4;
                break;
            default:
                a = 0;
        }
        System.out.println(a);
        
    }
}

三、简答题：
1、请判断下面的程序是否能正常编译并运行，如能编译请写出运行结果，如不能请改正。
    int i = 0;
    do
        System.out.println(i++);
    while(i<5);

  正确 ：结果为 0
                1
                2
3
4
2、请指出下面程序可能出现的问题。
    class Test
    {
        public static void main(String args[])
        {
            int i = 0;
            do
{
    System.out.println(i++);
}
        }
    }
没有while 语句，do语句没有中止，不是正确的写法
3、请总结break、continue和return的具体用法，并写出相应的示例程序。
break于中止当前循环中的子语句
continue 语句只能出现在循环语句中，用于跳出循环的剩余语句块，接着执行下一次循环
for(int i=0;i<10;i++)
 {
          if(i%2==0)
        {
               continue; 
        }
      System.out.println(i);
 }
return 用于结束当前执行的语句，并返回一个值
static int getMax(int num1,int num2,int num3)
    {      
         
        int max=num1>num2?num1:num2;
            max=max>num3?max:num3;
        return max ;
    }

四、程序题：
1、    请编写程序，计算1+3+5+……………………+1999的结果。
源程序：//FindSum.java
    public class FindSum
{
    public static void main(String args[])
    {
        int n = 1999 ;
        int sum = findSum(n);
        System.out.println("从0到"+n+"之间的奇数和为：");
        System.out.println("sum="+sum);
    }
    
    static int findSum(int n)
    {
        int sum=0;
        for(int i=0; i<=n; i++)
        {
            if(i%2==1)
                sum+=i;    
        }
        return sum;
    }
}
运行结果:
 
2、    请定义一个整数数组，用一种排序算法对这个数组进行排序。
 源代码：//Demo42.java
public class Demo42
{
    public static void main(String args[])
    {
        int [] num = {12,45,10,23,5,123,89,411,9,78};
        
        System.out.println("排序前：");
        arrList(num);
        
        selectSort(num);
        System.out.println("排序后：");        
        arrList(num);
        
    }
    static void selectSort(int [] arr)
    {
        for(int i=0; i<arr.length-1; i++)
        {
            int pos = i;
            int max = arr[i];
            for(int j=i+1; j<arr.length;j++)
            {
                if(arr[j]>max)
                {
                    max = arr[j];
                    pos = j;
                }
            }
            exchange(arr,i,pos);
        }
            
    }
    static void exchange(int [] arr,int pos1,int pos2)
    {
        int temp;
        temp = arr[pos1];
        arr[pos1] = arr[pos2];
        arr[pos2] = temp;
    }
    static void arrList(int [] arr)
    {
        StringBuffer sb = new StringBuffer();
        for(int i=0; i<arr.length; i++)
            sb.append(arr[i] + ",");
        sb.delete(sb.length()-1,sb.length());
        System.out.println(sb);
            
    }
}
运行结果：
 


3、    请用System.arraycopy实现数组的拷贝。
源代码：//Demo43.java
public class Demo43
{
    public static void main(String args[])
    {
        int [] num1 = {15,89,16,56,10,2,5,123,84,99,753,612};
        int [] num2 = {789,145,100,20,36,95,88,71,40,126,91,65};
        System.out.println("数组拷贝前：");
        arrList(num1);
        arrList(num2);
        
        System.arraycopy(num1,3,num2,3,6);
        System.out.println("数组拷贝后：");
        arrList(num1);
        arrList(num2);        
    }
    
    static void arrList(int [] num)
    {
        StringBuffer sb = new StringBuffer();
        for(int i=0; i<num.length; i++)
        {
            sb.append(num[i]+",");
        }
        sb.delete(sb.length()-1,sb.length());
        System.out.println(sb);
    }
}
运行结果：
 

4、    编写一个程序，程序里定义三个数，并输出这三个数的最大数。
源代码：//Demo44.java
class Demo
{
    public static void main(String args [])
    {
        int num1 = Integer.parseInt(args[0]);
        int num2 = Integer.parseInt(args[1]);
        int num3 = Integer.parseInt(args[2]);
        System.out.println("这三个数的最大值是：");
        System.out.println(getMax(num1,num2,num3));
    }
    static int getMax(int num1,int num2,int num3)
    {      
         
        int max=num1>num2?num1:num2;
            max=max>num3?max:num3;
        return max ;
    }
}

运行结果：
 
5、    编写一个程序，这个程序把一个整数数组中的每个元素用逗号连接成一个字符串，例如，根据内容为[1][2][3]的数组形成内容为“1,2,3”的字符串。 
源代码：//Demo45.java
  class arrDemo
{
    public static void main(String args [] )
    {
        int [] arr = {12,89,45,61,568,945,102,302,44,777,945,689};
        System.out.println("依次输出数组中的元素：");
        arrList(arr);
    }
    static void arrList(int [] arr)
    {
        StringBuffer sb = new StringBuffer();
        for(int i=0; i<arr.length; i++)
            sb.append(arr[i]+",");
        sb.delete(sb.length()-1,sb.length());
        System.out.println(sb);
    }
    
}
运行结果：
 
6、    编写一个程序，从键盘上接受用户输入的需要转的数，得到的一定是字符串，将此字符串转换成十进制整数，然后打印出这个十进制整数对应的二进制形式。
源代码：//Demo46.java
class appDemo
{
    public static void main (String args [])
    {
        int num = Integer.parseInt(args[0]);
        System.out.println("输入的整数为："+num);
        System.out.println("这个十进制的整数对应的二进制形式为：");
        ten2Binary(num);
    }
    static void ten2Binary(int num)
    {
        StringBuffer sb = new StringBuffer();
        while(num>0)
        {
            int temp = num%2;
            num=num/2;
            sb.append(temp);            
        }
        sb.reverse();
        System.out.println(sb);            
    }
}
运行结果：
 

7、     请用移位的方式打印出一个十进制整数的十六进制形式。提示：按每4个二进制位对整数进行移位和去高位处理，得到的结果就是十六进制数的一位，然后按下面三种方式之一（作为作业，要求每种方式都用到）计算出一个十六进制数值对应的十六进制形式： 
1)0-9之间的数值直接加上字符'0'，9以上的数值减去10以后再加上字符'A' 
2)定义一个数组，其中包含0-F这些字符，然后用要计算的数值作为数组的索引号，即可获得其对应的十六进制数据。 
3)Character.forDigit静态方法可以将一个十六进制的数字转变成其对应的字符表示形式，例如，根据数值15返回字符'F'。 
源代码：//Demo47.java
class hDemo
{
    public static void main(String args[])
    {
        int num = Integer.parseInt(args[0]);
        System.out.println("输入的整数为："+num);
        System.out.println("这个十进制整数对应的十六进制形式是：");
        ten2Hex(num);
    }
    static void ten2Hex(int num)
    {
        StringBuffer sb = new StringBuffer();
        char[] buf = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
        for(int i=0; i<8; i++)
        {
            int temp = num&0x000000000f;
            sb.append(buf[temp]);
            num=num>>4;
        }
        sb.reverse();
        System.out.println(sb);        
        
    }
}
运行结果:
 

  1 小算法复习：
  2 /*
  3     不用第三方变量交换两个数的值
  4 
  5     异或：第一个数异或第二个数，之后再把结果异或第二个数。其结果等于它本身！
  6 
  7     1.<<最高位砍掉,最低位补零
  8     （左移多少位，其实就是*2的N次方）
  9     2.>>最低位砍掉.如果最高位是1，前面就是补1,否则补0
 10     //（又移多少位，就是/2的N次方）
 11 */
 12 
 13 class Demo 
 14 {
 15     public static void main(String[] args) 
 16     {
 17         int a = 3;
 18         int b = 5;
 19 
 20         a = a ^ b;
 21         b = a ^ b;
 22         a = a ^ b ;
 23         System.out.println("a == "+a);
 24         System.out.println("b =="+b);
 25 
 26     }
 27 }
 28 /*某个培训中心要为新到的学员安排房间，假设共有x个学员，
 29 每个房间可以住6人，让你用一个公式来计算他们要住的房间数
 30 */
 31 
 32 
 33 class  Demo
 34 {
 35     public static void main(String[] args) 
 36     {
 37         int num = 48;
 38         int homeNuber = getHomeNumber(num);
 39         System.out.println("学生的个数为："+homeNuber);
 40     }
 41     static int getHomeNumber(int num)  //形式参数的初始化其实就是传递进来的参数帮他初始化啦～
 42     {
 43         return (num+5)/6;  //给一个最大的限度！
 44     }
 45 }
 46 
 47 /*
 48     利用无限循环实现0 - 9 之间的数之间的重复循环
 49 */
 50 
 51 class Demo 
 52 {
 53     public static void main(String[] args) 
 54     {
 55         int x = 0;
 56         while(true)
 57         {
 58 
 59             x = (x+1)%10;
 60             System.out.println(x);
 61         }
 62     }
 63 }
 64 
 65 /*
 66     利用小技巧把10进制转换成2进制代码！
 67 */
 68 import java.io.*;
 69 class Demo 
 70 {
 71     public static void main(String[] args) throws Exception
 72     {
 73         //读取键盘
 74         BufferedReader br = 
 75                 new BufferedReader(new InputStreamReader(System.in));
 76         System.out.println("本程序可以帮助您把十进制代码转换成二进制代码：");
 77         String line = br.readLine();
 78         int num = Integer.parseInt(line);
 79         StringBuffer sb = new StringBuffer();
 80         while(num>0)
 81         {
 82             int temp = num % 2; //获取到除以2的余数!
 83             sb.append(temp);
 84             num = num / 2; 
 85         }
 86             sb.reverse();
 87             System.out.println(sb);
 88     }
 89 }
 90 
 91 
 92 /*
 93     十进制转换成十六进制之方法一。
 94 */
 95 import java.io.*;
 96 class  Demo5
 97 {
 98     public static void main(String[] args) throws Exception
 99     {
100         BufferedReader br = 
101                             new BufferedReader(new InputStreamReader(System.in));
102 
103         System.out.println("本程序可以通过十进制转换成十六进制:");
104         
105         String line = br.readLine();
106         int num = Integer.parseInt(line);
107 
108         StringBuffer sb = new StringBuffer();
109         while(num>0)
110         {
111             int temp = num % 16;
112             if(temp>9)
113             {
114                 sb.append((char)(temp-10+'A'));
115             }else
116             {
117                 sb.append(temp);
118             }
119             num = num / 16;
120         }
121         sb.reverse();
122         System.out.println(sb);
123     }
124 }
125 
126 
127 /*
128 用移位的方法来求一个数
129 
130 十进制转换成十六进制
131 */
132 import java.io.*;
133 class Demo 
134 {
135     public static void main(String[] args) throws Exception
136     {
137         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
138         System.out.println("本程序可以帮助您从十进制转换到十六进制：");
139         String line = br.readLine();
140         int num = Integer.parseInt(line);
141         Ten2Hex(num);
142     }
143 
144     static void Ten2Hex(int num)
145     {
146         StringBuffer sb = new StringBuffer();
147         int count = 0x00000000f;
148         for(int i = 0;i<8;i++)
149         {
150             int temp = num & count;  
151             if(temp>9)
152             {
153                 sb.append((char)((temp-10)+'A'));  //类型要注意
154             }
155             else
156             {
157                 sb.append(temp);
158             }
159             num = num >>4;
160             
161         }
162         sb.reverse();
163         System.out.println("结果为："+sb);
164     }
165 }
166 
167 /*
168     打印金字塔程序！
169     求算法的时候要注意：
170     找到求第一个的规律.
171     然后循环就可以。
172 */
173 
174 
175 class Demo 
176 {
177     public static void main(String[] args) 
178     {
179         int n = 4;
180         for(int i = 0;i<n;i++)
181         {
182             for(int j = 0;j<n-i;j++)
183             {
184                     System.out.print(" ");
185             }
186             for(int k =0;k<i*2-1;k++)
187             {
188                     System.out.print("*");
189             }
190             System.out.println();
191         }
192     }
193 }
194 
195 
196 总结：
197     其实switch的参数必须是int类型的,为什么byte char short参数可以传递进来呢？
198 因为它的类型自动提升为int类型啦。也就是隐式的进行了强制转换/所以是可以的.

 1 class Test2
 2 {
 3     public static void main(String[]args)
 4     {
 5         StringBuffer sb = new StringBuffer();
 6         int num = 1234;
 7         while(num>0)
 8         {
 9             int temp = num % 16;
10             if(temp>9)
11             {
12                 sb.append((char)temp-10+'A');
13             }
14             else
15             {
16                 sb.append(temp);
17             }
18             num = num / 16;
19         }
20         System.out.println(sb);
21 
22     }
23 }