JAVA学习笔记1

原创 2012年03月23日 23:08:05

Module 1: Getting Started                           1 入门

Module 2: dentifiers, Keywords  and Types  2 标识符、关键字以及数据类型

Module 3: Expressions and Flow Control      3 表达式和流程控制

Module 4: Array                                            4 数组

Module 5: Objects and Classes                      5 对象和类

Module 6: Advanced Language Features        6 高级特性

Module 7: Exceptions                                     7 异常

Module 8: Building GUIs                               8 创建GUI界面

Module 9: The AWT Component Library        9  AWT组件库

Module 10: The AWT Event Model                 10 AWT事件模型

Module 11: JFC                                             11 JFC框架

Module 12: Applets                                        12章应用小程序

Module 13:Thread                                         13章线程

Module 14: Stream I/O and Files                        14章输入输出流和文件系统

Module 15: Networking                                 15章网络

 

1.类的组成:5部分

  *包(package几个具有相同功能的类放在一个包;没写(默认的包);只能放在第一行,最多只能写一行(一个类只放在一个包);规范:包名必须全部是小写字母

  *导入(importsystemjava.lang中,常使用,可以不用import导入

       使用了其它包的类,需要引入,本类要使用另一个类,并且这2个类不在同一包中

       *表示包中所的有类;在同一包中不需要引入;可以写多行,放在Class类声明之前

  *类的声明(public class

    一个源文件中只能包含一个public类,但是可以存多个类,文件名必须是public.java

    类名首字母必须大写;类名在有意义的基础上要简略;一般使用英文单词,但是可以使用中文

    多个单词时,每个单词的首字母都要大写

  *{类体}中的属性,变量【封装类的属性-->项目有哪些需求,特征】

  *{类体}中的方法

    main()方法,入口方法;参数名可以改,其它格式固定;要运行,测试必须写main()

    构造方法:方法名与类名相同,没有返回类型,也不是void类型

    业务方法:set(),get()方法

    方法名首字母要小写,多个字母时,从第二个字母开始首字母要大写

    方法组成:修饰符+返回类型+方法名+参数列表+抛异常+方法体  主要考虑(返回类型和参数列表)

2.Java环境的搭配:

    从官网下载JDKJavaSE)(分为windows环境下和Linux环境下)

    安装JDKjdk-6u12-windows-i586-p.exe

    配置环境变量:JAVA_HOMECLASSPATHPATH

    JAVA_HOME= C:\Program Files\Java\jdk1.6.0_12   //bin文件夹之前 java的根目录

    PATH=% JAVA_HOME %\bin;                         //path+原有路径

    CLASSPATH=.;                           //类路径,运行java路径 .代表当前路径

3.java程序的编译和运行:

  编译javac –d  . FirstJava.java

  运行java smple. FirstJava

4.3种注释符

  //单行注释符(快捷键Shift+/ 

  /* */多行注释符(快捷键Shift+Alt+/)

  /**     */文档注释  

  注意:只有文档注释 将来使用javadoc命令可以产生文档,并在文档中作为注释信息

5.标识符:类、方法和变量名称

   以字母,_$ 开头,由字母,数字,_$组成

   区分大小写

   没有长度限制

   Example: Student2getName() $99ab12

6.java中的原始类型:8

   boolean    true or false 不能用数字

   byte       8-bit integer     1个字节       8           -128—127

   char       16-bit unicode character       2个字节     16   

   double     64-bit floating-point number    8个字节     64

   float      32-bit floating-point number     4个字节     32

   int        32-bit integer                 4个字节     32

   long       64-bit integer                          8个字节      64

   short      16-bit integer                2个字节      16

 记忆:4个整数型(byteshortintlong),2个小数型,1个布尔型,1个字符型

7.String字符串

  是类,不是原始类型

  不能被继承,final

  不用\0结尾 在默认情况下字符串包含一个unicode字符序列 创建对象的方式有2种:

  1直接赋值  String name="张三";

   (2)使用构造方法创建  String name=new String("张三");

  考题:String name=new String("zhangsan")创建了几个对象?

     2个对象

  String字符串一旦创建,是定长的字符转,是不可以改变的

     String n="zhangsan";

     n=n+"1234";这样性能低,通常使用StringBufferStringBuilder

8.48个关键字

abstract     do      implements    private    throw   boolean     double                   import       protected     throws       break       else        instanceof   public     transient      byte         extends       int         return        true         case      

false         interface      short       try           catch         final       long           

static         void        char        finally          native     super       volatile

class          float        new       switch          while      continue     for       

null        synchronized   default        if           package        this

 其中instanceof是判断类型匹配的

     transient  是临时状态的

     native     是本地的

     volatile   是隔离的

     synchronized 是线程同步

9.java中的基础包:

  java.lang

  java.awt/

  javax.swing/

  java.awt.event 

  java.applet

  Java.io    //

  Java.net   //网络

  Java.util   //

10.语句用“;”结束 程序块用{}包含代码 多个空格是没有意义的 

11.整数有三种表示方法8进制(零开头),10进制,16进制(零X开头) 

  java中出现的整数默认是int  

  java中的浮点数缺省是double 

  long float32位长的浮点数   long double64位长的浮点数  

  float数字以F或者f结尾   double数字以Dd结尾

  考题: short s3=1;

           s3=s3+1; 错误 要统一类型改成S3=short(s3+1);正确

           s3+=1;   正确 相当于直接赋值

12.推荐的标识符命名规则

   类名以大写字母开头classAccount {…}  

   接口以大写字母开头interfaceAccountBase {…}  

   方法以小写字母或单词开头StringgetStudentName() {…}  

  变量以小写字母或单词开头StringstudentName;  

  常量以大写字母表示 final public static intMAX_ROW = 100;

13.编写一个老师Teacher             

       属性  namesexsalary

       方法  set get方法  main方法

       1》测试:创建两个老师,打印每个老师的信息

       2》增加方法:增加工资方法 addSalary方法,实现工资增加500功能,测试

       3》增加方法:增加工资方法 addSalary2方法,实现工资可以任意增加功能,测试

  public class Teacher{

       private String name;

       private String sex;

       private double salary;

       public Teacher(){}   //无参数构造方法

       public Teacher(String name,String sex,double salary){    //带参数构造方法

              this.name=name;   

              this.sex=sex;

              this.salary=salary;         

       }

       public  void setName(String name){

              name=name;

       }

       public String getName(){

              return name;

       }

       public void setSex(String sex){

              sex=sex;

       }

       public String getSex(){

              return sex;

       }

       public void setSalary(double salary){

              salary=salary;

       }

      public double getSalary(){

              return salary;        

 

        public String toString(){       //重写toString()方法

              return name+" "+sex+" "+salary;

       }

       public void addSalary(){       //增加工资方法 addSalary方法,实现工资增加500功能

              salary+=500;

       }

       public void addSalary2(double salary2){  //增加工资方法 addSalary2,工资可以任意增加

              salary=salary+salary2;

       }

       public static void main(String []args){

              Teacher t=new Teacher("张三","",73364.2464);

              System.out.println(t);

              t.addSalary();

              System.out.println(t);

              t.addSalary2(526354.2136);

              System.out.println(t);           

       }

}

14.学习使用API文档,查看String,练习String类的一些方法的使用完成如下作业:

              String str = "abc3dfg";

              判断str中是否有1-9数字

              如果有将字符串逆序输出

              如果没有原序输出

public class StringTest{

       public static void main(String []args){

              System.out.println("请输入字符串");    //键盘输入字符串

             Scanner reader=new Scanner(System.in);

             String str=reader.next();

              char[] cs=str.toCharArray();       //字符数组

              int i;

              for(i=0;i<cs.length;i++){

                     if(cs[i]>='1'&&cs[i]<='9'){

                            for(int j=cs.length-1;j>=0;j--){

                                   System.out.print(cs[j]);

                            }

                            break;

                     }

              }

                     if(i>=cs.length){

                            System.out.println(cs);

                     }

       }

}

2011.7.19      周二 

1.Java中小数默认是double

  float f=3.14  错误改成 float f=3.14f或是float f=3.14F

  原始类型范围:[-2n-1,2n-1-1]

2.变量的声明:

  intx,y,z;          //只声明

  float z=3.144f;    //声明并赋初值

public class Assign{

       private int i;        //成员变量 实例变量

       private String  student_name;

       private final doublePI=3.14;   //常量

       public void setStudent_name(String n){

              student_name = n;

       }

       public static void main(String [] args){                     

              int i;        //局部变量  内存不会自动初始化

              //i =10;      //在使用局部变量前必须初始化

              System.out.println(i);  //只声明变量i未初始化

              Assign assign = new Assign();

              System.out.println(assign.i);  //输出0

       }    

}

3.类与对象:

  类:描述群体的共性    

    1)变量或属性或:名词

     (2)方法或功能:set()和get() 动词

       万物皆对象   在大多数情况下是名词       具有属性或者成员      

       有对自身属性或成员操作的方法   使用new关键字创建实例

4.原始类型和引用类型的区别:

  原始类型变量的赋值

  int x = 10; int y = x;

  引用类型变量的赋值

  Teacher teacher = new Teacher(“John Smith”, 30, 10000);

        Teacher teacher, teacher_Clone;

    teacher = new Teacher(“John Smith”, 30, 10000);

     teacher_Clone = teacher;

  实例:public class PrimitiveRefType{

           public static void main(String [] args){

              //原始类型   x10赋值给y之后xy没有关系

              int x =10;

              int y = x;

              x =100;         

              System.out.println("x="+x); //输出x=100

              System.out.println("y="+y); //输出y=10

              //引用类型

              Teacher t1;//声明变量

              t1 = new Teacher("z3",30,5000.0);

              System.out.println("t1第一次:"+t1.getName());  //t1第一次:z3             

              Teacher t2 = t1;   //t1引用地址赋值给t2

              t2.setName("L4");        

              System.out.println("t1===="+t1.getName());    //t1====L4

              System.out.println("t2===="+t2.getName());    //t2====L4

         }

     }

5.局部变量及作用范围:

  自动变量,临时变量,栈变量 在方法中或者在类{}中的{}定义的

  使用前必须初始化

6.实例变量及作用范围:

  在类的{}定义的

  自动初始化,并有初始值 

byte  short   int   long   float    double    char     boolean   All reference types    

0     0       0    0L   0.0f     0.0d     ‘\u0000’      false         null

 实例:public class LocalVariable{

       private int i;          //成员变量或实例变量

       private boolean bl;    //boolean默认false

       private String name;   //所有类类型 默认值null

       private Teacher t;     //默认值null   

       //private int a = 8;

       public void a(){

              int a = 9;        //局部变量出了包含的{}就不可用

       }    

       public void b(){

              //int b = a;       //错误的  a出了a()方法就不可用

       }    

       public static void main(String[]args){

              int c ;     / /局部变量

              c = 0;     //局部变量使用前必须初始化

              int d = c;   //编译报错 可能尚未初始化变量 c

              System.out.println(c);                 

              //成员变量,如果没有初始化,程序会采用各种类型的默认值初始化

              LocalVariable lv = new LocalVariable();

              System.out.println(lv.i);

              System.out.println(lv.bl);

              System.out.println(lv.name);

              System.out.println(lv.t);

       }

}

 

7.Operators(操作符)

  赋值运算符:=*=+=-=/=%=>>=<<=>>>=&=^=|=

  比较运算符:<<=>>=instanceof

  相等运算符:==、!=

  算术运算符:+ - / %

  移位运算符:>> << >>>   (没有<<<                      (二进制运算)

  位比较运算符:& ^ |&都为1得到1|有一个1得到1  (二进制运算)

  逻辑运算符:&&|| 、!   (&&||称为短路运算)

  条件运算符:?、:

  实例:public class OperatorTest{

           public static void main(String []args){

              int i = 4;

              int b = i<<2;     //左移扩大 2n次方   4*2n次方       

              int c = i>>3;    //右移 缩小  2n次方   4/2n次方

              System.out.println(b);

              System.out.println(c);          

              int j1 = 3;

              int j2 = 4;

              int j3 = j1&j2;

              int j4 = j1|j2;

              System.out.println(j3);

              System.out.println(j4);                       

              String str = "aaaaa";

              if(str!=null&&str.length()>3){

                     System.out.println("字符串长度大于3");

              }

              String str2 = null;//str2不一定是什么值

              if("abc".equals(str2)){

                     System.out.println("字符串为abc");

              }

                     ?

                     (条件表达式)?1:2              

                    可以嵌套的

              int m1 = 10;

              int m2 = 20;

              int m3 =(m1>m2)?m1:m2;  //返回较大值

              System.out.println(m3);       

              int sc = 70;

       }

}==用在原始类型中,类类型不用==

短路运算:String str=null;

        if(str!=null&&str.length()>3) 因为str!=nullFalse,所以str.length()>3不执行   

        String str2=null;

          if("abc".equal(str2))if(str2!=null&&str2.equal("abc"))

8.类型转换两大类

 1》隐式类型转换 ---》大

      原始类型(大小指范围)  

       int---->long

       float--->double

       int--->double

      引用类型(大小指父子关系)

       String-->Object

       Student-->Object          

 2》强制类型转换 ---》小(损失精度)

      原始类型(大小指范围)  

       long---->int

       double--->float  

       double--->int

      引用类型(大小指父子关系)

       Object-->String

       Object-->Student

                                         

     语法  (强制转换的类型)变量

       例如: long l = 100L;

              int i = (int)l;                                        

注意:当我们将变量1强制转换为某类型时,一定注意是否能够转换过去

实例:public class Casting{

         public static void main(String[]args){

           int i = 10; 

              long l = i;        //隐式转换

              float f = 2.0f;

              double d = f;         

              String str = "abc";

              Object o1 = str;  //o1类型是Object  o1对象是String          

              int j = (int)l;   //强制类型转换

              float f2 = (float)d;

              float f3 = (float)2.0;

              String str2 = (String)o1;

              System.out.println(str2);             

              //注意

             Object o2 = new Object();

             //强制类型转换异常java.lang.ClassCastException

             //String str3 =(String) o2;  //出错

        }

      }

9.if....else

 <1>. if (布尔表达式){

 

           代码语句块      

      }

 <2>. if(布尔表达式){

        代码语句块

    } else {

        代码语句块

           }

<3>. if(布尔表达式){    

          代码语句块

       } else if(布尔表达式){      

         代码语句块

       }

    else {       

          代码语句块

      }

 注意:if{}可以省略,但是代码块出现多行时必须加上{},因为If只控制后面一行

10.switch(变量a){

         case 1:

         case 2:

          ...            

          ...

         default:

   }

Switch(a)中的变量a必须是byte,short,char,int中的一种

每个case语句中需要加上break;语句

default语句可以放在开始,中间或者末尾位置实例:

public class SwitchTest{

         public static void main(String[]args){

             int month;

             switch(month){

                     case 1:

                            System.out.println("1"+31);

                            break;                       //break跳出switch循环

                     case 2:

                            System.out.println("2"+29);

                            break;

                     case 3:

                            System.out.println("3"+31);

                            break;

                     case 4:

                            System.out.println("4"+30);

                            break;

                     case 5:

                            System.out.println("5"+31);

                            break;

                     case 6:

                            System.out.println("6"+30);

                            break;

                     default:

                            System.out.println("default"+30);

              }

       }    

  }

11.for(循环变量;循环表达式;循环变量的变化 ){    

    }

   for括弧中必须为3部分,每部分可以不写代码,但两个;必须有 

  for(;;){}  //死循环 

   实例:int sum =0;

        for(int i=1;i<=100;i++){

            sum = sum+i;                 //1加到100的和

        }

        System.out.println(sum);

  增强型for each循环

 for(String s:args)—>(变量:数组或集合){

     System.out.println(s);

 }

12.1While:

   实例:int sum2 = 0;

        int j =1;

        while(j<=100){

              sum2 = sum2+j;     //1加到100的和

              j++;

        }

        System.out.println(sum2);

  2Do...while:

 实例:int sum3 =0;

       j=1;

       do{

         sum3 = sum3+j;       //1加到100的和

         j++;

       }while(j<=100);

       System.out.println(sum2);

 区别:Do...while至少执行一次语句,While可能一次也不执行;当条件一开始为真时一样

13.//for10

  public class ForTest{

       public static void main(String []args){

              int sum=1;     

              for(int i=1;i<=10;i++){

                     sum=sum*i;                 

              }

              System.out.println(sum);

       }

   }

14.//while10

 public class WhileTest{

       public static void main(String []args){

              int sum=1;

              int i=1;

              while(i<=10){

                     sum=sum*i;

                     i++;

              }

              System.out.println(sum);

       }

15.//do while10

  public class DoWhileTest{

       public static void main(String []args){

              int sum=1;

              int i=1;

              do{ 

                     sum=sum*i;

                     i++;       

              }while(i<=10);

              System.out.println(sum);

       }

}

16.使用递归求10

  public class DiGui{

       public static void main(String []args){

              System.out.println(fun(10));               

       }    

       public static int fun(int n){

             if(n==1)

                   return 1;

              else

                    return n * fun(n-1);

      }

}

17.有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,

 * 假如兔子都不死,问每个月的兔子总对数为多少?

 * 程序分析:兔子的规律为数列1,1,2,3,5,8,13,21....(递归)

 public class TuZi{

       public static void main(String []args){

               int t1=1,t2=1,t3=0;

                 for(int i=1;i<=20;i++){

                     if(i==1||i==2){

                            System.out.println(""+i+"个月的兔子总数为:"+t1);

                     }

                     else{

                            t3=t1+t2;

                            System.out.println(""+i+"个月的兔子总数为:"+t3);                    

                            t1=t2;

                            t2=t3;                   

                  }

              }

       }

}

18.利用条件运算符的嵌套来完成此题:学习成绩> =90分的同学用A表示,60-89分之间的用B表示,60分以下的用C表示。

 * 程序分析:(a> b)?a:b这是条件运算符的基本例子。

 public class OperatorTest{

       public static void main(String []args){

              int score =97;

              String result = score>=90?"A":((score>=60&&score<90)?"B":"C");

              System.out.println(result);           

       }

}

//(条件表达式)?1:2

19.打印出所有的 "水仙花数 ",所谓 "水仙花数 "是指一个三位数,其各位数字立方和等于该数本身。

 * 例如:153是一个 "水仙花数 ",因为153=1的三次方+5的三次方+3的三次方。

 * 程序分析:利用for循环控制100-999个数,每个数分解出个位,十位,百位。

  public class ShuiXianHua{

       public static void main(String[] args){

             int n=0,x,y;

              for (int i=1; i<=9; i++) {

                  for (int j=0; j<=9; j++) {

                               for (int k=0; k<=9; k++) {

                                        x=i*i*i+j*j*j+k*k*k;

                                      y=i*100+j*10+k;

                                             if (x==y) {

                                                    n++;

                                                    System.out.print(y+" ");

                                             }

                                }

                   }

             }               

      }

}

 

20.判断101-200之间有多少个素数,并输出所有素数。

 * 程序分析:判断素数的方法:用一个数分别去除2...直到这个数,如果能被整除,则表明此数不是素数,反之是素数。

  public class SuShu{

       public static void main(String []args){

              System.out.println("101200间的素数有: ");

            for(int i=101;i<=200;i++){

                         boolean flag=true;

                         for(int j=2;j<=Math.sqrt(i);j++){

                               if(i%j==0){

                                    flag=false;

                                    break;

                               }

                         }

                         if(flag==true){

                              System.out.print(i+" ");

                         }

                         continue;

            }

 

       }

}

21.编写程序,实现字母的加密,首先输出原始字母password!,然后将这个一系列原始字母加密,每个字母都变成字母表中其后的5个字符输出。

  public class PassWord{

       public static void main(String [] args){

              String str="password";

              System.out.println("原字符串:" + str);

                char [] c=str.toCharArray();

              for(int i=0;i<=c.length-1;i++){

                     c[i]=(char)(c[i]+5);

                     System.out.print(c[i]);

              }           

 

       }

}

 

 

 

2011.7.20 周三  (数组)

1.Eclipse的使用

   先新建一个 java project工程,然后在src下新建一个包sample,最后在sample下新建一个类Book

   快捷键  Alt + /

           多行注释:选中内容 + Ctrl + Shift + /或是:Ctrl + /

           撤销注释:选中内容 + Ctrl + Shift + \或是:按2Ctrl + /

   添加构造方法,set&get方法,toString()(在Source下)

2.使用递归求阶乘

  package test;

  public class DiGui {

       public long jieCheng(int n){

              if(n<0){

                     return -1;

              }else if(n<=1){

                     return 1;

              }else{

                     return n* jieCheng(n-1);

                     /**

                      * n=10

                      * 10!= 10*9!

                      *                 9*8!

                      *                   8*7!

                      *                        ...

                      *

                      *                               ...

                      *                                      2*1!

                      *                                             1    

                      */

              }

       }

       public static void main(String[] args) {

              DiGui dg = new DiGui();

             long result = dg.jieCheng(10);   //成员方法要New对象调用方法

              System.out.println(result);

       }

}

3.数组:一个有固定大小,可以容纳相同类型数据的集合

         一个数组就是一个对象;声明数组并没有创建数组

        声明数组语法:int[] iArray;    //原始类型   //常用

              int iArray2 [];      //也可以

              Teacher[] tArray;   //引用类型,Teacher为一个类 

  创建数组用New关键字,New类型[长度],创建数组时必须指明长度;

  创建好数组后,数组中元素并没有被初始化

  创建数组语法:iArray = new int[3];

                      tArray = new Teacher[3];

  数组中元素的位置由索引index决定;index0---长度-1

  * 当我们使用索引index超出范围  就会报异常

  *越界异常  运行时异常 java.lang.ArrayIndexOutOfBoundsException

  初始化数组语法:iArray[0]=1;

                        iArray[1]=2;

                        iArray[2]=3;

                

            Teacher t1 = new Teacher();

                t1.setName("zhangsan");

                tArray[0] = t1;

                tArray[1] = new Teacher();

                tArray[2] = new Teacher();

                System.out.println(tArray[0].getName());

   数组的声明创建初始化一步完成

   double[] dArray = new double[]{2.2,3.0,4.8};

   Teacher [] tArray={t1,new Teacher(),new Teacher()}

  打印输出数组:

for(int i=0;i<iArray.length;i++){                  //打印输出数组

                            System.out.println(iArray[i]);

            }

              for(inti=1;i<=dArray.length;i++){                 //打印输出数组

                            System.out.println(dArray[i-1]);   

                 }

              for(inti=0;i<=lArray.length-1;i++){               //打印输出数组

                            System.out.println(lArray[i]);

           }

  数组的长度:iArray.length   字符串有String.length()

 增强型:for(int i:iArray){    //从头循环到尾

             i为取出的元素

 多维数组:int [][] iArray;

          iArray=new int[4][]  iArray=new int[4][3]  但是不能 iArray=new int[][3]

       创建多维数组必须指明第一维长度,第二维可以不指定

 int [][]iArray={{11,12,13},{5,4,7,6,8}}   6  iArray[1][3]

 多维数组的长度:iArray.length       为第一维的长度

                       iArray[1].length     为第二维的长度

 打印输出用两层For循环:int [][] iArray1={{1,2,3,4},{7,5,4}};

                      for(int i=0;i<iArray1.length;i++){                //打印输出数组

                                   for(int j=0;j<iArray1[i].length;j++){

                                          System.out.println(iArray1[i][j]);

                                   }    

                            }

 

4.breakcontinue的区别:

  break:终止当前的循环语句跳出,立刻结束包含它的循环

  continue:终止当前循环,进入下一个循环,立刻结束当前循环,进入下次循环

  public static void main(String[] args) {

              for(int i=1;i<=10;i++){

                     if(i%2==0){

                            break;             //break执行就立刻结束包含它的循环

                     }

                     System.out.println(i);     //   输出1                          

                     if(i%2==0){

                            continue;          //continue执行就立刻结束当前循环,进入下次循环

                     }

                     System.out.println(i);     //输出13,5,7,9

              }

       }   

5.给定一个多维数组,找最大最小值:

  public class Max_Min {

       public static void main(String[] args) {       

              int[][] mXnArray = { {16, 7, 12},{9, 20, 18}, {14, 11, 5}, {8, 5, 10} };

              int max=mXnArray[0][0];

             int min=mXnArray[0][0];

              for(int i=0;i<mXnArray.length;i++){           

                     for(int j=0;j<mXnArray[i].length;j++){

                            if (mXnArray[i][j]>max){

                                   max=mXnArray[i][j];

                            }

                            if (mXnArray[i][j]<min){

                                   min=mXnArray[i][j];

                            }                         

                     }

              }

              System.out.println("最大值为"+max);

              System.out.println("最小值为"+min);

       }

}

定义一个String[][]  求最小和最大的字符串

  public class StringTest {   

       public static void main(String[] args) {

       String[][]s={{"gy","ffd","g12","e44","2f","3w","4dg"},

               {"hwr","hv","uwee","ed","tj","tg","2kk","1hk","4gh"},                                        {"ghk","ehgj","t2","35t","233y","21y"},

{"134","554","f5","jv","sde","dtyt","12"}};

               String max=s[0][0];

               String min=s[0][0];

               for(int i=0;i<s.length;i++){

                     for(int j=0;j<s[i].length;j++){

                         if(s[i][j].compareTo(max)>0){

                                max=s[i][j];

                         }

                         if(s[i][j].compareTo(min)<0){

                                min=s[i][j];

                         }

                  }

           }

         System.out.println("最大字符串为:"+max);

         System.out.println("最字小符串为:"+min);

       }           

}

 

6.冒泡排序

   public static void main(String[] args) {

              int [] b={10,4,9,3,4,23,164};

              for(int i=0;i<b.length;i++){

                    for(int j=0;j<b.length-i-1;j++){      //j不能到最后一个,所以必须length-i-1

                            if(b[j]>b[j+1]){

                                   int temp =b[j];

                                   b[j]=b[j+1];      //交换

                                   b[j+1]=temp;                             

                            }

                     }

              }

              for(int maopao:b)

              System.out.println(maopao);

       }

7.有一组具有名称、价格、作者的书籍资料,可以按照书籍的价格升序进行排序,并打印出结果;按书名排序输出

  public class Book {                        //先创建Book

       private String title;

    private String author;

       private int price;

       public Book() {}

       public Book(String title, String author, int price) {

              this.title = title;

              this.author = author;

              this.price = price;

       }

      

 

       public String getTitle() {

              return title;

       }

       public void setTitle(String title) {

              this.title = title;

       }

       public String getAuthor() {

              return author;

       }

       public void setAuthor(String author) {

              this.author = author;

       }

       public int getPrice() {

              return price;

       }

       public void setPrice(int price) {

              this.price = price;

       }

       public  String toString(){

             return title+" "+author+" "+price;

          }

  }

 

  public class BookSort {                                 //创建书的对象类

       public static void main(String[] args) {

              Book b1=new Book("Java","耿祥义",23);

              Book b2=new Book("C++","郑旭丽",135);

              Book b3=new Book("C","韩非",76);

              Book b4=new Book("asp","李四",734);

 

              //按价格排序输出

              Book [] a={b1,b2,b3,b4};                    //Book类型数组

              for(int i=0;i<a.length;i++){

                     for(int j=0;j<a.length-i-1;j++){

                            if(a[j].getPrice()>a[j+1].getPrice()){     //调用getsetPrice方法

                                   Book temp=a[j];                         //交换顺序

                                   a[j]=a[j+1];

                                   a[j+1]=temp;

                            }

                     }           

          }

         for(Book jiage:a)

         System.out.println(jiage);

         System.out.println(" ");

         //按书名排序输出

         Book [] c={b1,b2,b3,b4};

              for(int i=0;i<c.length;i++){

                     for(int j=0;j<c.length-i-1;j++){

       if(c[j].getAuthor().compareTo(c[j+1].getAuthor())>0){ //compareTo比较字符串大小

                                   Book temp=c[j];

                                   c[j]=c[j+1];

                                   c[j+1]=temp;

                            }

                     }           

          }

         for(Book shuming:c)                     //增强型循环输出

         System.out.println(shuming);

        

       }

}

8.编写程序将华氏温度78度转换为摄氏温度,转换成的摄氏温度在屏幕上显示出来:

转换公式为:摄氏度=(5/9)*(华氏度-32)

  public class TemperatureConverse {

        //华氏温度转换为摄氏温度

        public  double hToc(double h){

               return (5.0/9)*(h-32);

        }

 

       public static void main(String[] args) {

              TemperatureConverse tc=new TemperatureConverse();  //必须先创建对象

              double h1=78;

              System.out.println("78℉=  "+tc.hToc(h1)+" ℃");  通过对象调用方法

              System.out.println();            

       }    

}

9:异常:

     空值异常

       类型转换异常

        数组越界异常  

 

10.Eclipse快捷键:

运行作用域       功能                      快捷键 

全局           单步返回                     F7 

全局           单步跳过                     F6 

全局            单步跳入                     F5 

全局           单步跳入选择                 Ctrl+F5 

全局           调试上次启动                 F11 

全局           继续                         F8 

全局           使用过滤器单步执行           Shift+F5 

全局           添加/去除断点                Ctrl+Shift+B 

全局           显示                         Ctrl+D 

全局           运行上次启动                 Ctrl+F11 

全局           运行至行                     Ctrl+R 

全局           执行                         Ctrl+U    

 

重构作用域      功能                      快捷键  

全局           撤销重构                   Alt+Shift+Z 

全局           抽取方法                   Alt+Shift+M 

全局           抽取局部变量               Alt+Shift+L 

全局           内联                       Alt+Shift+I 

全局           移动                       Alt+Shift+V 

全局           重命名                     Alt+Shift+R 

全局           重做                       Alt+Shift+Y 

 

源代码作用域          功能                快捷键 

Java编辑器           格式化              Ctrl+Shift+F 

Java编辑器           取消注释            Ctrl+ 

Java编辑器            注释                Ctrl+/ 

Java编辑器           添加导入            Ctrl+Shift+M 

Java编辑器           组织导入            Ctrl+Shift+O 

Java编辑器           使用try/catch块来包围 Ctrl+1 

 

项目作用域           功能                快捷键 

全局                 全部构建            Ctrl+B 

 

文件作用域           功能                快捷键 

全局                 保存                Ctrl+X    Ctrl+S  

全局                 打印                Ctrl+P 

全局                 关闭                Ctrl+F4 

全局                 全部保存            Ctrl+Shift+S 

全局                 全部关闭            Ctrl+Shift+F4 

全局                 属性                Alt+Enter 

全局                 新建                Ctrl+N

 

文本编辑 

作用域               功能               快捷键 

文本编辑器           改写切换           Insert 

文本编辑器            上滚行             Ctrl+↑ 

文本编辑器           下滚行             Ctrl+↓

 

搜索 

作用域                功能                    快捷键 

全局                出现在文件中              Ctrl+Shift+U 

全局                打开搜索对话框            Ctrl+H 

全局                工作区中的声明            Ctrl+G 

全局                工作区中的引用            Ctrl+Shift+G 

 

导航作用域           功能                           快捷键 

Java编辑器           打开结构                       Ctrl+F3 

全局                 打开类型                     Ctrl+Shift+T 

全局                  打开类型层次结构               F4 

全局                 打开声明                     F3 

全局                 打开外部javadoc                Shift+F2 

全局                 打开资源                     Ctrl+Shift+R 

全局                 后退历史记录                   Alt+← 

全局                  前进历史记录                   Alt+→ 

全局                 上一个                        Ctrl+, 

全局                 下一个                         Ctrl+. 

Java编辑器           显示大纲                     Ctrl+O 

全局                 在层次结构中打开类型           Ctrl+Shift+H 

全局                  转至匹配的括号                 Ctrl+Shift+P 

全局                 转至上一个编辑位置             Ctrl+Q 

Java编辑器           转至上一个成员                 Ctrl+Shift+↑ 

Java编辑器           转至下一个成员                 Ctrl+Shift+↓ 

文本编辑器           转至行                        Ctrl+L 

 

窗口作用域       功能                  快捷键 

全局           激活编辑器              F12 

全局           切换编辑器              Ctrl+Shift+W 

全局           上一个编辑器            Ctrl+Shift+F6 

全局           上一个视图              Ctrl+Shift+F7 

全局           上一个透视图            Ctrl+Shift+F8 

全局           下一个编辑器            Ctrl+F6 

全局           下一个视图              Ctrl+F7 

全局           下一个透视图            Ctrl+F8 

文本编辑器     显示标尺上下文菜单      Ctrl+W 

全局           显示视图菜单            Ctrl+F10 

全局           显示系统菜单            Alt+- 

 

查看作用域           功能            快捷键 

全局                 放大            Ctrl+= 

全局                 缩小            Ctrl+- 

 

编辑作用域           功能                  快捷键 

全局                 查找并替换            Ctrl+F 

文本编辑器           查找上一个            Ctrl+Shift+K 

文本编辑器           查找下一个            Ctrl+K 

全局                 撤销                  Ctrl+Z 

全局                 复制                  Ctrl+C 

全局                 恢复上一个选择        Alt+Shift+↓ 

全局                 剪切                  Ctrl+X 

全局                 快速修正              Ctrl1+1 

全局                 内容辅助              Alt+/ 

全局                 全部选中              Ctrl+A 

全局                 删除                  Delete 

全局                 上下文信息            Alt+  

Java编辑器           显示工具提示描述      F2 

Java编辑器           选择封装元素          Alt+Shift+↑ 

Java编辑器           选择上一个元素        Alt+Shift+← 

Java编辑器           选择下一个元素        Alt+Shift+→ 

文本编辑器           增量查找              Ctrl+J 

文本编辑器           增量逆向查找          Ctrl+Shift+J 

全局                 粘贴                  Ctrl+V 

全局                 重做                  Ctrl+Y 

   

F3:    察看声明打开声明

ctrl  +  shift  +  g:查看引用 

ctrl  +  shift  +  n:重命名 

ctrl  +  shift  +  o:导入类 

ctrl  +  shift  +  r:启动上次运行 

ctrl  +  shift  +  f:格式化代码 

ctrl  +  shift  +  t:查找相关信息

ctrl  +  c:复制 

ctrl  +  v:粘贴 

ctrl  +  x:切剪 

ctrl  +  a:全选 

ctrl  +  f:查找 

ctrl  +  z:撤销 

ctrl  +  y:重做 

ctrl  +  s:保存

Ctrl  +  M: 工作区最大化/最小化 

Crtl+1:  修正错误

Shift+Alt+T:  重构 

Shift+Alt+M:  提取函数 

Shift+Alt+R:  重命名 

Shift+Alt+C:  更改函数标记 

Ctrl+Shitf+F:  格式化代

Alt  +  /             智能提示     

Alt  +  shift  +  r   重命名变量 

 

2011.7.21            周四

 

1. /  的两边可以是整数  整数/整数=整数

  /  的两边也可以是double类型     9.0/5 9/5.0都为double型数据

 

2.数组的拷贝:

 public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)                               参数:

                     src -源数组。

                     srcPos -源数组中的起始位置。

                     dest -目标数组。

                     destPos -目标数据中的起始位置。

                     length -要复制的数组元素的数量。

  public static void main(String[] args) {

              int [] iArray =new int[]{1,2,3,4,5};

              int [] destArray ={10,9,8,7,6,5,4,3,2,1};

              System.arraycopy(iArray, 0, destArray, 0, iArray.length);

              for(int i:destArray){

                     System.out.print(i+"\t");

              }           

//数组工具类   Arrays  实现比如查找、排序(Sort)

  返回指定数组内容的字符串表示形式(toString)

  }

 

3.导入java工程:import->General->Existing Projects into Workspace->找到工程->选中Copy Projects into Workspace即可

4.查找之前必须先对数据进行排序(升序或是降序)---二分查找法

5.i++:先使用i的原值,然后将i1

  ++i:先使i1,再使用i加后的值

 

     执行12行代码后,x,a,b三个变量的值是什么?c

     1. Int x, a=6, b=7;

     2. X = a++ + b++;           //x = 13, a = 7, b=8

     如果换成 X = ++a + ++b       //x = 15, a = 7, b=8;

 

6. int x = 4;

   System.out.println(“value is “  + ((x>4)?99.9:9));   //类型自动转换为Double

   //运行结果为:value is 9.0

7.类与对象:

  封装:Encapsulation

  继承:Inheritance

  多态:Polymorphism------->父类型子对象

  Java中类声明的和实现同时进行。

 

  方法的语法:一般只需考虑返回类型和参数列表

  <modifiers><return_type><name>([<argument_list>]) [throws <exception>] {<block>}

   修饰符   返回类型   方法名  参数列表        抛异常           方法体

  如果方法内没有返回值时,返回类型定义为Void

  构造方法没有返回值,也没有Void

8.假设已经创建了A

  A a=new A()  System.out.println(a+b);     是错误的

     A b=new A() System.out.println(a+" "+b); 是正确的

9.参数传递:

  原始类型参数传递    值传递

  引用类型参数传递    传递引用  实质也是值传  注意:引用类型传递只能改变对象的内容,而不能改变完整的对象

  public class ParamPassTest {

      * 原始类型参数传递值传递

       public void a(int i){

              i++;

              System.out.println("a()===="+i);

       }

        * 引用类型传递引用 实质也是值传递

       public void changePersonName(Person p){

              p.setName("zhangsan");

              System.out.println(p.getName());

       }

        * 引用类型传递只能改变对象的内容,而不能改变完整的对象

       public void changePerson(Person p){

              p = new Person();//改变对象本身

              p.setName("zhangsan");

              System.out.println(p.getName());

       }

       public static void main(String[] args) {

              ParamPassTest ppt = new ParamPassTest();

              int i = 9;

              System.out.println(i);//9

              ppt.a(i);//a()====10

              System.out.println(i);//9

              Person p = new Person();

              p.setName("aaa");

              System.out.println(p.getName());//aaa

              ppt.changePersonName(p);//zhangsan

              System.out.println(p.getName());//zhangsan       

              Person p2 = new Person();

              p2.setName("bbb");

              System.out.println(p2.getName());//bbb

              ppt.changePerson(p2);

              System.out.println(p2.getName());//bbb

       }

}

10.This关键字:

  this两种主要的用法

 1this.参数与成员变量相同时,用This区分

             this 代表当前类实例

              this.属性   this.方法

 2this(XXX,xxx) 同一个类中,构造方法之间互相调用

              this()必须出现在构造方法中的第一行功能代码

  public class ThisTest {

       public ThisTest(){

              //int i = 1; //如果有该行代码   this()就报错 

              this(10);//调用另一个整型参数的构造方法 必须放第一行

              int i = 1;//可以这样

       }

       public ThisTest(int age){

              this.age = age;

       }

       private int age;

       public void setAge(int age){

              this.age = age;

       }

       public void a(int a){

              this.setAge(a);

       }

       public static void main(String[] args) {

              ThisTest tt = new ThisTest();

              //tt.setAge(10);

              //this.setAge(10);

       }

}

11.封装

    习惯要求

        *  一般会将属性private私有化,提供统一的public方法来完成属性的操作

        *   私有化的属性只能在当前类中对象.属性可以使用,

        *   其他类不能访问私有变量

        *  增强了可维护性

12.方法的重载(Method Overloading

    要求:《1几个方法在同一个类中

            2方法名相同,参数列表一定不相同(参数个数、类型、顺序)

                           注意:参数列表是否相同  不能由参数名决定 

                          参数名只是形参

            3返回类型可以不同 

13.编写Person类,包括姓名、年龄及熟悉setter  getter方法,根据年龄查找Person方法(注意:该方法要求下面测试类中初始化数据年龄不能相同)   

   测试类PersonTest

       使用数组初始化10个数据(年龄不能相同)

       完成调用根据年龄查询Person的方法,如果有打印该对象的姓名年龄信息,如果没有打印没有此人。

    public class Person {

       private String name;

       private  int age;

       public Person(String name, int age) {

              super();

              this.name = name;

              this.age = age;

       }

       public String getName() {

              return name;

       }

       public void setName(String name) {

              this.name = name;

       }

       public int getAge() {

              return age;

       }

       public void setAge(int age) {

              this.age = age;

       }

       public String toString(){

              return name+" "+age;

       }

}

   public class PersonTest {

       public void findPersonByAge(int a,Person[]p){

              boolean flag=false;

              for(int i=0;i<p.length;i++){

                            if(p[i].getAge()==a){

                                   System.out.println(p[i]);

                                   flag=true;

                            }    

                     }    

              if(flag==false){

                     System.out.println("没有此人");

              }

              }

        public static void main(String[] args) {

              Person  p1=new Person("zhangsan",12);

              Person  p2=new Person("lisi",7);

              Person  p3=new Person("wamhwu",98);

              Person  p4=new Person("hangshu",76);

              Person  p5=new Person("gaodeng",53);

              Person  p6=new Person("shenyu",32);

              Person  p7=new Person("yangxin",26);

              Person  p8=new Person("liuli",32);

              Person  p9=new Person("xiongxiuxin",29);

              Person  p10=new Person("shixi",31); 

              Person []p={p1,p2,p3,p4,p5,p6,p7,p8,p9,p10};         

              PersonTest pt=new PersonTest();

              pt.findPersonByAge(32, p);         

              }           

}

  

14.编写函数double fun(double h),它的功能是:四舍五入并保留两位小数。

   public class SheRu {

       public double fun(double h){

              long sheRu=Math.round(h*100);

              return sheRu/100.0;

 

       }

       public static void main(String[] args) {

              SheRu  sh=new SheRu ();

              System.out.println(sh.fun(1664776.67578));

       }

   }

15.青年歌手参加歌曲大奖赛,有10个评委对她的进行打分,试编程求这位选手的平均得分(去掉一个最高分和一个最低分)。

double a[]={7,9,8,7.5,8.6,9.2,9.7,9.4,8.5,8};

   public class Average {     

       public static void main(String[] args) {

              double a[]={7,9,8,7.5,8.6,9.2,9.7,9.4,8.5,8};

              double sum=0;

              double average=0;

              double max=a[0];

              double min=a[0];

              for(int i=0;i<a.length;i++){

                     if(a[i]>max){

                            max=a[i];

                     }

                     if(a[i]<min){

                            min=a[i];

                     }    

              }

              for(int i=0;i<a.length;i++){

                     sum+=a[i];

              }

              average=(sum-max-min)/8;

              //System.out.println(sum);

              //System.out.println(max); 

              //Sysem.out.println(min); 

              System.out.println(average);

       }

}

16.编程将字符串 \_0\_4d_a3转换为 \UL___0_\UL___ddddd_d___a_3

   public class StringConverse {

       public static void main(String[] args) {

              System.out.println("请输入字符串");

              Scanner reader=new Scanner(System.in);

              String str=reader.next();

              char[] cs=str.toCharArray();

              String  result=" ";

              for(int i=0;i<cs.length-1;i++){

                     if(cs[i]=='\\'){

                            result +="\\UL_";   

                     }

                     else if(cs[i]=='_'){

                            result +="_";

                     }

                     else if((cs[i]<='9'&& cs[i]>'0')&&(cs[i+1]<='z'&&cs[i+1]>'a')){

                            int k=cs[i]-48;

                            for(int j=0;j<=k;j++){

                                   result+= cs[i+1];

                            }

                     }

                     else

                            result+=(cs[i]+"_");      

              }

              result+= cs[cs.length-1];

              System.out.print(result);

       }

}

 

 

 

 

 2011.7.22    周五

1、四舍五入并保留两位小数

    double fun(double h)

     { return int(h*100+0.5)/100.0; }

   或是   public double fun(double h){

                 long sheRu=Math.round(h*100);

                 return sheRu/100.0;

        }

2.创建和初始化对象:new对象时,先对成员变量初始化,再执行构造函数

    创建无参数构造方法时:先进入无参构造函数,然后给成员变量赋值,然后跳出无参构造函数,最后结束

    创建带参数构造方法时:先进入带参构造函数,然后给成员变量赋值,然后再把参数替换成传入的参数,最后结束

3.    * 构造方法

        * 1方法名和类名相同

        * 2没有任何返回类型 也没有void

        * 3》当没有定义构造方法时,java在编译时会

        *          自动提供一个不带有参数的缺省的构造方法。

        *     注意:如果自己手写了任何构造方法,

        *              系统不再提供无参数构造方法。

        *   习惯:如果自己手写有参数构造方法,

        *          同时也不要忘记写一个无参数构造方法

 

4.类的继承  父子关系   “的关系

 * <1>继承关键字  extends 还可以扩展

 * <2>是否父类所有属性和方法都被继承?不是

 *          1构造方法不会被继承

 *           (2)方法和属性(包括protected关键字)可以被继承

 *                 方法和属性如果修饰符是publicprotected 可以被继承

 * <3>子类的每个构造方法隐式调用了父类的缺省的构造方法

 *          是不是父类必须有无参数构造方法?不是

 *          如果父类没有无参数构造方法,

 *          子类必须每个构造方法显式指明调用父类某有参数构造方法

 * <4>super(xxx)子类构造方法调用父类构造方法

 *          默认子类构造方法中都有super(),调用父类无参数构造方法

 *          super()也必须写在子类构造方法的第一行

 *         同一个构造方法中不可能同时出现super()this()

 * <5> super.xxx属性或方法   调用父类属性或方法   super(name,age,salary);

 *     super指向父对象

 * <6>类只能单一继承   A—>B,A—>C   A—>B—>C

 *    接口可以多继承

  ThisSuper的区别This.Super的区别;This()Super()的区别

    

 

 5. 多态 *一个对象就是一个对象类型

               * 一个变量可以是多个类型

              * 继承与重载不同,

           * 继承的关系是在运行时确认的(指向java命令运行类时,确认对象是子对象还是父对象),

           * 重载则是在编译时确认的(两个方法是否构成重载,编译时就能识别语法)

           * 多态出现形式:

          父类型    子对象     Employee m = new Manager();

          接口类型  实现类对象 

6.InstanceOf操作符:是一个布尔操作符;判断一个对象是否是另一个类的实例

   如:Employee是父类  Manager是子类      

      Employee e = new Employee();

      Manager m = new Manager();

      Employee m2 = new Manager();

      Object o1 = e;

      Object o2 = m;

   m2 instanceof Employee    //true

   m2 instanceof Manager     /true

7.类型转换

  InstanceOf操作符判断对象的类型;子类类型隐式的升级到父类类型;父类类型必须要强制转换才能降到子类类型

   //强制类型转换   ---》小

     Manager m3 = (Manager)o2;

   //强制类型转换   ---》小        注意:对象是否真正能够转换过去

 

8.方法重写 Overridden

 * 1是父子类中的两个方法 才能说子类中方法是否重写父类方法

 * 2名称相同,参数列表相同,返回类型相同(基本上保证和父类方法一致)

 * 3方法的可见性不能缩小(方法修饰符范围不能缩小)

 * 4异常的抛出数量不能增加(异常个数 异常大小)

 * 多态的多种形式最终能够表现出来,关键是子类重写父类方法

 父类:

  public class Animal {

       protected void eat(){

              System.out.println("Animal eat()");

       }

  }

 子类

  public class Dog extends Animal {

       public void eat(){

              System.out.println("Dog eat()");

       }

       public static void main(String[] args) {

              Animal a = new Dog();

              a.eat();

       }

 }

9.考题OverloadOverride的区别

  Overload是重载的意思,Override是覆盖的意思,也就是重写。

  重载Overload表示同一个类中可以有多个名称相同的方法,但这些方法的参数列表各不相同(即参数个数或类型不同)。

  重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同,通过子类创建的实例对象调用这个方法时,将调用子类中的定义方法,这相当于把父类中定义的那个完全相同的方法给覆盖了,这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时,只能比父类抛出更少的异常,或者是抛出父类抛出的异常的子异常,因为子类可以解决父类的一些问题,不能比父类有更多的问题。子类方法的访问权限只能比父类的更大,不能更小。如果父类的方法是private类型,那么,子类则不存在覆盖的限制,相当于子类中增加了一个全新的方法。

10.编写图形类Shape

       包括求面积的方法getArea()方法,该方法实现就输出”Shape求面积方法

   编写长方形类Rectangle继承Shape

       定义长   属性及setter getter方法

        重写getArea方法,实现求面积并打印

   编写圆形类Circle继承Shape

        定义半径 setter getter方法

        重写getArea方法,实现求面积打印

   编写测试类ShapeTest

        main方法测试,创建一个Shape类型数组,初始化数组,包含ShapeRectangleCircle对象,然后循环该数组分别调用求面积方法测试。

   public class Shape {

        //要重写的方法getArea()

       public void getArea(){

             System.out.println("Shape求面积方法");

     }

    }

   public class Rectangle extends Shape {

       private double a;

       private double b;

       public double getA() {

              return a;

       }

       public void setA(double a) {

              this.a = a;

       }

       public double getB() {

              return b;

       }

       public void setB(double b) {

              this.b = b;

       }    

       public Rectangle() {

              super();

       }

       public Rectangle(double a, double b) {

              super();

              this.a = a;

              this.b = b;

       }    

       //重写基类的方法getArea()

       public void getArea(){

              System.out.println("长方形的面积是" +a*b);

          }        

    }

 

    public class Circle extends Shape {

       private double r;

       public double getR() {

              return r;

       }

       public void setR(double r) {

              this.r = r;

       }    

       public Circle(double r) {

              super();

              this.r = r;

       }    

       public Circle() {

              super();

       }

       //使得小数点后面保留2位小数,并四舍五入

       public double count(double x){

              long lx=Math.round(x*100);

              return lx/100.0;            

       }

       //重写基类的方法getArea()

       public void getArea(){

              System.out.println("圆的面积是" + count(Math.PI*Math.pow(r, 2))); //Math.pow(r, 2)r*r

       }    

    }

  public class ShapeTest {

       public static void main(String[] args) {

              //创建ShapeRectangleCircle对象并调用构造函数初始化

              Shape s=new Shape();

              Rectangle r=new Rectangle(4.0,5.0);

              Circle c=new Circle(3.0);

              //创建Shape类型的数组,用来存放ShapeRectangleCircle对象

              Shape [] s1={s,r,c};     

              //循环数组s1分别调用ShapeRectangleCircle的求面积方法

              for(Shape sh:s1){

                     sh.getArea();  //Shape求面积方法

                                    //长方形的面积是20.0

                                  //圆的面积是28.27  

              }           

       }    

  }

11.10的基础上,在ShapeTest类中编写个getArea(。。。)方法,该方法可以传入ShapeRectangleCricle任何类型对象,执行getArea()方法

    public class ShapeTest {      

       public void getArea(Shape s2){

              s2.getArea();

       }

       public void getArea(Rectangle r1){

              r1.getArea();

       }

       public void getArea(Circle c1){

              c1.getArea();

       }    

       public static void main(String[] args) {

              ShapeTest st=new ShapeTest();

              st.getArea(s);

              st.getArea(r);

              st.getArea(c);        

       }

    }

12.编写唱片Track和时间Duration   及测试类Driver

   Write three classes:

   Track, Duration and Driver.

   Duration class has three fields,  i.e. hours, minutes and seconds, and two overloaded constructors.

   Track has two fields, i.e. title and duration which has Duration type, and get/set methods.

   The Driver class has a main method to set track’s duration and then, print out the duration.

   

//Duration

   public class Duration{

    private int hours;

    private int minutes;

    private int seconds;

    public Duration(){}   

    public Duration(int hours,int minutes,int seconds){

        this.hours=hours;

        this.minutes=minutes;

        this.seconds=seconds;

    }

    public Duration(int timeseconds){

        hours = timeseconds/3600;

        timeseconds = timeseconds-(hours * 3600);

        minutes = timeseconds / 60;

        timeseconds = timeseconds - (minutes * 60);

        seconds = timeseconds;     

    }

 

    public void sethours(int hours){

        this.hours=hours;

    }

 

   public void setminutes(int minutes){

          this.minutes=minutes;

   }

 

   public void setseconds(int seconds){

       this.seconds=seconds;

   }

 

   public int gethours(){

          return hours;

   }

    

   public int getminutes(){

          return minutes;

   }

 

   public int getseconds(){

          return seconds;

   }

 

 }

 //

  public  class Track {

       private String title;

       private Duration duration;

       public String getTitle() {

              return title;

       }

       public void setTitle(String title) {

              this.title = title;

       }

       public Duration getDuration() {

              return duration;

       }

       public void setDuration(Duration duration) {

              this.duration = duration;

       }

       public Track(String title, Duration duration) {

              super();

              this.title = title;

              this.duration = duration;

       }

       public Track() {

              super();

       }    

   }

  // Driver

  public class Driver { 

       public static void main(String[] args) {

              Duration da=new Duration(12345);

              Track t=new Track("雪之光",da);

              System.out.println(t.getTitle()+ " " +da.gethours()+":" +da.getminutes()+":" +da.getseconds()); 

       }

   }

   //输出  雪之光 0:42:14

 

 

 

 

 

 

 

 

 

 

 

 

2011.7.25          周一

1.抽象类

 * 1》有抽象方法的类,必须声明为抽象类

       但是,抽象类中可以存在实现的方法,甚至抽象类中一个抽象方法也没有

 * 2抽象类不能被实例化(不能new对象) AbstractTest at = new AbstractTest();

 * 3》可以声明一个变量是抽象类类型的    AbstractTest at = null;

 * <4>是否子类继承抽象父类,必须重写父类中抽象方法吗?

      不是,如果子类没有将父类所有抽象方法实现,子类也必须声明为抽象类:

   抽象方法:没有{}实现体,直接;结束的方法

        * 抽象方法必须有abstract修饰   public abstract void b();

        * 有抽象方法的类,必须声明为抽象类  abstract class

2.接口--抽象类继续抽象,没有任何实现的方法就叫接口

 * interface 关键字

 * 1所有方法都抽象  

             定义方法时抽象abstract关键字可省略  public可省略

 * 2》接口中定义的所有的变量都会被定义成public final static 

        //接口中变量都是 public final static

                                          public static final int i = 100;

                                         等价于int j = 100;

 * 3》类不叫继承接口,而是实现接口  implements

 *          注意:接口可以继承吗? 

 *                 可以而且可以多重继承  一个接口可以继承(extends)多个接口

 *          类实现接口,需要实现接口中所有抽象方法

 *          一个类可以实现多个接口,语法  implements 接口1,接口2,...

 * 4接口不能new对象,但是可以作为一种类型声明变量

 

考题:abstract classinterface有什么区别?

       1.抽象类可以有构造方法,接口中不能有构造方法。

       2.抽象类中可以有普通成员变量,接口中没有普通成员变量

       3.抽象类中可以包含非抽象的普通方法,接口中的所有方法必须都是抽象的,不能有非抽象的普通方法。

       4. 抽象类中的抽象方法的访问类型可以是publicprotected和(默认类型,虽然

          eclipse下不报错,但应该也不行),但接口中的抽象方法只能是public类型的,并且默认即为public abstract类型。

       5. 抽象类中可以包含静态方法,接口中不能包含静态方法

       6. 抽象类和接口中都可以包含静态成员变量,抽象类中的静态成员变量的访问类型可以任意,但接口中定义的变量只能是public static final类型,并且默认即为public static final类型。

       7. 一个类可以实现多个接口,但只能继承一个抽象类。

3.<1>静态变量(类变量):

  静态变量被类的所有实例共享,不依赖任何一个对象  所有对象都是用一个静态变量

  静态变量是类一旦被加载,就立刻初始化,没有创建对象,也可以直接使用

  在类的外部直接存取,直接使用    类名.静态变量

  静态变量可以不需要创建对象 直接类名.静态变量使用,也可以对象.静态变量来使用

  所有对象共用一个静态变量,

  所以任何一个对象将静态变量改变,其他对象调用的静态变量也改变

  <2>成员变量(实例变量):

  直接包含在类的{}内,非静态变量

  <3> 静态代码块:

  只被调用一次 类加载时,就立刻会调用,而且只调用一次

  作用:一般完成静态变量的初始化工作或者完成类中程序只加载一次的功能代码

  <4>普通代码块:

  每创建一个对象,就会执行一次,而且在创建对象的构造方法之前执行

4.成员方法:必须先有成员对象  才能够使用成员方法

 静态方法:静态方法也是在类加载时就初始化,可以没有对象,直接 类名.静态方法

           静态方法初始化先于对象

           由于静态方法先于对象初始化,所以不能够在静态方法中直接使用成员方法

           由于静态方法先于对象初始化,所以不能够在静态方法中直接使用成员变量

           静态方法可以直接使用静态变量

实例:

  public class StaticTest {

//成员变量或实例变量

       private int i;

//静态变量或类变量或全局变量     

       private static int b;

// 静态代码块

       static{

              //i=10;

              System.out.println("静态代码块执行=====");

              b = 10;

       }

//普通代码块

       {

              System.out.println("普通代码块执行====");

       }

      

       public StaticTest(){

              System.out.println("构造对象========");

       }    

//成员方法

       public void a(){

              b++;

              b();

       }

       public void c(){

              a();

       }

      

//静态方法

       public static void b(){

              //this.a();   

              //i++;          

                b++;     

       }    

       public static void main(String[] args) {

              StaticTest st1 = new StaticTest();

              StaticTest st2 = new StaticTest();

               * 两个对象分别有自己的实例变量i  

               * st1.i=100  不会改变st2.i   st2.i=10

              st1.i = 100;

              System.out.println(st1.i);

              System.out.println(st2.i);

              System.out.println(StaticTest.b);

              System.out.println(st1.b);

              System.out.println(st2.b);

              st1.b = 1000;

              System.out.println(st2.b);//1000

              //静态方法可以直接调用静态方法

              b(); 

       }

}

5.要覆盖或重写父类静态方法,重写的方法必须是static静态的

  我们准确叫做  隐藏父类静态方法   

  只有子类型子对象 时,才能真正将父类静态方法隐藏起

  a.b(); //==SuperA.b(); 所以没有将父类的静态方法完全隐藏

public class SubA extends SuperA {

       public void a() {

              System.out.println("Sub A a()");

       }

       public static void b(){

              System.out.println("Sub A b()");

       }

       public static void main(String[] args) {

              SuperA a = new SubA();

              a.a();

              a.b(); //==SuperA.b(); 所以没有将父类的静态方法完全隐藏

       }

}

6.final关键字  

 * 1》如果变量前加final  就是常量

      要求(1)值不能再改变

           2)声明时必须初始化

       习惯:常量定义时字母都大写

 * 2》如果方法前加final该方法子类就不能重写

 * 3》如果类前面加final该类就不能被继承

7.访问控制:

简答题

1. 面向对象的软件开发方法用什么把数据和基于数据的操作封装在一起? //

2. 在一个类定义中,用什么描述对象的状态? //属性  用什么描述对象的行为?//方法

3. 什么方法是一个特殊的方法,用于对对象进行初始化?  //构造方法 

4. 一个源程序文件中,能有多于一个的 public类吗?  //不能源程序文件名=public.java

5. 构造方法的方法名可由编程人员任意命名吗?     //不能必须与类名相同

6. 类的构造方法名必须和类名相同吗?  //

7. 构造函数有返回值吗?   //没有,也没有void

8. 构造函数可以重载吗?  //可以

9. 如果一个类定义中没有定义构造方法,该类有构造函数吗? //有,默认的不带参数的构造方法

10. 如果一个类定义中已经定义了构造方法,java还会给它定义缺省的构造方法吗? //不会

11. 类的访问控制权有哪两种?    //publicdefault

12. 用什么修饰符修饰的方法称为静态方法?    //static

    用什么修饰符修饰的属性称为静态属性?    //static

13. 静态属性和静态方法仅属于类的一个具体对象吗?它属于谁?

    不是,属于类  

14. static 变量能是 private变量吗? //可以

15. 使用静态成员都能以什么做前缀?  //类名或对象

16.  static方法中能有this引用吗?   //不能

17. static方法中可以有this引用吗? //可以

18static方法能处理非static成员吗? //不能

19.非static方法能处理static成员吗? //

20. 类的私有属性和私有方法能不能被其子类直接访问?   //

填空题

1.下面是一个类的定义,请完成程序填空。

public  class  Myclass

{    int  x, y;

    Myclass ( int  i, int j)   //构造方法

    {

        x=i;   y=j;

    }

}

2. 下面是一个类的定义,请将其补充完整。

class  Student 

{

       String name;

       int    age;

       Student(  String  s, int  i)

   {

       name=s;

        age=i;

   }

}

3.下面是一个类的定义,请将其补充完整。

class Myclass  // 定义名为Myclass的类

{

     static int var=666;

     static int getvar()

     {   return  var;   }

}

4.下面程序的功能是通过调用方法max()求给定的三个数的最大值,

请将其补充完整。

public class Class1

{

   public static void main( String args[] )

   {

     int i1=1234,i2=456,i3=-987;

     int MaxValue;

     MaxValue=i1;

     System.out.println("三个数的最大值:"+MaxValue);

   }

   public static int max(int x,int y,int z)

   {  int temp1,max_value;

      temp1=x>y?x:y;

      max_value=temp1>z?temp1:z;

      return max_value;

   }

}

写出下列程序的输出结果

public class Test

{

       public static void main(String[] args)

       {

              Count myCount = new Count(); //无参数 count =1

              int times = 0;  //成员变量

              for(int i=0;i<100;i++)

                     increment(myCount , times);

              System.out.println("count is" + myCount.count);

              System.out.println("time is"+ times);

       }

       public static void increment(Count c , int times)  //静态方法

       {

              c.count++;

              times++;

       }

}

class Count

{

       public int count;

       Count(int c)

       {

              count =c;

       }

       Count()

       {

              count =1;

       }

}

结果:count is 101

      time is 0

编写一个类,要求使用单例模式

提示:单例模式就是这个类在使用时候只能new一个对象,多个实例都是一个对象引用

   public class Singleton {   

       private static  Singleton s;

       private   Singleton(){

              System.out.println("A Singleton Model example");

       }  

       public   static   Singleton   getInstance() {  

                if(s==null)

                       s=new Singleton();

                 return s;

       }  

        public static void main(String[] args) {

               Singleton s=Singleton.getInstance();

        }

  }

 

2011.7.26                 周二

1.类的访问控制权有publicdefault

2.单例模式实例:

  单例模式就是这个类在使用时候只能new一个对象,多个实例都是一个对象引用

  public class Singleton {

       //1 构造方法私有化

       private Singleton(){}     

       //3 声明一个该类类型的静态变量

       private static Singleton s ;     

       //2 提供一个公有的 static返回该类类型的方法

       public static Singleton getInstance(){

              if(s==null)

                     s = new Singleton();

              return s;

       }

   }

  public class SingletonTest {

       public static void main(String[] args) {       

              Singleton st1 = Singleton.getInstance();

              Singleton st2 = Singleton.getInstance();

              System.out.println(st1==st2);      //true同一个对象

       }

   }

3.==equals()的区别:

  * ==比较值相等

        原始类型比较值大小  引用类型比较对象地址   

  * equals(Object o)方法

        判定两个对象是否具有相同的类型和内容

  * equals()方法是Object类的方法 等价于==    比较对象地址

  * 如果自己的类,必须重写equals()方法

       * 约定:重写equals()方法,应该同时重写hashCode()方法

       * 达到两个对象相等,应该对象的哈希码也相同

        @Override

       public int hashCode() {

              final int prime = 31;

              int result = 1;

              result = prime * result + age;

              result = prime * result + ((name == null) ? 0 : name.hashCode());

              return result;

       }

       @Override

       public boolean equals(Object obj) {

              if (this == obj)

                     return true;

              if (obj == null)

                     return false;

              if (getClass() != obj.getClass())

                     return false;

              Student other = (Student) obj;

              if (age != other.age)

                     return false;

              if (name == null) {

                     if (other.name != null)

                            return false;

              } else if (!name.equals(other.name))

                     return false;

              return true;

       }

  实例:

     public class EqualsTest {    

        public static void main(String[] args) {

               int x =10;

              int y =10;

              System.out.println(x==y);            //true

              Student s1 = new Student("z3",20);

              Student s2 = new Student("z3",20);

              System.out.println(s1==s2);         //false

              System.out.println(s1.equals(s2));  //true

              System.out.println(s1.hashCode());

              System.out.println(s2.hashCode());

        //考题:

              String str1 = "abc";

              String str2 = new String("abc");

              String str3 = "abc";

              System.out.println(str1==str2);       //false

              System.out.println(str1.equals(str2));//true

              System.out.println(str1==str3);       //true

              System.out.println(str1.equals(str3));//true

       }

   }

4.toString()方法

     * 作用:对象转换为字符串时调用   直接打印对象时默认会调用

     * 当打印一个对象的时候,隐式调用对象的toString()方法

     * 一般要重写toString()方法。

   @Override

       public String toString() {

              return "学生名:"+this.name+"\t学生年龄:"+this.age;

       }

                //println(String s)

              System.out.println(s1.toString());

              //println(Object o)

              System.out.println(s1);

5.按照上课讲的实例开发

       Track唱片类

       Duration时间封装类  要求构造方法有传递总时间的构造方法

       TrackTest测试类

       测试打印唱片Track对象和Duration对象可以直接打印(重写toString方法)

       要求打印时间为 hh:mm:ss的格式

    public class Duration {

       private int hours;

       private int minutes;

       private int seconds;

       public int getHours() {

              return hours;

       }

       public void setHours(int hours) {

              this.hours = hours;

       }

       public int getMinutes() {

              return minutes;

       }

       public void setMinutes(int minutes) {

              this.minutes = minutes;

       }

       public int getSeconds() {

              return seconds;

       }

       public void setSeconds(int seconds) {

              this.seconds = seconds;

       }

       public Duration(int hours, int minutes, int seconds) {

              this.hours = hours;

              this.minutes = minutes;

              this.seconds = seconds;

       }

       //传递总时间的构造方法

        public Duration(int total){

              this.hours =  total/3600;

              this.minutes = total%3600/60;

              this.seconds = total%60;

       }

       //保证为2位数

       public String format(int x){

              if(x<10)

                     return "0"+x;

              else

                     return " "+x;

       }

       //重写objecttoString()方法

          控制 hh:mm:ss的格式

       public String toString(){

              if(hours==0)

                     return format(minutes)+":"+format(seconds);

              else

                     return format(hours)+":"+format(minutes)+":"+format(seconds);

       }    

   }

   public class Track {

       private String title;

       private Duration duration;

       public String getTitle() {

              return title;

       }

       public void setTitle(String title) {

              this.title = title;

       }

       public Duration getDuration() {

              return duration;

       }

       public void setDuration(Duration duration) {

              this.duration = duration;

       }

       public Track(String title, Duration duration) {

              this.title = title;

              this.duration = duration;

       }

       public Track(String title) {

              super();

              this.title = title;

       }

       public Track(Duration duration) {

              super();

              this.duration = duration;

       }

       public Track() {}

       //重写objecttoString()方法

       public String toString(){

          return title+"  "+duration;

       }

    }

   public class TrackTest {

       public static void main(String[] args) {

              Duration da=new Duration(12345);

              Track t=new Track("雪之光",da);

              System.out.println(t);  //输出  雪之光  03: 25: 45

       }

   }      

6.String

  1)分割字符串  split(String s)   根据给定正则表达式的匹配拆分此字符串。

     String str1 ="1abc_9bcd_12df3_45se6";

     String [] str1s= str1.split("_");

       for(String st:str1s){

       System.out.println(st);  //返回1abc  9bcd   12df3   45se6

  2)取子串  String substring(int beginIndex)

              返回一个新的字符串,它是此字符串的一个子字符串。

                    该子字符串从指定索引处的字符开始,直到此字符串末尾

             String substring(int beginIndex, int endIndex)

              返回一个新字符串,它是此字符串的一个子字符串。

              该子字符串从指定的 beginIndex 处开始,直到索引 endIndex - 1处的字符,

               该子字符串的长度为 endIndex-beginIndex

     String str1 ="1abc_9bcd_12df3_45se6";

     String subStr1 = str1.substring(3,16);

     System.out.println(subStr1);   //返回 c_9bcd_12df3_

  (3)boolean contains(CharSequence s)

          当且仅当此字符串包含指定的 char值序列时,返回 true

      String str1 ="1abc_9bcd_12df3_45se6";

      boolean bl = str1.contains("d");

 4public int indexOf(String str)返回指定子字符串在此字符串中第一次出现处的索引。

          如果字符串参数作为一个子字符串在此对象中出现,则返回第一个这种子字符串的第一个字符的索引;

          如果它不作为一个子字符串出现,则返回 -1

      String str1 ="1abc_9bcd_12df3_45se6"

      int index = str1.indexOf("d");

      System.out.println(index);      //返回8

 5 boolean equals(Object anObject)

       将此字符串与指定的对象比较。

     String s1 = new String("Hello");

     String s2 = s1;    

     String s3 = new String("Hello");

     System.out.println("s1.equals(s3):" + s1.equals(s3));  //true

  (6)忽略大小写比较相等  public boolean equalsIgnoreCase(String anotherString)

     将此 String与另一个 String 比较,不考虑大小写。如果两个字符串的长度相同,

     并且其中的相应字符都相等(忽略大小写),则认为这两个字符串是相等的。

     String code ="aBcD";

     String myCode ="abcd";

     if(code.equalsIgnoreCase(myCode)){

       System.out.println("验证码正确");   //验证码正确

     }

  7char charAt(int index)

         返回指定索引处的 char值。索引范围为从 0 length() - 1

     String str1 ="1abc_9bcd_12df3_45se6";

     char c= str1.charAt(3);

     System.out.println(c);   //返回c

  8int compareTo(String anotherString)

         按字典顺序比较两个字符串。

      如果按字典顺序此 String对象位于参数字符串之前,则比较结果为一个负整数。

      如果按字典顺序此 String对象位于参数字符串之后,则比较结果为一个正整数。如果这两个字符串相等,则结果为 0

     String str1 ="1abc_9bcd_12df3_45se6";

     String str2 ="1abc_9bcd_12df3_45se6";

     int j=str1.compareTo(str2);

     System.out.println(j);    //返回0

 9 String concat(String str)

         将指定字符串连接到此字符串的结尾。

    如果参数字符串的长度为 0,则返回此 String对象。否则,创建一个新的 String 对象,

    用来表示由此 String对象表示的字符序列和参数字符串表示的字符序列连接而成的字符序列。

        String str3 ="1abf3_";

              String str4 ="45se6";

              String s=str3.concat(str4);

              System.out.println(s);   //返回 1abf3_45se6

 10 boolean endsWith(String suffix)

          测试此字符串是否以指定的后缀结束。

   如果参数表示的字符序列是此对象表示的字符序列的后缀,则返回 true;否则返回 false

    注意,如果参数是空字符串,或者等于此 String对象(用 equals(Object) 方法确定),则结果为 true

        String str4 ="45se6";

        boolean b=str4.endsWith("se6");

       System.out.println(b);   //返回True

  (11) String trim()

          返回字符串的副本,忽略前导空白和尾部空白。

       此字符串移除了前导和尾部空白的副本;如果没有前导和尾部空白,则返回此字符串。

    String str5 ="    1abf3_   ";

       String s2=str5.trim();

       System.out.println(s2);//返回1abf3_

7.StringBuilder

  String 常量不可变

  * 当程序频繁改变字符串  不用使用String +运算

  * 应该使用StringBuffer 线程安全的可变字符序列。一个类似于 String 的字符串缓冲区    

     StringBuilder

  * 一个可变的字符序列。此类提供一个与 StringBuffer兼容的 API

  * 但不保证同步。该类被设计用作 StringBuffer的一个简易替换

       String str3 = "abc";

       //str3 = str3+"def";  不可取

   (1)StringBuffer append(StringBuffer sb)将指定的 StringBuffer 添加到此序列中。    

       String str3 = "abc";

        StringBuffer buffer = new StringBuffer(str3);

       buffer.append("def");                

       System.out.println(buffer.toString());   //abcdef

  8.StringBuilder

  1StringBuffer replace(int start, int end, String str)用字符串str代替startend之间的字符。

  public class StringBuilderTest {

       public static void main(String[] args) {       

              String  str1="ashghgh_";

              System.out.println(str1);                        //ashghgh_

              StringBuilder sbt=new StringBuilder(str1);

              StringBuilder sb=sbt.replace(1, 1, "12gyuopp");

              System.out.println(sb);                         //a12gyuoppshghgh_

       }

     }

9.Date

  public class DateTest {     

       public static void main(String[] args) {

              //时间 Date

              Date d = new Date();

              System.out.println(d);

              //Calendar日历   提供更加强大的时间操作

              //DateFormat时间格式化   抽象类    子类SimpleDateFormat

              //2011-07-26 10:33:36 时间格式化

              SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");

              String dStr = sdf.format(d);

              System.out.println(dStr);             

              //"2011-07-26"

              SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");

             

                     try {

                            Date d2 = sdf2.parse("2011-07-26");

                     } catch (ParseException e) {

                            e.printStackTrace();

                     }

       }

}

10.DateFormat类:是抽象类,找子类SimpleDateFormat

   1 static DateFormat getDateInstance()

          获取日期格式器,该格式器具有默认语言环境的默认格式化风格。

     String dateString = "20110724";

        try {

                Date date= new Date();

                SimpleDateFormat sdf3=SimpleDateFormat("yyyyMMdd");

                System.out.println(sdf3.parse(dateString));      

            //下面将字符串转换为日期格式后显示的格式是2008-10-12

             System.out.println(DateFormat.getDateInstance().format(date));

            //如果想换一种别的格式,可以用下面的办法,得到任何的日期格式都可以

            //输出的结果为2010/07/24

             System.out.println(new SimpleDateFormat("yyyy/MM/dd").format(date));

            //SimpleDateFormat sdf2 = new SimpleDateFormat("yyyyMMdd");  

            //输出的结果为20110724

             System.out.println(new SimpleDateFormat("yyyyMMdd").format(date));

        } catch (Exception ex) {

             System.out.println(ex.getMessage());        

        }

    }

11.Math

   1static int abs(int a) 返回 int 值的绝对值。    

       int i=-12;

       System.out.println(Math.abs(i));  //12

    (2)static double ceil(double a)

        返回最小的(最接近负无穷大)double值,该值大于等于参数,并等于某个整数。(会四舍五入)

    double j=-124.32;

       double h=234.56;

       System.out.println(Math.ceil(j));  //-124.0

       System.out.println(Math.ceil(h));  //235.0

   3 static double random()

          返回带正号的 double值,该值大于等于 0.0 且小于 1.0

        System.out.println(Math.random()*10+1);//产生1-10之间的随机数7.99223411269374

 

 

12.编程,产生随机数1-10  循环50次,统计出现的数字及个数  

    public class RandomTest {

       public static void main(String[] args) {

              int A[] = new int[11];

              for(int i=1;i<=50;i++){

                     int random = (int)(Math.random()*10+1);   

                     for(int j=1;j<=10;j++){

                            if(random == j){

                                   A[j] ++;

                            }

                     }

              }

              for(int i=1;i<=10;i++){

                     System.out.println("数字"+i+  "出现了:"+A[i]+"");

              }

       }

  }

结果:数字1出现了:4

      数字2出现了:5

      数字3出现了:6

      数字4出现了:3

      数字5出现了:7

      数字6出现了:4

      数字7出现了:2

      数字8出现了:4

      数字9出现了:10

      数字10出现了:5

13.字符串String str ="asdfghjkl";编写程序将该字符串逆序输出

  public class StringTest {

       public static void main(String[] args) {

              String str ="asdfghjkl";

              char[] cs=str.toCharArray();

              for(int i=cs.length-1;i>=0;i--){

                            System.out.print(cs[j]);

              }

       }

 }

 或:public class StringBufferTest {

       public static void main(String[] args) {

              String str ="asdfghjkl";

              StringBuffer buffer = new StringBuffer(str);

              buffer.reverse();

              System.out.println(buffer);

       }

   }

14.原始类型对应的包装类型

   八种原始类型 对应都有各自的包装类型

    包装类型作用:

       *1类型转换 比如 String--->int   String-->float

       *2到原始类型对应的类类型对象

  实例:public class WrapperClass {

            public static void main(String[] args) {

              int i = 10;

              //打包

              Integer integer = new Integer(i);

              String s = " 10 "; 

              String ss = s.trim();// "10"

              //String--->int

              //步骤1   String-->Integer--->int

              Integer is = new Integer(s.trim());

              int x = is.intValue();

              //步骤2  String--->int

              int y = Integer.parseInt(s.trim());

              System.out.println(y);

              //其他  例如   String ---float

              String s2 ="1.2";

              float f = Float.parseFloat(s2);

              /**

               * 新特性   自动打包和拆包

               */

              //Integer is2 = new Integer(10);

              Integer is2 =10;

              int m = is2;

         }

     }

14.在第二题基础上, 将字符串封装为Track对象 并输出唱片1, 390”  

  public class Duration {

       private int hours;

       private int minutes;

       private int seconds;

       public int getHours() {

              return hours;

       }

       public void setHours(int hours) {

              this.hours = hours;

       }

       public int getMinutes() {

              return minutes;

       }

       public void setMinutes(int minutes) {

              this.minutes = minutes;

       }

       public int getSeconds() {

              return seconds;

       }

       public void setSeconds(int seconds) {

              this.seconds = seconds;

       }

       public Duration(int hours, int minutes, int seconds) {

              this.hours = hours;

              this.minutes = minutes;

              this.seconds = seconds;

       }

       public Duration(int total) {

              this.seconds =total;

       }

       public String toString(){

                     return seconds+"";

       }    

    }

    public class Track {

       private String title;

       private Duration duration;

       public String getTitle() {

              return title;

       }

       public void setTitle(String title) {

              this.title = title;

       }

       public Duration getDuration() {

              return duration;

       }

       public void setDuration(Duration duration) {

              this.duration = duration;

       }

       public Track(String title, Duration duration) {

              this.title = title;

              this.duration = duration;

       }

       public Track(String title) {

              super();

              this.title = title;

       }

       public Track(Duration duration) {

              super();

              this.duration = duration;

       }

       public Track() {}

      

        public String toString(){

          return title+"  "+duration;

       }      

    }

    public class TrackTest {

       public static void main(String[] args) {

              String str="唱片1, 390";

              String [] s= str.split(",");

              int y = Integer.parseInt(s[1].trim());

              Duration d=new Duration(y);

              Track t=new Track(s[0],d);

              System.out.println(t);

       }

   }

 输出:唱片1  390

15.System

  1static long currentTimeMillis()

          返回以毫秒为单位的当前时间。

     当前时间与协调世界时 1970 1 1日午夜之间的时间差(以毫秒为单位测量)。

     public class Test {

         public static void main(String[] args) {

              long now = System.currentTimeMillis();

              System.out.println(now);  //1311727788672

         }

     }

 

 

 

 

 

 

 

 

 

 

 

 

 

 

2011.7.27                    周三

 

1.内部类:在一个类中声明另一个类(A类中声明B类,则BA得内部类)

  作用:(1)在A中的成员变量,在B方法中可以直接使用成员变量(方便访问类中的局部变量和私有变量)

       2)避免类名命名冲突

       3)在图形界面编程中常使用

  分类:成员内部类、静态内部类、局部内部类、匿名内部类

 1)静态内部类

        * 内部类最简单的形式

        * 不能和外部包围类使用相同名称

        * 编译成独立的类,外部类和内部类分开StaticOuterClass.class StaticOuterClass$StaticInnerClass.class

        * 只能访问外部类的静态成员或者方法,包括私有的

        * 看成静态方法

        * 静态内部类创建实例语法:外部类.内部类 变量 = new 外部类.内部类();

   实例:

       public class StaticOuterClass {

              private static int i = 10;//成员变量

              private int b = 10;

             public void a(){

                     i++;

                     System.out.println(i);            //11

              }    

              public static void b(){

                     //i++;

              }

              static class StaticInnerClass{      //静态内部类

                     private int i = 8;

                     public void a(){  

                            int j=StaticOuterClass.i++;       //访问外部的i变量        

                            System.out.println(j);            //11

                            i++;                       //操作内部的i变量

                            System.out.println(i);            //9

                     }

              }

       }

      public class StaticInnerClassTest {

              public static void main(String[] args) {

                     StaticOuterClass outer = new StaticOuterClass();  //创建外部类对象           

                     StaticOuterClass.StaticInnerClass inner = new StaticOuterClass.StaticInnerClass();

                     //创建静态内部类对象

                     outer.a();

                     inner.a();

              }

       }

  2)成员内部类 和成员变量成员方法平级

        * 不使用Static修饰符在包围类中定义

        * 像成员变量

        * 可以访问包围外部类的所有成员

