发新话题
打印

JAVA学堂_____从零开始

第八课   编辑字符串
   由于String类生成的字符串对象是不变的,一旦对象生成后,无法直接被改变,那么StringBuffer类就可以生成可变字符串,但StringBuffer对象无法像String对象一样直接将字符串指定StringBuffer对象,所以下面这个例子是非法的:
StringBuffer mystring1=”this is a string”
下面的才是合法的:
  StringBuffer mystring1=new StringBuffer(“this is a string!”);
  StringBuffer mystring2=new StringBuffer();    //默认容量为16个字符
  StringBuffer mystring3=new StringBuffer(50);
下面我们看一个具体的实例:
public class StringBufferDemo{
        public static void main(String args[]){
                StringBuffer sb=new StringBuffer();
                sb.append("abcde");
                System.out.println("\""+sb+"\"  length:"+sb.length()+",capacity:"+sb.capacity());
                sb.insert(0,"fhjjk");
                System.out.println("\""+sb+"\"  length:"+sb.length()+",capacity:"+sb.capacity());
                sb.append("lmnopqr");
                System.out.println("\""+sb+"\"  length:"+sb.length()+",capacity:"+sb.capacity());
        }
}
首先我们看其中几个方法的作用:
append()----在后面追加字符,这个不一定是字符串也可以是其它基本数据
length()-----返回对象的长度
capacity()—返回对象的容量
insert()------在指定的位置插入字符串
下面是输入的结果:
"abcde"  length:5,capacity:16
"fhjjkabcde"  length:10,capacity:16
"fhjjkabcdelmnopqr"  length:17,capacity:34
在结果中我们看最后一个,由于其总的宽度已经超过了16位默认容量,这时系统将自动将容量进行调整为16*2+2。
我们用这节课的内容再把上节课中的例子做一下改动,来完成相同的结果:
public class StringBufferDemo{
        public static void main(String args[]){
                String s1="this is my original string";
                String s2="original";
                System.out.println("original string:\""+s1+"\"");
                System.out.println("string to be deleted:\""+s2+"\"");
                int index=s1.indexOf(s2);
                if(index==-1)
                {System.out.println("no string matched!");}
                else
                {
                        StringBuffer sb=new StringBuffer(s1);
                        sb.delete(index,index+s2.length());
                        s1=sb.toString();
                        System.out.println(s1);
        }
}
}
这里面我们用了一个StringBuffer中的一个delete方法,它可以把两个位置之间的字符删除。
如果我们应用字符串替换的时候还可以使用replace(起始位置,结束位置,字符串)来实现。

TOP

第九课  字符串比较

在字符串比较时使用==做为比较方法和基本数据类型是不一样的,在JAVA中这种比较是比较两个字符串是否指向了同一个地址,而不会比较其中的内容,如果比较内容的话,我们需要以下的String提供的方法:
s1.compareTo(s2):如果S1大于S2则返回大于0的一个数;如果S1小于S2则返回小于0的一个数;如果S1等于S2,则返回0
s1.compareToIgnoreCase(s2):作用同上,不区分大小写
s1.equals(s2):如果两字符串相同返回真值,否则返回假值
s1.equalsIgnoreCase(s2):作用同上,不区分大小写
我们来看下面的例子:
public class StringDemo{
        public static void main(String args[]){
                String s1="this is a";
                String s2="this is a string";
                String s3;
                s3=s1;
               
                System.out.println("s1="+s1);
                System.out.println("s2="+s2);
                System.out.println("s3="+s3);
                System.out.println("s1==s3???"+(s1==s3));
                System.out.println("s1==s2???"+(s1==s2)+"\n");
               
                s1=s1+" string";    //s1指向了新的地址
                System.out.println("s1="+s1);
                System.out.println("s1==s3???"+(s1==s3));
                System.out.println("s1==s2???"+(s1==s2)+"\n");
                System.out.println("s1 equals s2????"+s1.equals(s2)+"\n");
               
                s2="This is a string";
                System.out.println("s2="+s2);
                System.out.println("s1 equals s2????"+s1.equals(s2)+"\n");//区分大小写
                System.out.println("s1 equals s2????"+s1.equalsIgnoreCase(s2)+"\n");//不区分大小写
               
                int result=s1.compareTo(s2);
                if (result>0)
                        System.out.println("S1 is greater than S2");
                else
                  if (result<0)
                     System.out.println("S1 is less than S2");
                  else
                     System.out.println("S1 is equal to S2");}}

