前面的知识点太细太碎，容易遗漏，开贴记忆，方便自己，方便大家。
1、成员变量与局部变量
成员变量存在于堆中，作用于整个类中，随着对象的建立而存在，随着对象的消亡而消亡
局部变量存在于栈中，作用于方法内部或语句中。

2、静态代码块、构造代码块、构造函数
这三者都能进行初始化，运行优先级由高到低是：静态代码块，构造代码块，构造函数。
静态代码块，随着类的加载而运行，只运行一次。
构造代码块，随着对象的建立而运行，优先于构造方法。每次new对象都会运行一次。
构造函数，随着对象的建立而运行。   ——————————————
静态代码块，给类进行初始化。
构造代码块，给对象进行初始化。
构造方法，给对应对象进行初始化

3、this代表所在方法所属对象的引用，对象内的成员相互调用时，成员的前面都有一个隐藏的this关键字。

4、类名与构造方法名要一致。
如果类名前面有权限修饰符public，那么构造方法名前面也要有public。
5、当调用方法时，虚拟机会在栈中分配一块名为栈帧的内存空间，以供局部变量(包括基本类型与引用类型)使用。当方法调用结束后，虚拟机就会收回此内存。
6、匿名内部类其实就是一个匿名子类对象，不要被它的名字所迷惑，认为它是个类。
7、throw和throws的区别
① throw出现的方法内，throws出现在方法上
② throw后面跟的是异常对象，throws后面跟的是异常类，可以有多个，用逗号隔开。
8、RuntimeException如果在方法内抛出该异常，方法上可以不用声明，编译一样通过。
如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。

9、异常的分类
① 编译时被检测的异常
② 编译时不被检测的异常（运行时异常，runtimeexception以及其子类）
10、异常在子父类覆盖中的体现：① 子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类，或不抛异常。
② 如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集
③ 如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常，必须用try来处理。

关于this关键字

1. class Person{
   
2.         int age;
   
3.         Person(int age){
   
4.                 age=age;  //如果用关键词this，那么输入结果就会为5。
   
5.                           //
   
6.         }
   
7.         void speak(){
   
8.                 System.out.println("age="+age);
   
9.         }
   
10. }
    
11. public class Sunday{
    
12.         public static void main(String[] args){
    
13.                 Person p=new Person(5);
    
14.                 System.out.println(p.age);
    
15.         }
    
16. }
    
17. 
    
18. 输出结果：0

复制代码

以前倒是没注意到这点，现在写上，以防忘了。

1. 
   
2. /*
   
3. *this语句，用于构造器之间的相互调用。
   
4. *小心类似死循环一样的调用。
   
5. *一般函数不能调用构造函数
   
6. */
   
7. 
   
8. class Person{
   
9.         private String name;
   
10.         private int age;
    
11.         Person(String name){
    
12.                 this.name=name;  
    
13.         }
    
14.         Person(String name,int age){
    
15.                 this(name);  //如果写成Person(name)，就会报错，说找不到Person(String)方法
    
16.                              //this语句只能放在第一行，不能放在其他位置，否则会报错，提示只能放在构造器语句的第一行。
    
17.                              //放在其它行不安全。
    
18.                 this.age=age;       
    
19.         }
    
20.         public String toString(){
    
21.                 return name+":"+age;
    
22.         }
    
23.        
    
24. }
    
25. public class Sunday{
    
26.         public static void main(String[] args){
    
27.                 Person p=new Person("aaaa",10);
    
28.                 System.out.println(p);
    
29.         }
    
30. }

复制代码

wisely 发表于 2014-7-20 00:14

main函数被玩儿坏了，毕老师太会玩儿了。

1. class Sunday{
   
2.         public static void main(String[] args){
   
3.                 for(int i=0;i<args.length;i++){
   
4.                         System.out.println(args[i]);
   
5.                 }
   
6.         }
   
7. }
   
8. 
   