在内部类中访问包围类的成员的语法:Outerclass.this.member 外部类.this.外部类变量

在外部类创建成员内部类对象语法:外部类.内部类  inner = new外部类(). new 内部类();

   实例:

       public class MemberOuterClass {

              private int i = 10;

              public void a(){

                     this.i++;

                     System.out.println(i);    //11

              }

              class MemberInnerClass{

                     private int i = 8;

                     public void innerA(){

                            i++; //自己的 8

                            System.out.println(i);   //9

                            //new MemberOuterClass().i++;错误的

                            this.i++;//自己的 8

                            System.out.println(i);     //10

                            int j=MemberOuterClass.this.i++;//外部类当前对象    外部类.this

                            System.out.println(j);  //10

                     }

              }

       }

       public class MemberInnerClassTest {

              public static void main(String[] args) {

                     MemberOuterClass outer=new MemberOuterClass();

                     outer.a();

                     MemberOuterClass.MemberInnerClass inner =new MemberOuterClass().new MemberInnerClass();

                     inner.innerA();

              }    

       }

   3)局部内部类

          *在方法内定义,甚至就是方法内的代码块

          * 内部类中最不常用的形式

          * 像局部变量,但不能声明成public,protected,private,static

          * 只能访问final的局部变量 ==》如果访问成员变量,可以直接方法

                                              如果访问局部变量,局部变量必须是final的常量

 

    实例:

       public class LocalOuterClass {

              private int i =10;    

              public void a(final int x){

                     //x++;  //错误:x是常量不能改变值

                     i++;

                     System.out.println(i);     //11

                     final int b =8;//局部变量

                     class LocalInnerClass{

                            public void a(){

                                   i++;//错误,不能访问非final的常量

                                   int y = b;  //局部变量必须是final的常量8

                                   y = x;      //传入的值

                            }

                     }           

              }

       }

   4)匿名内部类

          * 局部内部类的一种特殊形式

          * 直接访问final的局部变量

          * 没有class关键字   没有类名

          * 没有extends/implements关键字

         * 只用一次,必须指明变量初值

          * 通常都是隐式的继承父类   实现接口

          * 下面例子 开发一个匿名内部类隐式的实现了Shape接口

          * 并且同时创建了一个匿名内部类对象,他的类型是Shape类型的

          * 匿名内部类:

              优点:代码编写简单

              缺点:很难理解

          * 总结:

             new 抽象父类/接口(){

                    大括号包含的就是匿名内部类

             }

    实例:

       public interface Shape {        //定义一个Shape接口

              public void area(); 

       }

       public class UseShape {

              public void area(Shape s){

                     s.area();

              }

      

              public static void main(String[] args) {

                     UseShape us = new UseShape();

                     us.area(new Shape(){            //匿名内部类

                            private double r=3;

                            @Override

                            public void area() {

                                   System.out.println("圆形面积:"+(Math.PI*r*r));

                            }

                    

                     });

              }

       }

