Java基础笔记杂糅

http://blog.csdn.net/e_wsq/article/details/8878796

http://blog.csdn.net/e_wsq/article/details/8878796 

 

hadoop视频资料

 

局部变量没有默认值

Equal用来对比是不是字符串相等，而不是String对象相等，对象的相等用==，指是不是指向堆里面同一个对象，这个对象里面的属性变量肯定相等。但是equal是个函数，用来判断属性变量是否相等，也可以用来判断这个对象的其他属性

 

 

 

ArrayList<>数组在删除元素后会自动删除这个格子，索引会自动更新。

 

不能减低方法的存取权限

这代表存取权限必须相同，或者更多开放。举例来说，你不能覆盖掉一个共有的方法并将它标记为私有，这会让它以为编译期通过的是一个公有，然后突然在执行期才被java虚拟机阻止存取

 

就算只有一个抽象方法，该类都要标记为抽象的

 

在一个引用一个object对象的时候检查这个object是不是一个Dog对象可以用  ob instanceof Dog 这个条件判断来判断是不是Dog对象

 

实现interface时还是必须在某个类的继承之下

 

 

Java可以有与类同名的方法而不会变成构造函数，其中的差别在于是否有返回类型，构造函数不会有返回类型

 

编译器看到是参数的类型和顺序，而不是参数的名字，如果2个函数名一样，但是参数顺序不一样，那么是2个不同的函数

 

对super（）调用的必须是构造函数的的一个语句

 

This（）只能用在构造函数中，且必须是第一行语句

 

Super（）与this不能兼得

 

想象一下如果一个构造函数同时调this（）指向另外一个构造函数，又同时用super调用父类，那么如果另外一个构造函数也包含父类呢、？那么是调用哪个父类

 

 

静态方法无法引用到该类的任何实例变量

因为不知道是哪个对象的实例变量

 

静态变量会在该类的任何对象创建之前就完成初始化

 

常数变量的名称应该都是大写，并以下划线字符分割

 

Final的变量要赋初值，并且不可以改变

 

可以通过以下方法来初始化

 

Public class Bar{

Public static final double BAR_SIGN；

Static{

BAR_SIGN  = （double）Math。Random（）；//这样也能初始化

}

}

 

 

ArrayList<Interage> listOfName = new ArrayList<Interage>();

等于在用int的包装类，因为我5.0之前都要用包装来包装以个inti，现在可以直接用了，不过在用list的时候用interage来声明类型，list自动帮你转化为int（autoboxing功能）

 

 

 

你可以在使用primitive主数据类型作为运算子的操作只能怪以包装类型来替换，这代表你可以对integer的对象做递增运算！

Integer I = new Integer(42);

I ++;

 

Or

 

Integer j = new Integer(5);

Integer k = j + 3;

 

 

String。Format（”the rank is%,d out of %,.2f”,one,two）;

在这里可以看出有参数个数不一定，那么是不是有很多重载的版本呢？不是的

Java语言需要一种新的功能—称为可变参数列表（varable argument list）

 

如果某实例变量不能或不应该被序列化，就把它标记为transient（瞬时）的

那么在序列化的时候就不会序列化这个变量

 

如果在序列化对象的那个对象类所引用的对象中没有implements serializable的话会出现序列化失败

 

反序列化回来的是个object，所以要强制转换成原来对象的类型

 

对象必须实现序列化这个接口才能被序列化，如果父类实现序列化，则子类也就自动地有实现，而不管是否有明确的声明

 

读取对象的顺序必须与写入的顺序相同

 

静态变量时不会被序列化，因为所有对象都是共享同一份静态变量值

 

 

解序列化的时候如果类的版本不同的话，那么java虚拟机就会在还原过程中抛出异常

因此，解决方案就是把serialVersionUID放在class中，让类在演化的过程中还维持相同的id

Public class Dog（）{

Static final long serialVersionUID = -1234322131r31433L;

Private String name;

Private int size;

}

 

Mythread.start()要调用start（）才会让线程开始执行，在此之前，它只是个Thread的实例，并不是真正的线程

 

控制多线程的同步化原子性让方法原子化有几种方法

 

 

Public synchronized void increment(){

Int I = banlance;

Banlanece = I + 1;

}

这样就不会执行I = banlance的时候跑去执行其他线程

保证Banlanece = I + 1;获得的值就是当时想要的值

 

或者用这种方法

 

Public void go(){

Dostuff();

 

Synchronized(this){

CriticalStuff();

MoreCriticalStuff();

}

}

 

 

 

Collection.sort(songList);可以让实现了Collection接口的容器排序

 

 

Java泛型的声明

声明类为泛型

Public class ArrayList<E> extends AbstracList<E>…{

         Public Boolean add(E o);

}

 

Public <T extends Animal> void takeThing(ArrayList<T> List)

如果类本身好呢没有使用类型参数，你还是可以通过一个不寻常但是可行的位置上指定给方法---在返回类型之前。这个方法以为着T可以是“任何一种Animal”；      

 

 

 