9. class Demo{
   
10.         public static void main(String[] args){
    
11.                 String arr[]={"haha","huohuo","gaga","heihei","xixi"};
    
12.                 Sunday.main(arr);
    
13.         }
    
14. }

复制代码

构造代码块先于构造函数的说法不准确。先进构造函数执行父类构造方法，然后是默认初始化、构造代码块和指定初始化，最后是构造函数的其他语句。由于父类构造方法先于构造代码块，我有个感觉，其实构造代码块和指定初始化是被放入构造函数内部执行的。

wisely 发表于 2014-7-20 01:19
main函数被玩儿坏了，毕老师太会玩儿了。

重载(overload)方法时，参数顺序不一样，仍旧不是一样的方法。

1. 
   
2. class Demo{
   
3.         public void show(int a,String str){
   
4.                 System.out.println(a+":"+str);
   
5.         }
   
6.         public void show(String str,int a){
   
7.                 System.out.println(str+":"+a);
   
8.         }
   
9. }
   
10. 
    
11. public class Sunday{
    
12.         public static void main(String[] args){
    
13.                 Demo demo=new Demo();
    
14.                 demo.show(10,"abc");
    
15.                 demo.show("abc",10);
    
16.         }
    
17. }

复制代码

output：
10：abc
abc：10

class Person{
        private String name;
        {
                System.out.println("我是构造代码块");
        }
        Person(){
                System.out.println("我是无参数构造函数");
        }
        Person(String name){
                System.out.println("我是有参构造函数");
        }
        static{
                System.out.println("我是静态代码块");
        }
        public static void show(){
                System.out.println("我是静态方法");
        }
}

public class Sunday{
        public static void main(String[] args) {

                Person p=null;   //这句代码并不会加载类，所以不会执行静态代码块。

                                           //用到类中的内容时，才会加载。
        }
}