2.练习内部类的使

  <1>编写Shape接口,包含getArea()方法

  <2>编写ShapeTest类,该类中有方法 getArea(Shape s){ s.getArea();}

     main方法中测试,调用该getArea(Shape s)方法,

     要求传递参数s的值对象是通过成员内部类、静态内部类、匿名内部类的对象

   publicinterface Shape {

       publicvoid getArea();

}

publicclass ShapeTest {

       publicvoid getArea(Shape s){

            s.getArea();

       }

    //成员内部类

    class Circleimplements Shape{

        privatedoubler=7;

        publicvoid getArea() {

        System.out.println("成员内部类:圆的面积是 "+(int)Math.PI*r*r);      }

    }

    //静态内部类

    staticclass Recgiterimplements Shape{

        privatedoublew=6;

        privatedoublel=6;

        @Override

        publicvoid getArea() {

            System.out.println("静态内部类:长方形的面积是 "+w*l); 

        }

    }

    publicstaticvoid main(String[]args) {

        ShapeTest st=new ShapeTest();

        //匿名内部类

        st.getArea(new Shape (){

            privatedoubler=5;

            @Override

            publicvoid getArea() {

        System.out.println("匿名内部类:圆的面积是 "+(int)Math.PI*r*r);     }

        });

        st.getArea(new ShapeTest2().new Circle());

        st.getArea(new ShapeTest2.Recgiter());

    }

}

