帐前卒专栏

String a = "  dfsd";///////////这时输出dfsd。  
String b = a.trim();//////////除开头结尾的空格。  
concat(string s）/////////////把s 加在执行串后。  
substring(int n)///////////////从第n个字符之后的串。  
boolean equals(String s);////////////执行串与s完全相同,但不检查时不是同一个对象。  
boolean equalsIgnoreCase(String s);//忽略大小写对比。  
//String类中的toString()法可以用于debug。如：System.out.println(*.toString());

char charAt(int n);///////返回第n个字符。  
boolean startsWith(String s);/////////如果执行串以s开头返回true。

//////////int x = 0, y = 1, z = 2;  
//////////System.out.println(sString + x + y + z);///////这里把x，y，z都转换为string，而不是相加然后再转换为string

Math.random()//////可以生成随机数。生成0~1的随机小数。并且会随时间的变化而变化。可以产生0，但不能产生1  
java.lang.Character.isLowerCase((char)i) //检测i是否为小写。

Graphics a；  
a.drawOval(size.width/4,size.height/4,size.width/2,size.height/2);////////此时椭圆
在中心。  
a.drawString("Hello world
gj",20,200);/////20是最左的象素坐标，200是基线  
  
Cbox()  
{  
setLayout(new FlowLayout());  
Checkbox cb = new Checkbox("he");//////复选框有2个构造器Checkbox(String
s)&Checkbox(String s,boolean state).  
add(cb);///if there isn't this statement, theCheckbox won't appear.  
setSize(200,200);  
}

CheckboxGroup cbg = new CheckboxGroup();  
Checkbox(String s,boolean state,CheckboxGroup cbg)&Checkbox(String
s,CheckboxGroup cbg,boolean state);/////这样可以建单选框。

setLayout(new FlowLayout());  
Choice c = new Choice();  
for(int i = 0;i < fontFamily.length;i++)  
c.add(fontFamily[i]);  
add(c);  
c = new Choice();/////////////////////////这样相当于新建一个下拉单选框。  
for(int i = 0;i < size.length;i++)  
    c.add(size[i]+"");  
add(c);  
setSize(200,200);

public class TestFrame extends Frame {  
    public void doDemo(){  
        Button b = new Button("Press Me!");  
        b.addActionListener(new ButtonHandler());///在这里添加实现  
        add(b,BorderLayout.CENTER);  
        pack();////如果没有这句，最初按钮是看不到的。最大化后才会看到。  
        setVisible(true);  
    }  
    public static void main(String args[]) {  
        TestFrame   f = new TestFrame();  
        f.doDemo();  
    }  
    ////////以下是一个内部类  
    public class ButtonHandler implements ActionListener {  
        public void actionPerformed(ActionEvent e) {  
        setTitle("Button's label is :" +
        e.getActionCommand());////这里getActionCommand（）函数返回的是控件的名称。  
        }  
    }  
}

textTabbedPane = new JTabbedPane(JTabbedPane.BOTTOM);/////将标签放在下部。  
privateScrollPane = new JScrollPane();  
privateTextPane = new JTextPane();

privateTextPane.setEditable(true);///////这是把JTextPane设置为可以编辑的。（是否能让用户编辑）  
// privateTextPane.setName("");//////这句似乎没什么用。  
privateScrollPane.setViewportView(privateTextPane);///JScrollPane可以显示JTextPane
上的内容。  
textTabbedPane.addTab("private",privateScrollPane);//这句才是把最重要的。把JScrollPane放在J
TabbedPane上。  
add（textTabbedPane）///把JTabbedPane放在JFrame上。

TextArea ta = new
TextArea(10,20);/////////////////////用于创建文本框。第一个参数为高度，第二个为长度。  
Scrollbar sb = new Scrollbar(Scrollbar.HORIZONTAL)；////////////用于建一个水平方向的控制条。

add(sb,"North");//////这就是边框管理器。之前不再用setLayout(new FlowLayout());

add(p,"South");//////////////"South"一定要大写。

Panel p = new Panel();//////////创建新面板。  
p.add(new Button("HI"));  
p.add(new TextField("ldldl",10));//////////可以将几个构件锁在一起。  

public SelfListener()  
{  
    setLayout(new FlowLayout());  
    for(int i = 0;i < btn.length;i++)  
    { 
        btn[i] = new Button(s[i]);  
        btn[i].addActionListener(this);  
        add(btn[i]);  
    }  
    tf = new TextField(25);  
    add(tf);  
    setSize(200,300);  
}  
public void actionPerformed(ActionEvent e)  
{  
    if(e.getSource() == btn[0])  
        nCon -= 1;  
    else if(e.getSource() == btn[1])  
        nCon -= 2;  
    else  
        nCon -= 3;  
    tf.setText(nCon + " Left.");  
    if(nCon < 3)  
        btn[2].setEnabled(false);  
    if(nCon < 2)  
        btn[1].setEnabled(false);  
    if(nCon == 0)  
    {  
        Label ab = new Label("win!");//////////在这里会出现混乱。//////win!迟迟不出现。只有变化窗口的时候才会  
        add(ab,"South");///////////////////////出现。  
        btn[0].setEnabled(false);  
    }  
}  

tf.setText("Font Color is "
+ c.getItem(c.getSelectedIndex())
+ cb[i].getLabel() );//////////////////此处用于返回checkbox所选项。

btn[i].addActionListener(this);  
btn[i].addActionListener(this);//////////此时进行两次调用。点一次鼠标有两次动作。

publicTextPane.setEditable(false);///这个面板是否可以操作。  


////      publicTextPane.setName("");//////////////////?似乎没有什么用。  
publicScrollPane.setViewportView(publicTextPane);//让面板显示  
textTabbedPane.addTab("public",publicScrollPane);//在textTabbedPane上添加滚动条。

///   frameClient.getContentPane().add(new JButton(),  BorderLayout.CENTER);/////////这句话用于JFrame添加控件。

public float getrain(float a) throws Exception  
{  
    if(a < 0)  
    {  
        Exception x = new Exception("the db must be wrong!");  
        throw x;  
    }  
    else  
        return 0;  
}  
/////////使用这个方法时要用  
try{  
    ....................  
}  
catch(Exception x)  
{
    ................  
}  

import java.io.IOException;  
import java.awt.AWTException;  
import java.sql.SQLException;  

package mypackage;  
import mypackage.*;/////程序员永远不用这样定义。

package cc;  
public class Cctest  
{  
protected int  id;  
protected void show()  
{  
System.out.println(id);  
}  
}  
  
package dd;  
import cc.Cctest;  
public class C extends Cctest  
{  
float salary;  
protected void show(C A)      //在子类中被超越。  
{  
System.out.println(A.id);///////子类实例可用。  
System.out.println(A.salary);  
}  
}//////////this is right.  

package dd;  
import cc.Cctest;  
public class C extends Cctest  
{  
float salary;  
protected void show(Cctest A)  
{  
System.out.println(A.id);//this is wrong.  
}  
}
```  



  
超类版本访問 | 子类版本访问 | 
-------|--------|
public | public | 
protected | public    protected | 
default |public    protected    default | 
private |public    protected    default    private | 
  
把main放在超类中。这样以后可以用超类的引用子类实例的超越的所有类型的函数。  
  
终结类不能子类化，终结方法不能被超越。终结变量得到初始化后不能被修改。 

```java

private void show()///////////在超类中。  
{  
System.out.println("a = " + a + " b = " + b + " c = " + c);  
}  
public void show()///////////在子类中。  
{  
System.out.println(add());  
}  
PrivateClass pri1 = new SubPrivate();//////////超类引用子类。  
pri1.show();////////////调用的是超类中的show().  

package Interface;  
interface OverrideB  
{  
void b();  
void c(int s);  
}  
~~~~~~~~~~~~~~~~~~~~
package Interface;  


interface A  
{  
    void b();  
    int c(int s);  
}  

~~~~~~~~~~~~~
package Interface;  
public class Override implements OverrideB,A  
{  
    public void b()//这段代码是正确的.但软件工程不要求这样做.  
    {  
    
    }  
    public int c(int s){//这里不正确.两个接口中的方法可以函数签名和返回值都相同.但不能只有返回值不同.  
    return 3;  
    }  
}  

interface AandB extends A,B  
{  
  
}

public abstract class AbClass  
{  
   abstract void draw();  
}  
package Interface;  
interface AbInterface extends AbClass  
{  
  
}  

class A  
{  
    public static void main(String [] args)  
    {  
        System.out.println("hello");  
    }  
}  
  
public class PublicTest  
{  
  
}

class sub  
{  
    String a;  
    int num;  
    sub()  
    {  
        a = "Hello";  
        num = 3;  
    }  
    public static void main(String []arg)  
    {  
        MainClass mc = new MainClass();  
        System.out.println(mc.s.a);  
        System.out.println(mc.s.num);  
    }  
}  
  
public class MainClass  
{  
    String t;  
    sub s;  
    MainClass()  
    {  
        s = new sub();  
        t = "hhh";  
    }  
  
}
```  
这里编译通过，运行也可以。可能是上一个类调用了MainClass  
不过要注意的一点是一个java文件中最多只有一个public类。  
只要声明成public 或省略public的类都可以在其他的java文件中调用。  
但是如果一个类没有声明是public，那么它的方法和成员有可以不能被其他文件的类看到。  
但是仍然可以使用他们。不过这个类中的私有成员不能被访问，其他类型的都可以。  
详见：PublicTest.java 与PublicTest1.java  
一个类可以有多个子类，但不能有多个超类.  
java中没有缺省值。这里的缺省值是指函数中参数的缺省。如test（int a ＝ 0）这样写是错误的。  
不过java中类的成员有缺省值。如Default.java  
并且成员变量先被缺省赋值,然后再在构造器被赋值.  
  
重载函数时要注意函数签名不同即传入的函数参数的个数或参数的类型不同。OverLoading.java  
java中可以几个文件联编。  
  
float类型共输出9位。  
  
超越是函数签名,返回值,参数列表均相同.  
超载是参数列表不同.  

```java
Super officer = new Sub("dd",1);/////这是使用的引用是子类被超类引用.  
officer.setSalary(333333.3432f);  
officer.show(); //////这里服从sub类中的show().  
Super manager = new Super("cc",2);  
manager.setSalary(900000.3432f);  
manager.show();  /////这里服从super类.  

```  
  
上面代碼为多态.  
  
无变元构造器这样定义:  
```java
public class Waterbird  
{  
    float weight;  
    Waterbird()  
    {  
    }/////////不能用Waterbird();  
}  

abstract class SupConstruction  
{  
    SupConstruction()  
    {  
        System.out.println("SupConstruction constructed!");  
        con();  
        System.out.println("con");  
    }  
    abstract void con();//虚拟函数  
}  
public class Construction extends SupConstruction//继承虚拟类  
{  
    int i =9;  
    Construction()  
    {  
        super(); //调用构造函数  
        System.out.println("Construction constructed");  
    }  
    public void con()//超越虚拟方法  
    {  
        System.out.println("Con "+i);  
    }  
    public static void main(String [] args)  
    {  
        Construction c = new Construction();//实例化.  
    }  
} 

class sub  
{  
    String a;  
    int num;  
    sub()  
    {  
        a = "Hello";  
        num = 3;  
    }  
}

public class MainClass  
{  
    String t;  
    sub s;  
    ///这样写没有错误。  
    MainClass()  
    {  
        s = new sub();  
        t = "hhh";  
    }  
    public static void main(String []arg)  
    {  
        MainClass mc = new MainClass();  
        System.out.println(mc.s.a);  
    }  
}

public class MainClass  
{  
  String t;  
  sub s;  
  ///这样写有错误。  
  public static void main(String []arg)  
  {  
    s = new sub();  
    System.out.println(s.a);  
  }  
}

class Test  
{  
int num = 3;  
static void show(Test a)/////////////////如果想在main中直接使用函数名得以实现就必须加static  
{  
System.out.println(a.num);  
}  
}  
//如果在main中这样实现：  
Test out = new Test();  
out.num = 10;  
out.show(out); //This is very important!  

TestB b = new TestB();  
TestAAndB ab = b;  
ab.b();////compile  error  

////////////////////////////对象就是数据+方法。

 /////////////这样构造类
class person1                               /////////////但不能这样声明  public class person1
{   ///////////////这样写会出错 。
    String name;
    int age;
}
public class person
{
    public static void main(String[]
    args)/////////main函数的参数必须这样写不能省略args，当然可以使用其他的变量
    { person1 test = new person1();
    }
}

///////////////////这样也可以
public class person
{ String name;
int age;
public static void main(String[] args)
{ 
    person test = new person();
}
}

class person //////////////class 前的public 可以不写。
{
public static void main(String[] args)
{
..........................................
}
}

class person1
{
    String name;
    int age;
    void test()
    {
        in t = new in(); /////////////////////每一次都必须实例化。
        t.test1();   ////////否则编译失败。
        System.out.println("person1");
    }
    class in ///////////////内部类
    {
        void test1()
        {
            System.out.println("in");
        }
    }
}

Flower(String s)  
{  
    System.out.println("String create");

}  
Flower(int i)  
{  
    System.out.println("int create");  
}  
Flower(String s,int i)  
{  
    this(i);////放在最前面  
    System.out.println("String and int create");

}

class SupClass
{
    public SupClass(int id)
    {
        System.out.println(id+"SupClass is construct!");
    }
}
public class Init extends SupClass
{
    static int i;////////这样写在super（i）处就不会出错。
    public Init()
    {
        super(i);
        i=0;
    }
}
/////变化一下：
public class Init extends SupClass
{
    int i;
    public Init()
    {
        super(i);//这里就会报错。这是因为先初始化static变量，后进行自身类的构造函数调用，后调用基类构造函数，再进行
        i=0；  //自身类中成员变量的初始化。
    }
}
//////////再写一个类
public class ObjOrPri {
    SupClass a= new SupClass(i);//这里会报错，这就意味着成员对象是顺序进行的初始化。
    int i;

    ObjOrPri()
    {
        System.out.println(a);
    }
}

public class ObjOrPri {
    int i;
    SupClass a= new SupClass(i);/////这里就不会报错。
    ObjOrPri()
    {
        System.out.println(a);
    }
}

boolean [] a;  
a = new boolean [] {true,false};  
System.out.println(a[0]+" "+a[1]);    //this is right.  
System.out.println(a[0]+a[1]);         //this is wrong. Because two boolean can't add .  
System.out.println(a[0],a[1]);           //this is also wrong. Because the function can't take two paraments take two paraments.

ArrayList c;  
c = new ArrayList();  
for(int i = 0;i<26;i++)  
c.add("hello"+i);  
System.out.println(c);  
////////可以在程序过程中输入任意多个数据放入这种数组。  
Iterator a = c.iterator();//////////////这里是获得c的迭代器。  
while(a.hasNext())////////这里判断下一个是否存在。  
System.out.println(a.next());  
/////////这里不要产生误解：认为第一个打印不出来。这里可以看出迭代器初始值是指向第一个元素，  
/////////打印时只是先打印了元素再向后指。

/////////不过要说明的是java中没有指针这个概念，不过我学c/c++多年很自然的想用这个概念。

for(int i = 0;i < 10;i++)  
System.out.println(i);  
for(int i = 0;i < 10;i++)  
System.out.println(i*10);  
////////////////////这样写并没有出错，这与c＋＋不同。代表在for循环以外i已经被销掉。不能再使用i这个变量

int i = 3;  
{  
char i = 'c';//////////这里将出错，与c++不同。c++中将在第一个输出点输出c  
System.out.println(i);  
}  
System.out.println(i);  
～～～～～～～～～～～～～～～～～～～～～～～～～～  
int i = 3;  
{  
char q = 'c';  
System.out.println(q);  
}  
System.out.println(i);  
System.out.println(q);///////////这里也会编译失败，原因是q已经超出作用范围。

///////在声明数组或对象时，创建的是一个引用。无论声明什么样的数组，引用都是32位宽。  
int [] ages;  
int [] otherAges;  
otherAges = new int [5];  
ages = otherAges;  //认为把otherAges的引用赋给ages  
////如果otherAges[2] = 2;  
////则ages[2] == 2;

//////////////////////////////函数不用声明。  
//////////////////////////////传入到函数中的数组被永久的改变了。

int [] b = new int []{1,2,3,5,7};  // this is right.  
int [] b = new int [5]{1,2,3,5,7}; //this is wrong.  
/////////////////////////////////////////////////////////////////  
static int[] creat(int a)///返回一个数组。  
{  
int[] array = new int [a];  
..................................  
return array;  ///只写数组名。  
}

Object a = new Object();

Object b = a;

////////break和continu只能跳出一层循环。
///////如果前面加上标签，就可以随意跳出循环
outer:
while(true) {
    while(true) {
        i++;
        System.out.println("i = " +i);
        if(i == 1) {
        System.out.println("continue");
        continue;
        }
        if(i == 3) {
        System.out.println("continue");
        continue outer;////////这里可以跳到最外层循环再循环。
        }
        if(i == 5) {
        System.out.println("break");
        break;
        }
        if(i == 7) {
        System.out.println("break");
        break outer;///////////跳出out
        }
    }
}

int a = 1;
switch(a)
{
case 1:
System.out.print(a);
case 2:
System.out.print(a+1);
}///////可以打印出12，这是不加break的后果