JAVA编程思想

1.类的多型性

void doStuff(Shape s) { 
    s.erase(); 
    s.draw();
}

Circle c = new Circle();
Triangle t = new Triangle();
Square s = new Square();
doStuff(c);
doStuff(t);
doStuff(s);

//doStaff中无需关心具体是什么类型。直接用基础类型即可完成所有的衍生类

2.迭代器Iterator

用来遍历list而无需关心list中具体存放的类型是什么

 list l = new ArrayList();
 l.add("aa");
 l.add("bb");
 l.add("cc");

 for (Iterator iter = l.iterator(); iter.hasNext();) {
     String str = (String)iter.next();
     System.out.println(str);
 }
 /*迭代器用于while循环
 Iterator iter = l.iterator();
 while(iter.hasNext()){
     String str = (String) iter.next();
     System.out.println(str);
 }
 */

3.数据类型

boolean 1 位 - - Boolean

char 16 位 Unicode 0 Unicode 2 的 16 次方-1 Character

byte 8 位 -128 +127 Byte（注释①）

short 16 位 -2 的15 次方 +2 的 15 次方-1 Short（注释①）

int 32 位 -2 的 31 次方 +2 的31 次方-1 Integer

long 64 位 -2 的63 次方 +2 的 63 次方-1 Long

float 32 位 IEEE754 IEEE754 Float

double 64 位 IEEE754 IEEE754 Double

Void - - - Void无数据类型

4.static的使用

静态成员

class StaticTest {
  static int num=47;  
}

StaticTest s1 = new StaticTest();
StaticTest s2 = new StaticTest();

此时访问s1.num 和 s2.num 都是47;
若s1.num+1  则s1.num 和 s2.num都变为48 因为s1和s2都指向同一个内存区域

静态方法

class StaticTest2{
  static void incr(){
  
  }
}

可以通过两种方法来调用他
1.声明对象
StaticTest2 s2 = new StaticTest2();
s2.incr();

2.静态方法直接调用
StaticTest2.incr();

让当前代码休息5秒

try {

　　Thread.currentThread().sleep(5 * 1000);

} catch(InterruptedException e) {

}

5.数组和ArrayList

* 数组的长度是不可变的。所以如果要对一个数组扩容，应该用临时数组，将这个短的数组赋值给新的数组

* ArrayList的长度是可变的。不够时他会自动增加

6.继承

java中类不可以多继承（类中可以存在多个同名方法，容易混乱）。但是接口可以多继承，用逗号隔开

interface Vampire extends DangerousMonster, Lethal { 
    void drinkBlood()
}

7.上溯造型和下塑造型

上溯造型：继承后，以基础类为对象来调用。

上溯：

class Instrument {
    public void play(Note n) { 
        System.out.println("Instrument.play()");
    }
}

class Wind extends Instrument {
    // Redefine interface method: 
    public void play(Note n)
        System.out.println("Wind.play()");
    }
}

public class Music { 
    public static void tune(Instrument i) { 
        // ... i.play(Note.middleC)
    };

    public static void main(String[] args) { 
        Wind flute = new Wind(); 
        tune(flute); // Upcasting
    }
}

下溯造型：继承后，以将对象转换成扩展类来调用。

import java.util.*;
class Useful { 
    public void f() {} 
    public void g() {}
}

class MoreUseful extends Useful { 
    public void f() {}
    public void g() {} 
    public void u() {}
    public void v() {}
    public void w() {}
}

public class RTTI { 
    public static void main(String[] args) { 
    Useful[] x = { new Useful(), new MoreUseful() };
    x[0].f(); 
    x[1].g(); 
    // Compile-time: method not found in Usefu
    //! x[1].u(); 
    ((MoreUseful)x[1]).u(); // Downcast/RTTI          
    ((MoreUseful)x[0]).u(); // Exception thrown }} ///
    }
}

8.集合的类型

a.Vector

addElement() 插入对象

elementAt(index) 　一次提取一个对象

elements()　　获得序列的枚举

b.stack--也称为“后入先出”集合

数组的每一行都通过 push()继承进入堆栈，稍后用 pop()从堆栈的顶部将其取出。

Vector 操作亦可针对 Stack 对象进行。这可能是由继承的特质决定的Stack属于Vector。

因此，能对Vector 进行的操作亦可针对Stack 进行，例如 elementAt()方法

Stack stk = new Stack(); 
for(int i = 0; i < months.length; i++) 
    stk.push(months[i] + " ");
System.out.println("stk = " + stk);

c.新集合arrayList

List（接口）顺序是 List 最重要的特性；它可保证元素按照规定的顺序排列，可以重复

Collection c = new ArrayList();
Iterator it = c.iterator();
while(it.hasNext()) {
　　
}

ArrayList 提供了以下方法：

addFirst()，addLast()，getFirst()，getLast()，removeFirst() 以及removeLast();

d.Set

Set（接口）添加到 Set 的每个元素都必须是独一无二的；否则Set 就不会添加重复的元素

public static Set fill(Set a, int size) { 
    for(int i = 0; i < size; i++) {
        a.add(new MyType(i)); 
        return a;
}

e.Map

Map（接口）维持“键－值”对应关系（对），以便通过一个键查找相应的值.key是唯一的

结论

1.可以看出，在ArrayList 中进行随机访问（即get()）以及循环反复是最划得来的；但对于LinkedList 却是一个不小的开销。

但另一方面，在列表中部进行插入和删除操作对于 LinkedList 来说却比ArrayList 划算得多。

我们最好的做法也许是先选择一个ArrayList 作为自己的默认起点。以后若发现由于大量的插入和删除造成了性能的降低，再考虑换成LinkedList 不迟。

2.进行add()以及contains()操作时，HashSet 显然要比 ArraySet 出色得多，而且性能明显与元素的多寡关系

不大。一般编写程序的时候，几乎永远用不着使用 ArraySet。

3.最后，当我们使用 Map 时，首要的选择应该是 HashMap。只有在极少数情况下才需要考虑其他方法。

9.IO

从InputStream（输入流）衍生的所有类都拥有名为read()的基本方法，用于读取单个字节或者字节数组

从OutputStream 衍生的所有类都拥有基本方法 write()，用于写入单个字节或者字节数组

posted @ 2018-05-08 15:36 林被熊烟岛阅读(170) 评论(0) 收藏举报

刷新页面返回顶部