3.比较2个学生

  1)Student类中实现接口Comparable,重写compareTo抽象方法

       public int compareTo(Student o) {

             return this.age-o.getAge();

       }

      在测试类中:

      public Student min(Student s1,Student s2){

          return s1.compareTo(s2)>0?s2:s1;

      }

   (2)直接在测试类中:匿名内部类

       StudentTest st = new StudentTest();

       Student s1 = new Student("zhangsan",20);

       Student s2 = new Student("lisi",30);

       class StudentComparator implements Comparator<Student>{

       @Override

       public int compare(Student o1, Student o2) {

              return o1.getAge()-o2.getAge();

       }    

       }

4.集合框架:一个集合就是可以并只能存放其它对象的特殊对象

           Java中实现集合功能需要实现三个元素

  集合与数组的区别:

  1)数组定长,集合可变长

  2)数组只能存放一种类型,集合可以存放多种类型,只要是对象就可以

   习惯:一个集合中只存放同一种类型对象

  接口:定义每一种集合形式必须实现的方法

  实现:具体的实际类如:Hashtable,Vector

  算法:存储、获得以及操作集合众元素的方法

  注意:Package java.utiljava.util包中

  集合接口框架:分为两类:Collection接口和Map接口(结构不同分) ,

                         其中Collection接口分为List接口和Set接口(算法不同分),

                          Set接口包含Sortedset,

                          Map接口包含SortedMap接口(MapKey,value键字,key不能重复作为主键,)

    Set不允许存放相同的对象(有相同的对象不添加)、元素是无序的。

    SortedsetSet类似,但在Sortedset集合中的元素是有序存储的。

    List元素是有序的,按照添加元素的顺序保持,删除元素时也保证元素是连续有序的,并且允许存储重复的对象。

    Map通过唯一的主键和值的影射来存放对象、不允许有相同的主键。无序的,

            有相同的Key,value值会覆盖,value可以重复,只能根据keyvalue值。

    SortedMapMap类似,但存放主键是默认按照升序的方式存放,借此保证对象的有序。只按Key排序

  集合框架中类的层次关系:分为两类:Collection下包含HashSet[Set]类和LinkedListVectorArrayList[List]

                      HashSet下包含TreeSet[Sortedset];HashtableHashMap[Map]下包含TreeMap[SortedMap].

 