TOP

第十课  输入输出

一、        在输入出中,我利用System.out.println()可以非常容易实现了,比如以下输出:
  public class outputTest{
        public static void main(String args[]){
                float x;
                x=100.0f/3.0f;
                System.out.println(x);
                System.out.println(100.0/3.0);
        }
}
结果:
33.333332
33.333333333333336
在输出中我们看到结果是不一样的,当然我们知道是由于精度的不同造成的,因为在100.0和3.0中默认为双精度的。
我们这节课中讨论的并不是这个结果,而是如何输出一个格式化的数字,比如货币或是百分比的。
在java.text包中,提供了NumberFormat类可以产生这种格式,然后我们再用format方法来得到格式化的字符
import java.text.*;
public class outputTest{
        public static void main(String args[]){
                double x;
                x=100.0/3.0;
                NumberFormat f1=NumberFormat.getNumberInstance();//数字格式
                String s=f1.format(x);
                System.out.println(s);
                NumberFormat f2=NumberFormat.getPercentInstance();//百分比格式
          s=f2.format(x);
          System.out.println(s);
          NumberFormat f3=NumberFormat.getCurrencyInstance();//货币格式,这跟系统区域有关
          s=f3.format(x);
          System.out.println(s);
                }
}
输出结果分别为:
33.333
3,333%
$33.33
三、        键盘输入:我们选看下面的例子
import javax.swing.*;
public class inputTest{
        public static void main(String args[]){
                String name=JOptionPane.showInputDialog("please input you name:");
                String input=JOptionPane.showInputDialog("please input you age:");
                int age=Integer.parseInt(input);
                System.out.println("your name:"+name+"  you age:"+age);
        System.exit(0);
                }
}
现在我们给出的键盘输入的包在javax.swing中,我们利用JOptionPane类的showInputDialog()方法来实现。Integer类的parseInt()方法实现由字符串转换成了数值。在最后中,我们利用java.lang.System类的exit(0)方法是把运行状态码传递给操作系统,并退出。

TOP

第十一课  数组
一、        数组的定义
1、格式:  类型  数组名[];
char a[];
char [] b;
float c[];
float []d;
以上定义是合法的,[]可以放在前面,也可以放在后面,在JAVA的习惯中是放在前面的。
2、        特点:
①数组定义不分配内存空间,因此不必指定数组大小
②一个数组中的元素应该是同一类型的
③数组中的元素是有顺序的
④数组中的一个元素通过数组名和下标值来确定
二、数组的建立:分配内存空间,有两种方法
①通过关键字new来建立数组:
  a=new char[5];
  char []e=new char[5]
②直接指定初值的方法建立数组
  int []f={1,2,3,4,5};
三、数组的初始化
①静态方法:直接在字义数组时就进行初始化,如:
String []name={"marry","klood","carry"};
  int []age={43,35,46}
②动态方法:用 new关键字来分配内存,如:
                String []name;
                name=new String[3];
                name[0]="marry";
                name[1]="klood";
                name[2]="carry";
注:在下标中取值为0~(N-1)之间,否则在运行时会出现下标越界
四、二维数组的定义
int [][]ma=new int[3][3];
int [][]mb={{1,2,3},{4,5,6},{7,8,9}};
int [][]mc=new int [3][];
mc[0]=new int[10];
mc[1]=new int[5];
mc[2]=new int[3];
五、应用举例:
1、
public class arrayTest{
        public static void main(String args[]){
                int []year={1992,1993,1994};
                int i;
                System.out.println(year.length);
                for(i=0;i<year.length;i++){
                                        System.out.println(year);
                                }
                }
}
2、
public class mainMess{
        public static void main(String args[]){
                if (args[0].equals("-h"))
                  System.out.print("Hello ");
                else if (args[0].equals("-g"))
                  System.out.print("good bye ");
                for(int i=1;i<args.length;i++)
                  System.out.println(args);
                }
        }