Compareable接口是用泛型的，所以在继承时候要

Class Song implement Comparable<Song>{…

Public int compareTo(Sone s){

         Return title.compareTo(s.getTitle());

}

}

 

 

或者用自己定制接口comparator类

classArtistCompare implements Comparator<Song>{

                   public int comare(Song one,Song two){

         return one.getArtist().compareTo(two.getArtist());

}

}

 

然后在类中这样使用

ArtistCompare artistCompare = new ArtistCompare();

Collection.Sort(songList,artistComare);

 

 

 

Public void takeAnimals(ArrayList<? Extend  Animal>animals){

         For(Anima a : animals){

         a.eat();

}

}

其中<? Extend  Animal>指明是万用类型，只要是Animal的子类或Animal都可以，但是不可以添加元素

a.       add（）；都会失败，如果没有？extends的话那么可以add但是运行时会出错，因为可能会add（new cat） add（new dog）那么就混有不同的animal了

 

其实Public class ArrayList<E> extends AbstracList<E>…{

         Public Boolean add(E o);

 

}

Public void takeAnimals(ArrayList<? Extend  Animal>animals){

         For(Anima a : animals){

         a.eat();

}

}

一样的

 

 

一般的servlet是继承HttpServlet并覆盖doGet（）和doPost（）来创建的

Servlet要输出带有完整标识的HTML网页

 

 

 

Super（className.class）这是一种反射机制，一般就是父类有个构造函数的参数是calss《？》

那么就等于把所有的class转化成className这个类型

 

 

 

随机存取机器模型是算法分析与计算复杂性理论中重要的串行计算模型，简称 RAM。引进它是为了便于从理论上分析计算机串行程序所耗费的时间、空间等资源。

 

 

Synchronized有4中用法，一种是在同步方法

Public Synchronized void fun();

这样的话获得的锁是对象锁，就是一个对象内的线程同时只有一个线程能进入这个方法，但是其他对象的线程就可以进入

 

一个就是同步快

Synchronize(Object){

         …

}

这种方法类似同步方法，都是获得对象锁，只是在一个块中同步而已

 

Synchronized（class）{

..

}

这种方法获得的是一个类锁，这样的话就算有多个不同的对象，那么全部对象也只能只有一个对象的线程才能进入，其他对象的线程只能有阻塞

例子：单例模式

private volatile static SingletonSynchronized singleton;//voaltile的意思就是就算是在多个引用中，但是改变的都是同一个内存中的东西

    //遮掩的话一个引用在更改了这个单例的时候就会立刻同步到所有引用得到的值，而不是通过在寄存器上保存的值。这样的话就可以实时知道正确值

    //用在硬件上就会实现同步，而不调用寄存器上的，每次调用都要重新读取，以防多线程调用的情况下一个瞬间改变的寄存器上的量还没有改变防止发生错误

    //但是volatile不能保证同步，只能保证是对同一块内存操作，例如创建变量还是需要很多条语句来创建的

    private SingletonSynchronized(){}

    public static SingletonSynchronized getInstance(){

        if(singleton == null){//首先判断 存在这个类不，这个是为了效率，如果早就创建了就可以直接不进入同步快，也可以不要，不过这样的话每次都要进入同步，效率降低

            synchronized(SingletonSynchronized.class){//不存在的话只有一个对象能进入

                if(singleton == null){//当单例没有没创建的时候就创建一个；当第二个对象进来的时候就可以直接不进入if语句块

                    singleton = new SingletonSynchronized();

                }

            }

        }

        return singleton;

    }

 

 

 

Switch(ex)其中ex只能是short int char byte其实就是转换成一个整形处理 char就是转换成一个ascall枚举类型也可以

 

 

for(double x = 0.1;x != 1.0;x += 0.1){

            System.out.println( x + "; ");

        }这个是有错误的，因为可能存在浮点数不完全等于那么数，就是精确问题，好比2个浮点数的比较不能直接用==来对比一样

 

 

不可以循环继承

 

 

动态多态性只针对非静态的成员方法，如果是用于静态的成员方法，那么调用的函数还是父类的静态函数

 

 

导入包的时候最好就是只导入最小范围的包或者类，这样可以减少内存的开销，如果只是使用静态工具的话可以不需要导入整个包，可以直接调入这个包的这个静态方法

 

类的构造方法中不能具有静态属性

 

 

接口的成员域都具有public ，final，static就是不可更改的一个固定属性

所有接口成员函数都具有abstract，public属性

 

 

不具有静态属性的实名内部类不能含有静态属性的方法。不能class1.class?.statfun()逻辑错误

不具有静态属性的实名内部类成员域如果有静态变量也必须是final的

 

 

在调用System。Out。Print的时候如果他们的参数不是字符串类型数据，则在程序的执行过程中一般先自动调用成员方法toString（）（对于非null的引用类型数据）或valueOf（对于基本数据类型数据或null）

 

 

String a = “A”