5.开发一个最简单的集合练习类ListTest 练习使用ArrayList集合对应的方式使用一下VectorLinkedList集合

import java.util.*;

import simple.Student;

public class ListTest {

       public static void main(String[] args) {

              //1 选择自己想用的集合  创建对象

              List list1= new ArrayList();       //ArrayList

              List list2 = new Vector();        //Vector

              List list3 = new LinkedList();    //LinkedList

              //2.添加元素

              list1.add("abc");

              list1.add(123);

              list1.add(12.9);

              list1.add(new Student());

              list2.add("abc");

              list2.add(new ShapeTest());

              list2.add(9.0);

              list2.add(63);

              list3.add("abc");

              list3.add(new ShapeTest());

              list3.add(9.0);

              list3.add(63);        

              System.out.println(list1.get(0));

              System.out.println(list1.size());

              System.out.println(list2.get(1));

              System.out.println(list2.size());

              System.out.println(list3.get(2));

              System.out.println(list3.size());

              //取值

              System.out.println(list1);

              System.out.println(list2);

              System.out.println(list3);

              //取值

              for(int i=0;i<list1.size();i++){

                     Object o1 = list1.get(i);

                     System.out.println(o1);

              }

              for(int j=0;j<list2.size();j++){

                     Object o2 = list2.get(j);

                     System.out.println(o2); 

              }    

              for(int k=0;k<list3.size();k++){

                     Object o3 = list3.get(k);

                     System.out.println(o3); 

              }

                    

       }

}