六、数组的排序和复制
我们通过下面的例子来说明它的使用方法:
import java.util.*;
public class copyAndsort{
public static void main(String args[]){
         int []a={1,2,3,4,5,6,7,8};
         int []b={100,200,300,400,500,600,700};
         System.arraycopy(a,2,b,3,3);
         for(int i=0;i<b.length;i++)
         System.out.println(b);
         Arrays.sort(b);
         for(int i=0;i<b.length;i++)
           System.out.println(b);
          }
        }
arraycopy方法实现了复制,从a的第2下标处开始,到b的下标3开始的3个字符
Arrays类在包java.util中,使用其中的sort方法实现快速排序。

TOP

第十二课  运算符
一、算术运算符:
单目:+(取正)  -(取负)  ++(自增1)  - -(自减1)
双目:+  -  *  /  %(取余)
说明:
1、++:在后边时先算后加1,在前边时先加1后算
2、- -:同加加
3、%:只能用于整数,取得相除余数
我们通过例子说明这些的用法:
public class addTest{
        public static void main(String args[]){
                int i=10,j=10;
                System.out.println((++i)*(j--));            //110
                System.out.println("i="+i+"  j="+j);    //I=11  j=9

                System.out.println((i--)*(++j));        //110
                System.out.println("i="+i+"  j="+j);    //I=10  j=10

                System.out.println("\'i++\'="+(i++)+"\'++i\'="+(++i));   //'I++'=10  '++I'=12
                System.out.println("i="+i+"  j="+j);   //I=12  j=10
                System.out.println(10%3);    //1
                System.out.println(3%10);    //3
        }
}
二、关系运算:
  ==   !=   >   <   >=   <=
这个我们多次用到了,随便举个例子:
import javax.swing.*;
public class booleanTest{
                public static void main(String args[]){
                String i=JOptionPane.showInputDialog("please input your age:");
                int age=Integer.parseInt(i);
                if (age>18)
                  System.out.println("Your are a man");
                else
                  System.out.println("Your are a younger");
    System.exit(0);
        }
}
三、逻辑运算符:
  &(与)  |(或)  !(反)
&:当两边同时为真时,结果为真,否则为假
| :当两边有一边为真时,结果为真,否则为假
! :真值变假值,假值变真值
我们看下面的例子:

public class booleanTest{
public static void main(String args[]){
  boolean a,b;
  a=true;
  b=!a;
  System.out.println(a&b);
  System.out.println(a|b);
        }
}

TOP

第十三课  运算符

四、位运算
  ~(按位取反)  &(按位与)  |(按位或) ^(按位异或)
  >>(右移)     <<(左移)  >>>(不带符号左移)
比如:
I=17  其二进制形式为  00010001
j=15  其二进制形式为  00001111

①则~I    11101110(负数为补码)à换成原码应该取反后+1,即10010010=-18
注:大家在算取反运算的时候其实你只要正数取负后减1,负数取正后减1。
②I&j    0  0  0  1  0  0  0  1
           0  0  0  0  1  1  1  1
           0  0  0  0  0  0  0  1
结果为:1
③I|j     0  0  0  1  0  0  0  1
           0  0  0  0  1  1  1  1
           0  0  0  1  1  1  1  1
结果31
④I^j     0  0  0  1  0  0  0  1
            0  0  0  0  1  1  1  1
            0  0  0  1  1  1  1  0
结果:30
程序如下:
public class bitTest{
        public static void main(String args[]){
                byte i=17,j=15;
                System.out.println(~i);
                System.out.println(i&j);
                System.out.println(i|j);
                System.out.println(i^j);
        }
}
现在我们看位移的例子:
public class bitTest{
        public static void main(String args[]){
                byte i=8,j=-8;
                System.out.println(i<<3);
                System.out.println(j<<3);
                System.out.println(i>>2);
                System.out.println(j>>2);
                System.out.println(j>>>31);
        }
}
①i<<3        0 0 0 0 1 0 0 0
左移三位        0 1 0 0 0 0 0 0
                  =64
②j<<3        100000000000000000000000000001000
                  100000000000000000000000001000000
                     =-64
③I>>2        0 0 0 0 1 0 0 0
        0 0 0 0 0 0 1 0
                   =2
④j>>2        100000000000000000000000000001000
                    100000000000000000000000000000010
            =-2