String b = “B”

当进入一个函数中改变a，b那么在函数退出来的时候在调用a,b值是不改变的，因为a，b实际上是字符串池的引用，跟基本数据类型一样。

如果是a = new String（“a”）

B = new String (“B”);

那么在函数退出来的时候就会改变

 

 

 

J2SE 1.5中提供了Varargs机制是一个允许形参类型可以变的一种技术

就是(Integer… num)

只有最后一个形参才能被定义成“能和不确定个实参相匹配”的。因此，一个方法里只能有一个这样的形参。另外，如果这个方法还有其它的形参，要把它们放到前面的位置上。只有最后一个形参才能被定义成“能和不确定个实参相匹配”的。因此，一个方法里只能有一个这样的形参。另外，如果这个方法还有其它的形参，要把它们放到前面的位置上。编译器会在背地里把这最后一个形参转化为一个数组形参，并在编译出的class文件里作上一个记号，表明这是个实参个数可变的方法。

sumUp(new int[] {}); 

注意这时传递过去的是一个空数组，而不是null。这样就可以采取统一的形式来处理，而不必检测到底属于哪种情况。

sumUp( 1, 3, 5, 7);

在背地里，编译器会把这种调用过程转化为用“数组包裹实参”的形式：

造成这个现象的原因在于J2SE 1.5中的泛型机制的一个内在约束——不能拿用标识符来代表的类型来创建这一类型的实例

public class OverloadingSampleB { 
    public static void main(String[] args) { 
        testOverloading(1, 2, 3);//编译出错 
    } 
    private static void testOverloading( Object... args) { 
    } 
    private static void testOverloading( Object o, Object... args) { 
    } 
} 

public class OverloadingSampleC { 
    public static void main(String[] args) { 
        /* 编译出错 */ 
        testOverloading( 1, 2); 
        /* 还是编译出错 */ 
        testOverloading( new Integer(1), new Integer(2)); 
    } 
    private static void testOverloading( int... args) { 
    } 
    private static void testOverloading( Integer... args) { 
    } 
} 

 

 

其中大量对UI界面操作的都会影响EDT线程，因为一直操作EDT线程进行显示

然后SwingWorker线程done其实是没有占用EDT线程的，只有对ui有操作才占用

 

 

 

获取鼠标坐标

http://javapub.iteye.com/blog/739146

 

 

static{

  //代码内容

  //........

  //代码结束

}

静态代码域，在类的加载的时候调用一次，整个生命周期只会调用一次。

{

  //代码内容

  //........

  //代码结束

}

普通代码域，在类的每个对象创建的时候调用。

 

代码域中定义的变量都是局部的，只有域中的代码可以调用。

                                                                                                                                                  

 

 

 

空白final只能在构造函数或者是初始化块中初始化,函数中不行

只有覆盖很重载.

 

 

在覆盖基类的方法的时候如果基类抛出了类,那么覆盖的方法可以不抛出那个类,但是覆盖类中抛出的类,基类中的方法必须抛出

但是在构造函数中就不可以这样,基类构造函数要抛出的类型那么要不就是在子类中的构造函数中处理或者也抛出同样的类

 

 

重写就是覆盖掉基类的方法,例如equals(object obj)如果要覆盖他那么就要在子类中覆盖equals(object obj)并相同类型,如果是equals(person p)那么是不算重写的,这样就不能用set集合中的equals断定这个2个对象相等,如果是equals(object obj)那么就可以断定对象相等

equals(person p)是重载,也就是说根据传入的不同参数表现出不同的形式

 

 

如果不重写equals()方法，就不能将该对象用作哈希表中的键。

哈希检索的两个步骤：

1、使用hashCode()找到正确的位置，或者称之为桶吧，因为里面有可能有多个元素

2、使用equals()在该桶内找到正确的元素。

 

 

相同类的类里面定义可以调用相同类对象的私有成员

public boolean equals(Persion p){

        System.out.println(p.name);

        return p.name.equals(this.name);

                                                              

}

以内封装性是对类而言的不是对象

 

 

 

SL275中描述的Java程序运行的过程是这样的：类加载器（class loader）加载程序运行所需要的所有类，它通过区分本机文件系统的类和网络系统导入的类增加安全性，这可以限制任何的特洛伊木马程序，因为本机类总是先被加载，一旦所有的类被加载完，执行文件的内存划分就固定了，在这个时候特定的内存地址被分配给对应的符号引用，查找表（lookuo table）也被建立，由于内存划分发生在运行时，解释器在受限制的代码区增加保护防止未授权的访问；然后字节码校验器（byte code verifier）进行校验，主要执行下面的检查：类符合JVM规范的类文件格式，没有违反访问限制，代码没有造成堆栈的上溢或者下溢，所有操作代码的参数类型都是正确的，没有非法的数据类型转换（例如将整型数转换成对象类型）发生；校验通过的字节码被解释器（interpreter）执行，解释器在必要时通过运行时系统执行对底层硬件的合适调用。