6.编写一个学生类Student

  编写一个学生业务类StudentBO

                    该类编写一个集合属性List students setter getter方法

                    编写一个方法添加学生方法,将一个学生添加到属性students

                    实现时要求集合存在相同的学生不添加,不存在相同的添加学生

  编写一个StudentBOTest类,测试添加学生方法 

 public class Student implements Comparable<Student> {

        private String name;

        private int age;

       public String getName() {

              return name;

       }

       public void setName(String name) {

              this.name = name;

       }

      

       public int getAge() {

              return age;

       }

       public void setAge(int age) {

              this.age = age;

       }

       public Student(String name,int age) {

              this.name = name;

              this.age = age;

       }

       public Student() {}

      

       public String toString(){

              return name+ " "+age;

       }

       //按照学生年龄升序排列 如果年龄相同  按照名字降序

       @Override

       public int compareTo(Student o) {

              if(this.age!=o.getAge()){

                     return this.age-o.getAge();

              }else{

                     return -this.name.compareTo(o.getName());

              }

       }           

       @Override

       public int hashCode() {        

              return this.name.hashCode()+this.age;

       }

       @Override

       public boolean equals(Object obj) {

              Student s = (Student)obj;

              if(this.name.equals(s.getName())&&this.age==s.getAge())

                     return true;

              return false;

       }

}

 

