java（未检出20130729） String、StringBuffer、类与类之间关系：依赖关系Use-a、.聚合关系has-a、组合继承（“is-a”）、抽象类、接口

public class TestMain{

       publicstatic void main(String aaa[]){//用来接收运行时输入参数

              System.out.println(aaa[2]);

       }

}

java TestMain one two three four

输出的结果:

Three

 

数组有length属性，String有length()方法//作用获取数组或字符串长度

 

String:是一个定长(根据硬件来确定长度)非线程安全的字符串类

Eg：

System.out.println(str.charAt(0));//查找索引位置的元素

        System.out.println(str.concat("123"));//字符串链接方法

        System.out.println(str+"123");//字符串链接运算

        System.out.println(str.indexOf("d"));//查找字符 找到就放回索引位置，找不到就返回-1

        System.out.println(str.lastIndexOf("d"));//查找字符 找到就放回索引位置，找不到就返回-1

        System.out.println(by.length);

        System.out.println(str.length());//求字符串长度：索引最大等于长度减1

       

        String str3 =str.replaceAll("d","9");

        String str4 =str.replace("d","9");//替换 将str中的"d"替换成"9";

        System.out.println(str3);

        String []strs =str.split("d");

        System.out.println("字符串拆分");

        for(String str5:strs){

            System.out.println(str5);

        }

        System.out.println(str6.equals("String1"));//比较值

System.out.println(str.substring(8));//取子串 从小标为8开始取，取到字符串末尾

        System.out.println(str.substring(8,12));//取子串 包含开始位置 不包含结束位置 当结束位置大于字符串长度时会跑出java.lang.StringIndexOutOfBoundsException异常

 

 

StringBuffer：是一个变长且线程安全的字符串类

StringBuffer str=new StringBuffer(20);//指定初始化长度

        str.append("0123456789");

        str.append(true);//添加字符串

        System.out.println(str.length());//求字符串长度

        System.out.println(str.delete(str.length()-4, str.length()));//移除时包含开始位置

        System.out.println(str.substring(8));//下标位置为8的开始取(包含下标位置) 取到字符串末尾

        System.out.println(str.insert(8,true));//在此下标位置之前插入boolean值

        System.out.println(str.insert(8,9));//在此下标位置之前插入int值

 

StringBuilder：是一个变长且非线程安全的字符串类.

StringBuilder str = new StringBuilder(20);

        str.append("01234567890123456789");

        System.out.println(str.replace(0, 1,"abc"));//字符替换 包含下标开始位置，不包含下标结束位置

        System.out.println(str.toString());//获取值

 

 

类与类之间关系

1.Use-a

依赖关系

Eg:

publicclass Dog {

    publicvoid running(){

        System.out.println("dog running");

    }

}

 

/**

 * use-a

 * @author Administrator

 *依赖关系：Person类遛狗方法中用到DOG类的running()方法。

 */

publicclass Person {

    publicvoid liugou(){

        Dog dog  = new Dog();

        dog.running();

    }

 

}

2.聚合关系

/**

 * 聚合关系 has-a

 * @author Administrator

 *Cat类中有Mouse实例，当cat实例销毁时，mouse对象同时被销毁，mouse的生命周期受cat的生命周期影响

 *一个类中有另外一个成员变量

 */

publicclass Cat {

    Mouse mouse;

    publicvoid eat(){

        mouse =new Mouse();

        System.out.println("吃"+mouse);

    }

 

    publicvoid working(){

        mouse =new Mouse();

        System.out.println("抓"+mouse);

    }

}

publicclassMouse {

 

}

 

3.组合：

/**

 * 组合：Bus中有Compartment；TireEntity；EngineEntity类的成员，并且在构造方法中进行初始化

 * @author Administrator

 *

 */

publicclass Bus {

    private Compartmentcom;//车厢成员

    private TireEntityte;//轮胎成员

    private EngineEntityee;//发动机成员

    public Bus() {

        super();

        this.com = new Compartment();

        this.te =new TireEntity();

        this.ee =new EngineEntity();

    }

}

 

publicclassTireEntity {

 

}

publicclassEngineEntity {

 

}

publicclass Compartment {

 

}

 

4.继承（“is-a”）

特殊和一般的关系

[访问修饰符] [修饰符] 类名 [extends父类名称]{类体}

 

抽象类:

抽象方法一定在抽象类中，抽象类中不确定有抽象方法。

为了不让实例化，对类进行抽象，抽象类中有抽象方法（没有实现代码，只有方法定义）,可以有抽象方法，也可以有实现方法，普通类继承抽象类之后必须实现抽象方法(抽象类继承抽象类之后可以不实现抽象方法)。

允许（但不要求）抽象类包含抽象成员;抽象类当中可以存在非抽象的方法

访问修饰符 abstract 类名{

访问修饰符 abstract  返回值类型 方法名称(参数列表);

访问修饰符  返回值类型 方法名称(参数列表){方法体}

}

 

 

抽象类不能被实例化

用abstract关键字来修饰一个类时，这个类叫做抽象类

Abstract class Animal{}

用abstract来修饰一个方法时，该方法叫做抽象方法

只需声明，而不需实现

当父类中的方法不能够实现时使用抽象方法

public abstrac void sing();//注意没有方法体

 

成员方法和成员变量遵循访问修饰符的规则。

继承不能多继承。

 

接口：

关键字：interface

格式：访问修饰符interface 接口名{

常量定义;

公共抽象方法(参数列表);

}

接口中定义所有方法都是公共抽象方法，不能有实现方法。

接口中定义的变量默认是public static final修饰的常量。

接口可以多继承接口

普通类可以实现多个接口(必须实现接口中所有方法)

普通类可以继承一个抽象类

抽象类可以继承一个抽象类

抽象类可以实现多个接口

接口不能继承抽象类

 

接口(interface)是抽象方法和常量值的定义的集合。

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

实现多态  一个实例可以存放到，此类实现接口的所有类型的变量中。

接口中所有的方法都是public abstract。

在接口中声明方法时，不能使用native、static 、final 、synchronized 、private 、protected等修饰符。

 

一个普通可以继承一个类，同时实现多个接口

Eg：

publicclass Dogextends Runnerimplements IAnimal,IPet {

    @Override

    publicvoideat(){

    }

    @Override

    publicvoid sleeping() {

    }

}

 

 

Serializable接口比较特殊又被称做marker,因为它没有任何方法要被实现.

它的作用在于实现它的类可以被序列化.

class Dog implementsserializable{

}

序列化的好处在于：

使对象可以在网络上传输。

可以使对象写到文件中