wisely 发表于 2014-7-21 20:33
class Person{
        private String name;
        {

1. 
   
2. class Person{
   
3.         private String name;
   
4.         private int age;
   
5.         private static String country="cn";
   
6.         Person(String name,int age){
   
7.                 this.name=name;
   
8.                 this.age=age;
   
9.         }
   
10. }
    
11. 
    
12. public class Sunday{
    
13.         public static void main(String[] args){
    
14.                 Person p=new Person("wamgda",20);
    
15.         }
    
16. }

复制代码

Person p=new Person("wangda",20)

该句代码的运行过程。
1、在栈内存中创建关于Person的引用p
2、因为new用到了Person.class虚拟机加载Person.class进内存
3、执行该类中的静态代码块，如果有的话，给Person类进行初始化
4、在堆内存中开辟空间，分配内存地址
5、在堆内存中建立对象的特有属性，并进行默认初始化。
6、对对象进行显式初始化
7、对对象进行构造代码块初始化
8、对对象进行对应构造方法的初始化
9、将内存地址赋给栈内存中的p。

多态的主板示例

1. 
   
2. 
   
3. 
   
4. 
   
5. interface PCI{
   
6.         public abstract void open();
   
7.         public abstract void close();
   
8. }
   
9. 
   
10. class MainBoard{
    
11.         public void run(){
    
12.                 System.out.println("mainboard run");
    
13.         }
    
14.         public void usePCI(PCI p){
    
15.                 if(p!=null){
    
16.                         p.open();
    
17.                         p.close();
    
18.                 }
    
19.         }
    
20. }
    
21. 
    
22. class NetCard implements PCI{
    
23.         public void open(){
    
24.                 System.out.println("netcard open");
    
25.         }
    
26.         public void close(){
    
27.                 System.out.println("netcard close");
    
28.         }
    
29. }
    
30. 
    
31. class SoundCard implements PCI{
    
32.         public void open(){
    
33.                 System.out.println("soundcard open");
    
34.         }
    
35.         public void close(){
    
36.                 System.out.println("soundcard close");
    
37.         }
    
38. }
    
39. 
    
40. public class Sunday{
    
41.         public static void main(String[] args){
    
42.                 MainBoard mb=new MainBoard();
    
43.                 mb.run();
    
44.                 mb.usePCI(null);
    
45.                 mb.usePCI(new NetCard());
    
46.                 mb.usePCI(new SoundCard());
    
47.         }       
    
48. }
    

复制代码

程序本身不难，不过提到了接口的用法，特别不错。详见毕老师视频08-06

看看         

内部类定义在成员位置

1. 
   
2. 
   
3. class Outer{
   
4.         private int x=1;//想要让内部类访问到这个，需要将function中的x改成Outer.this.x
   
5.                         //如果内部类没有与x重名的变量，那么省略Outer.this也行，前面会默认添加。
   
6.         class Inner{
   
7.                 int x=2;  //想要访问到Inner的成员变量x，function中的打印语句中的x需要改成this.x
   
8.                 public void function(){
   
9.                         int x=3;  
   
10.                         System.out.println("Inner:"+this.x);
    
11.                 }
    
12.         }
    
13.         void method(){
    
14.                 Inner in=new Inner();
    
15.                 in.function();
    
16.         }
    
17. }
    
18. 
    
19. public class Sunday{
    
20.         public static void main(String[] args){
    
21.                 Outer out=new Outer();
    
22.                 out.method();
    
23. 
    
24.                 /*
    
25.                 //直接访问内部类中的成员
    
26.                 Outer.Inner in=new Outer().new Inner();   //内部类直接创建对象的方式
    
27.                 in.function();
    
28.                 */
    
29.         }
    
30. }

复制代码

内部类的访问规则：
1、内部类可以直接访问外部类中的成员，包括私有的成员。
        之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
2、外部类要访问内部类，必须建立内部类对象。

当内部类写在成员位置上时，可以加private修饰符。而外部类不可以。

一、当内部类被静态static修饰后，只能直接访问外部类中的static成员，出现了访问局限
    1、在外部其他类中，如何直接访问static内部类的非静态呢？
         new Outer.Inner().function()
    2、在外部其他类中，如何直接访问static内部类的静态呢？
         Outer.Inner.function()

二、当内部类中定义了静态static成员，该内部类必须是静态static的
三、当外部类中的静态方法访问内部类时，内部类也必须是静态的。

wisely 发表于 2014-7-23 01:00
内部类

内部类定义在局部

1. /*
   
2. 内部类定义在局部时，
   
3. 1、不可以被成员修饰符修饰
   
4. 2、可以直接访问外部类中的成员，因为还持有外部类中的引用。
   
5.         但不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
   
6.                 即便是方法method中的参数传递也必须是final，如method(final int a)
   
7. */
   
8. class Outer{
   
9.         int x=1;
   
10.         void method(final int a){  //此处的变量也必须是final
    
11.                 //a++;        //加上这句就会挂掉，原因尚且不明
    
12.                 final int y=2;//内部类想要访问y，必须定义成final
    
13.                 class Inner{
    
14.                         void function(){
    
15.                                 System.out.println(Outer.this.x+":"+y+":"+a);
    
16.                         }
    
17.                 }
    
18.                 new Inner().function();//想要运行function()，必须要new对象。
    
19.         }
    
20. }
    
21. 
    
22. public class Sunday{
    
23.         public static void main(String[] args){
    
24.                 Outer out=new Outer();
    
25.                 out.method(7);
    
26.                 out.method(9);//虽然a为final，但它为局部变量，调用方法时进栈，而后出栈，不影响后面的调用
    
27.                               //除非a是Outer类的成员变量。
    
28.         }
    
29. }

复制代码

wisely 发表于 2014-7-23 02:06
内部类定义在局部

1. "lisi".equals(name)与name.equals("lisi")的区别：
   
2. 如果name=null，那么第一个可以运行，而第二个会抛出空指针异常

复制代码