import java.util.*;

public class StudentBO {

        List<Student>  students;

 

       public List<Student> getStudents() {

              return students;

       }

       public void setStudents(List<Student> students) {

              this.students = students;

       }

 

       public StudentBO(List<Student> students) {

              this.students = students;

       }

       public StudentBO() {}

      

       public void addStudent(Student s){     

              if(!students.contains(s))

                     students.add(s);

       }    

       public String toString(){

              return students+ " ";

       }    

}

import java.util.*;

public class StudentBOTest {

       public static void main(String[] args) {

              Set<Student> set = new HashSet<Student>();

                    

              Student s1 = new Student("zhangsan",14);

              Student s2 = new Student("lisi",21);

              Student s3 = new Student("wangwu",22);

              Student s4 = new Student("zhangsan",14);

              Student s5 = new Student("gaoxing",43);    

              set.add(s1);

              set.add(s2);

              set.add(s3);

              set.add(s4);

              set.add(s5);

          Iterator<Student> it= set.iterator();

              while(it.hasNext()){

                     Student s=it.next();

                     System.out.println(s);

                    

              }

       }

}

 

 

 

 

 

 


版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

Java学习笔记 (1)

  • 2013-08-17 20:24
  • 100KB
  • 下载

java转入C#学习笔记-1

自学了java一年多,什么ssh都特意整了一圈,结果找工作进入了一家.net平台开发的公司。。。泪奔。。 。苦逼又得从基础搞起。         不过还好c#和java算是两兄弟吧,起步总不至于太...

JAVA学习笔记1

  • 2008-07-13 19:33
  • 49KB
  • 下载

java web学习笔记day1

学习传智播客java视频按照老师所讲学习 今天的学习内容{ 1.按照 博客园的一篇帖子 MyEclipse 2015优化技巧 优化了我的myeclipse2015把我的myecl...

java学习笔记1

  • 2008-06-28 10:47
  • 208KB
  • 下载

JAVA学习笔记最新ppt版1

  • 2008-01-19 10:03
  • 473KB
  • 下载

Java学习笔记1

我们知道在面向对象的程序设计语音中有两个很重要的概念,就是类和对象,其中类是某一批对象的抽象,我们可以 把类理解成某种概念,那对象就是一个具体存在的实体。 在接下来讲解的Java语言就是一门面向对象的...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)