【321手机视频简介】
【321手机视频】是android操作系统手机上一款轻巧，灵巧便捷、响应敏捷的多媒体终端。通过终端可以随时随地的观看来自央视全套电视台和
全国30多个省级以上的电视台，还可以观看来自优酷、土豆、奇艺、乐视网、56网、PPTV、 激动网等国内主流视频网站的视频信息。
【支持视频格式】
divx 、xvid 、wmv 、flv 、ts 、rmvb 、rm 、mkv 、 mov 、 m4v 、avi 、mp4 、3gp 、mpg
【支持流媒体格式】
MMS
RTSP (RTP, SDP)
HTTP progressive streaming
HTTP live streaming (M3U8), for Android 2.1以上系统
http://www.eoemarket.com/apps/76026
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）
简 要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。
而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的：
String S1 = “This is only a” + “ simple” + “ test”;
StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个
String S1 = “This is only a” + “ simple” + “test”; 其实就是：
String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：
String S2 = “This is only a”;
String S3 = “ simple”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;
这时候 JVM 会规规矩矩的按照原来的方式去做
在大部分情况下 StringBuffer > String
StringBuffer
Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。
可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。
StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。 append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。
在大部分情况下 StringBuilder > StringBuffer
java.lang.StringBuilder 一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。
一、 Static关键字（出现在三个地方：属性前、内部类前和方法前）(注：Test是类名，Demo是静态内部类，Demo1是普通内部类)
A. Static属性只和类相关，与对象无关，使用方法：类名.静态属性。有对象肯定就会有类（先有类才会有对象），这样就可以调用static属性
B. 内部静态类：在main方法中创建内部类对象时，应写成：Test.Demo demo=new Test.Demo();
C. 由于main方法是静态方法，在执行main方法时还没有创建内部类对象，当在创建内部类时，应先将外部类new出之后，在new内部类，即Test.Demo1 demo1=new Test().new Demo1()。（补充 ：system.out.println();方法，system本身是一个类，out是其中的一个方法，但其本身也是一个对象，就可以调用它内部的println方法）
二、构造方法私有化（构造方法（即构造器）前加Private）
A. 单例模式：又叫单态，由于构造器私有，所以别人不能new，可创建一个本类的属性，通过一个静态方法换回一个自身的对象，不管对象被创建多少个，它始终只有一个对象，例：
public class TestSingle{
//单例 或 叫单态
//构造器私有
//创建一个本类的静态属性
//通过一静态方法换回一个自身的对象
private static TestSingle single=null;
private TestSingle(){}
public static TestSingle getTestSingle(){
if(single != null){
return single;
}else{
return new TestSingle ();
}
}
}
public class Main{
public static void main(String[] args){
TestSingle s1=TestSingle .getTestSingle();
TestSingle s2=TestSingle .getTestSingle();
System.out.println(s1==s2);
}
}
三、对象数组（数组的每个元素都是一个对象）
如：public class ObjectArrary {
String name;
int age;
public ObjectArrary(String name){
this.name=name;
}
public ObjectArrary(String name,int age){
this.name=name;
this.age=age;
}
public String getObject(){
return "姓名： "+this.name+" 年龄："+this.age;
}
}
public class GetObject {
public static void main(String[] args) {
ObjectArrary[] a=new ObjectArrary[3]; //这里只是定义数组和数组的长度
a[0]=new ObjectArrary("a",21); //给数组元素赋值
a[1]=new ObjectArrary("b",21);
a[2]=new ObjectArrary("c",21);
//也可以写成：ObjectArrary[]a={newObjectArrary("zhang",22),newObjectArrary("wei",21),
newObjectArrary("xiao",22)};
for(int i=0;i<a.length;i++){
System.out.println(a[i].name+" "+a[i].age);
}
}
}
四、JDK新支持
A. 可变参数，如下：
public class Main{
public static void main(String[] args){
getInt(1,2,3,4);
getInt(1);
getInt(new int[]){1,2,3,4};
}
public static void getInt(int ...is){ //…表示参数没有限制，只是整型数组，数量可变
for(int i:is){
System.out.println(i);
}
}
}
B、自动拆箱、装箱
就是简单数据类型和对象可以互相转换，如：
Int i=new Integer(3);
Integer t=5;
C、泛型
ArrayList<String> list=new ArrayList<String>();
List.add(“str”);
D、注解：是给程序看的，给编译器看的，有的注解可以控制程序的流程
E、静态导入：将静态方法用import导入，在调用的时候，就可以直接写方法名
Import static com.itszt.swallow.Person.show;
在调用时，直接写：show();
(com.itszt.swallow为包名，Person是类名，是静态方法名)
F、代码块：
Ø 普通代码块
Ø 构造块（游离块和构造块功能重复，一般不用游离块）
Ø 静态代码块
Ø 同步代码块，其中此代码块在多线程中部分进行讲解
比较各代码块的执行顺序：（静态代码块à游离代码块à构造方法块）
public class Daimakuai {
//游离块，又叫构造块
{
System.out.println("这是父类游离块");
}
public Daimakuai(){
System.out.println("这是父类构造方法块");
}
static{
System.out.println("这是父类静态代码块");
}
public void go(){
System.out.println("这是父类普通方法");//被对象调用的时候执行
}
}
public class Daima extends Daimakuai{
//游离块，又叫构造块
{
System.out.println("这是子类游离块");
}
public Daima(){
System.out.println("这是子类构造方法块");
}
static{
System.out.println("这是子类静态代码块");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Daimakuai d=new Daima();
}
}
此段代码运行的结果是：
这是父类静态代码块
这是子类静态代码块
这是父类游离块
这是父类构造方法块
这是子类游离块
这是子类构造方法块
（补充：system.exit()是终止程序，退出系统）
五、内部类
Ø 局部内部类：在方法中写的类
public class Main{
public static void main(String[] args){
}
public void show(){
class Person{
String name;
public void gerMsg(){
name="wei";
}
}
new Person().getMsg();
}
}
Ø Final关键字
public class Main{
public static void main(String[] args){
}
//1、局部内部类中，如果调用方法的局部变量，则该变量必须声明为final类型
//2、或者把该变量定义为成员变量，即全局变量
//String name=”aa”;
public void show(){
final String name=”aa”;
class Person{
public void gerMsg(){
System.out.println(name);
}
}
new Person().getMsg();
}
}
² Final修饰一个变量时，这个变量值就是不能被改变，即定义一个常量
² 在方法前，代表此方法不能被重写或覆盖
² 在类前，代表此类不能被继承
² 在使用常量时，最好将final和static一起使用，调用时直接使用类名点常量名，即类名.常量名。如final static String s= “person”,调用时String a =Test.s;（Test为类名）。
六、 抽象类
Ø 抽象类即，类中有个抽象方法（只有声明，没有实现），关键字abstract，抽象类不能new。
Ø 当一个类继承抽象类时，要实现抽象类中的抽象方法，如果这个类也是抽象类，就不用实现父类中的抽象方法了，直接继承。
Ø 不能用final来声明抽象类，因为final声明的类不能被继承，而抽象类必须被继承，那么抽象类中的抽象方法就无法被实现，那这个抽象类就没有任何意义了
Ø 抽象类不能被new，但是有构造方法，在子类new创建对象时，父类的构造方法就会被执行
七、接口
Ø 接口中的属性就是常量，默认的是final声明的，即常量必须赋值且不能改变，所以属性都是常量(public final static)int i=10，所以方法都是抽象方法(public abstract)void go();
Ø 理解上，可以认为如果抽象类中的所有方法都是抽象方法，则这个抽象可以定义为接口
Ø 实际上，接口不是类，接口就是接口，是一种规范
Ø Java中类是单根继承的，即只能继承一个类，但一个类可以实现多个接口；接口可以继承接口，且接口可以继承多个接口
未完待续。。。。。。。。。。。。。
想了解很多请点击http://itszt.losoon.com/a/xueyuanxinde/2012/0320/235.html