⑤j>>>31        100000000000000000000000000001000
                    000000000000000000000000000000001
                     =1
五、复杂赋值运算符
运算符        例子        等价于
+=        X+=Y        `X=X+Y
-=        X-=Y        `X=X-Y
*=        X*=Y        `X=X*Y
/=        X/=Y        `X=X/Y
%=        X%=Y        `X=X%Y
&=        X&=Y        `X=X&Y
|=        X|=Y        `X=X|Y
^=        X^=Y        `X=X^Y
<<=        X<<=Y        `X=X<<Y
>>=        X>>=Y        `X=X>>Y
>>>=        X>>>=Y        `X=X>>>Y
这个只是个简写的形式,自己看看吧
六、条件运算符:
运算符  X?Y:Z
这是一个三目运算,首先判断X是真值或假值,真值时返回Y的值,假值时返回Z的值。
看下面的例子:
public class conditionTest{
        public static void main(String args[]){
                int i,j=5,k=10;
                i=j>k?3:20;
        System.out.println(i);}
}

[ 本帖最后由 黑雨 于 2006-11-28 08:09 AM 编辑 ]

TOP

第十六课  面向对象的基本概念
一、基本概念:
OOP:object oriented programming(面向对象程序设计)
类:是一个抽象的模型,它由成员变量和成员方法组成
对象:类的实例化
数据封装:把对象和数据组合起来的操作
继承:从一个类中派生出的新类,称为子类,子类继承父类的功能与属性,同时也可以产生新的功能与属性。
接口:它不是一个类,而是对符合接口需求的类的一套规范。一个类可以有多个接口。它的提出主要是为了弥补JAVA只支持单重继承机制造成的缺陷。
多态性:主要表现在接口和抽象类上
对象的生命周期:创建、使用和释放。
二、创建对象的步骤:
1、声明对象:
  如:String str;
2、实例化对象
  str=new String();
我们看一个具体的实例:
class Car{
private String tireType;//轮胎型号
private int gearNum;//排档数
private float engine;//引擎排气量
public Car(String t,int g,float e){
this.tireType=t;
this.gearNum=g;
        this.engine=e;
}
public void Equipment(){
System.out.println("轿车排档数"+gearNum);
        System.out.println("轿车轮胎型号"+tireType);
  System.out.println("轿车排气量"+engine);
}
}
public class ObjectTest{
public static void main(String args[]){
Car test=new Car("3号",3,13);
test.Equipment();
}
}
说明:
1、类明的第一个字母应该大写,并具有该类的特征
2、通常类成员都是私有的,而方法是公有的
3、构造方法用来定义对象的初始状态,每个类都有构造方法
4、构造方法每个类都有,其名称必须与类名相同
5、构造方法不能被用户直接调用,只能通过new自动调用
6、构造方法没有返回值,但不能用 void来声明

TOP

第十四课  基本程序结构

程序的基本结构包括:顺序、分支和循环,顺序结构是指程序从上执行到下,这是总的结构形式,那么我们说的如果……那么……即为分支结构,而我们当反复的执行某种语句的时候则为循环结构。
注:在C语言中,可以在嵌套块中定义相同的变量,而在JAVA中是不允许的。
一、分支结构:
1、IF(条件表达式)
语句或语句组;
   [ELSE
语句或语句组;]
这种语句我们以前用了不少,现在我们再举个例子:
   要求从键盘输入学生成绩,输出相应的等级:
import javax.swing.*;
public class ifTest{
public static void main(String args[]){
        String f=JOptionPane.showInputDialog("please input your grage:");
        int g=Integer.parseInt(f);

        if (g>=60){
          if (g>=90)
            System.out.println("优秀");
          else
            System.out.println("及格");
          }
        else{
                if (g>0)
                   System.out.println("不及格");
                else
                   System.out.println("缺考");
                  }
        System.exit(0);
}
}
2、switch(表达式)
   {
case 常量:
  [语句或复合语句;]
  [break;]
case 常量:
  [语句或复合语句;]
  [break;]
……
[default:
[语句或复合语句;]]
}
我们还是继续上面的例子来改装一下:
import javax.swing.*;
public class switchTest{
public static void main(String args[]){
        String f=JOptionPane.showInputDialog("please input your grage:");
        int g=Integer.parseInt(f)/10;
  switch(g)
  {
          case 10:
          case 9:
            System.out.println("优秀");
            break;
          case 8:
          case 7:
          case 6:
             System.out.println("及格");
             break;
          case 5:
          case 4:
          case 3:
          case 2:
          case 1:
             System.out.println("不及格");
             break;
          default:
             System.out.println("缺考");
            }
            System.exit(0);
          }
  }

TOP

第十五课  基本程序结构(2)

二、循环结构:
for(初始表达式;判断表达式;递增表达式;)
  {
语句体
}
下面我们举二个例子:
1、计算1加到100之和
public class forTest{
public static void main(String args[]){
int s=0;
for(int i=1;i<=100;i++)
s+=i;
System.out.println(s);
}
}
2、计算1到15的阶乘
public class forTest{
public static void main(String args[]){
long fact;   //注意定义数据的范围
for(int n=1;n<=15;n++)
{
fact=1;
for(int i=2;i<=n;i++)
  fact*=i;
System.out.println(n+"!="+fact);
}
}
}
其它循环结构:
do
{
  循环体语句组
}
while(条件表达式)
while(条件表达式)
  {
语句组
}
以上两种循环结构比较类似,但区别在于,第一种循环开始时没有条件,所以循环体至少执行一次,而第二种循环当条件表达式第一次就为假值时一次循环体都不执行,其它的就都一样了。
看下面的例子:
public class whileTest{
public static void main(String args[]){
char ch;
try
{
System.out.println("please input a string(* to exit)");
while((ch=(char)System.in.read())!='*')
{if(Character.isDigit(ch))
System.out.println(ch+"is a digit");
else
  if(Character.isLetter(ch))
        if(Character.isUpperCase(ch))
           System.out.println(ch+"is Uppercase letter");
        else
           System.out.println(ch+"is Lowercase letter");}
          }
catch(Exception e)
{System.out.println("I/O error coours!");}
}
}
以上程序中用到了异常捕捉try—catch—finally,这个以后我们还要讲,这里就不再说了。
用于循环的几个流程控制
1、break:用于从循环中跳出,当用于标号时,可以直接从标号退出如:
  abc:if(I=1){
for(int j=0;j<10;j++)
if(j>I)
  break;
else
break abc;
}
2、continue:从此位置跳转到循环开始位置继续执行,它的用法是与break的用法一样的
3、return:返回上级调用程序
4、throw:这是例外处理机制中的一个特殊的流程,我们以后再讲

TOP

第十六课  面向对象的基本概念
一、基本概念:
OOP:object oriented programming(面向对象程序设计)
类:是一个抽象的模型,它由成员变量和成员方法组成
对象:类的实例化
数据封装:把对象和数据组合起来的操作
继承:从一个类中派生出的新类,称为子类,子类继承父类的功能与属性,同时也可以产生新的功能与属性。
接口:它不是一个类,而是对符合接口需求的类的一套规范。一个类可以有多个接口。它的提出主要是为了弥补JAVA只支持单重继承机制造成的缺陷。
多态性:主要表现在接口和抽象类上
对象的生命周期:创建、使用和释放。
二、创建对象的步骤:
1、声明对象:
  如:String str;
2、实例化对象
  str=new String();
我们看一个具体的实例:
class Car{
private String tireType;//轮胎型号
private int gearNum;//排档数
private float engine;//引擎排气量
public Car(String t,int g,float e){
this.tireType=t;
this.gearNum=g;
        this.engine=e;
}
public void Equipment(){
System.out.println("轿车排档数"+gearNum);
        System.out.println("轿车轮胎型号"+tireType);
  System.out.println("轿车排气量"+engine);
}
}
public class ObjectTest{
public static void main(String args[]){
Car test=new Car("3号",3,13);
test.Equipment();
}
}
说明:
1、类明的第一个字母应该大写,并具有该类的特征
2、通常类成员都是私有的,而方法是公有的
3、构造方法用来定义对象的初始状态,每个类都有构造方法
4、构造方法每个类都有,其名称必须与类名相同
5、构造方法不能被用户直接调用,只能通过new自动调用
6、构造方法没有返回值,但不能用 void来声明

TOP

发新话题