基础学习笔记 + 代码实例 （2）

一、 面向对象基础部分 
1、this、super关键字 

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description 测试基类 
5.  * @history 
6.  */  
7. public class BaseTest {  
8.     protected String pwd; // 定义protected属性pwd  
9.     public BaseTest(){  
10.         // 无参数构造方法  
11.     }  
12.     public String sayHelloWorld(){  
13.         return "hello world";  
14.     }  
15. }  

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description this,super关键字测试类 
5.  * @history 
6.  */  
7. public class MyTestDemo extends BaseTest{  
8.     // notes:测试使用而已，代码功能模拟而已  
9.     private String username; // 定义用户昵称私有属性private修饰  
10.     private String password;  
11.     public MyTestDemo(String username){ // 构造方法  
12.         this();// this()调用无参数构造方法  
13.         this.username = username; // this.属性访问当前username属性  
14.         // super.属性调用父类属性  
15.         this.password = super.pwd;  
16.     }  
17.     public MyTestDemo(){  
18.         // 无参数构造方法  
19.         super(); // 调用父类无参数构造方法  
20.     }  
21.     public void sayHello(){  
22.         this.sayWord(); // this.方法调用当前对象的sayWord方法  
23.         super.sayHelloWorld(); // super.方法调用父类sayHelloWorld方法  
24.     }  
25.     public String sayWord(){  
26.         return "hello this";  
27.     }  
28.     // this表示当前对象  
29.     public boolean equals(Object obj){  
30.         MyTestDemo other = (MyTestDemo)obj; // 传入的比较对象，强制转换操作  
31.         // 简单模拟，如果对象的username属性值相同那么就认为相同  
32.         if(this == other){  
33.             return true;  
34.         }  
35.         if(other instanceof MyTestDemo){  
36.             if(this.username.equals(other.username)){  
37.                 return true;  
38.             }  
39.         }  
40.         return false;  
41.     }  
42.     /** 
43.      *@description  
44.      *@param args 
45.      */  
46.     public static void main(String[] args) {  
47.         // this关键字绑定了当前该对象，通过this.属性、this.方法  
48.         // super关键字用在子类要调用父类的属性或者方法中，通过super.属性、super.方法  
49.         MyTestDemo obj1 = new MyTestDemo("hello-java"); // 定义并实例化对象  
50.         obj1.sayHello(); // 调用对象的sayHello方法  
51.         MyTestDemo obj2 = new MyTestDemo("hello-java");  
52.         // equals方法传入的参数类型为object，传入的obj2会自动向上转型处理  
53.         boolean result = obj1.equals(obj2);   
54.         System.out.println(result); // true  
55.     }  
56.   
57. }  

2、static、final关键字 

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description final和static关键字学习 
5.  * @history 
6.  */  
7. public class FinalAndStaticTestDemo {  
8.     /** 
9.      *@description  
10.      *@param args 
11.      */  
12.     public static void main(String[] args) {  
13.         // final关键字主要有三种场景  
14.         // 1、final定义的变量为常量，比如基本数据类型的值一旦初始化了不能改变  
15.         // 2、final定义的类为终结类，不能再被继承，比如string类型  
16.         // 3、final定义的方法为终结方法，不能被覆写，否则编译器会报错  
17.         final String str = "helloworld"; // final修饰变为常量不能改变  
18.         //str = "hellojava"; // eclipse提示:The final local variable str cannot be assigned.   
19.           
20.         // 进一步思考下面两个问题  
21.         String s1 = "hello";  
22.         String s2 = "hello1";  
23.         final String s = s1;  
24.         s1 = s2;  
25.         System.out.println(s); // hello还是hello1呢?  
26.           
27.         // 引用不可变，内容可变是这个意思吗?  
28.         StringBuffer sb = new StringBuffer();  
29.         sb.append("hello");  
30.         final String fs = sb.toString();  
31.         final StringBuffer fsb = sb;  
32.         sb.append("world");  
33.         System.out.println(fs);// hello还是helloworld呢?  
34.         System.out.println(fsb.toString()); // hello还是helloworld呢?  
35.           
36.         // static关键字比较类似也有下面三种场景  
37.         // static修饰的变量为静态变量，它不同于对象/实例变量，是关联在某个类上的  
38.         // static修饰的类为静态类  
39.         // static修饰的方法为静态方法，它也不同于对象/实例方法，是关联在某个类上的  
40.         // static int i = 100;  
41.         // static class HelloWorld{ //... }  
42.         // public static void sayHeloWorld(){ //... }  
43.     }  
44.     // 静态变量和对象变量  
45.     static int i = 100; // 定义静态变量i  
46.     int j = 100; // 定义成员变量/实例变量  
47.     public static void sayHelloWorld(){ // 定义静态方法sayhelloworld  
48.         System.out.println("hello world");  
49.     }  
50.     static class HelloWorld{ // 定义内部类  
51.         // ...  
52.     }  
53.   
54. }  

3、引用传递介绍和应用 

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description 引用传递的简单学习 
5.  * @history 
6.  */  
7. class DemoTest{  
8.     String ide = "eclipse"; // 为了方便访问暂不封装  
9. }  
10. public class MyDemoTest{  
11.     /** 
12.      *@description  
13.      *@param args 
14.      */  
15.     public static void main(String[] args){  
16.         // 对象属性值访问和变更  
17.         DemoTest dt1 = new DemoTest();  
18.         System.out.println(dt1.ide); // eclipse  
19.         dt1.ide = "netbeans"; // 改变ide属性值  
20.         System.out.println(dt1.ide); // netbeans  
21.           
22.         function(dt1); // 调用方法function  
23.         System.out.println(dt1.ide); // jcreator  
24.           
25.         // String类赋值和变更  
26.         String ide = "eclipse";  
27.         function(ide);  
28.         System.out.println(ide); // eclipse而不是netbeans  
29.     }  
30.     private static void function(String ide) {  
31.         ide = "netbeans"; // 赋值为netbeans  
32.     }  
33.     // 测试方法function  
34.     private static void function(DemoTest dt2) {  
35.         dt2.ide = "jcreator"; // 改变ide属性值  
36.     }  
37. }  

4、静态块、代码块、同步块 

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description 静态块、代码块、同步块学习测试类 
5.  * @history 
6.  */  
7. class BlockDemo {  
8.     static {  
9.         // 在类中定义的static{ //...}为静态代码块  
10.         // 静态代码块的程序只会被初始化一次  
11.         System.out.println("BlockDemo->static");  
12.     }  
13.     {  
14.         // 在类中定义的{ //...}为构造代码块  
15.         // 构造代码块和对象一起初始化的  
16.         System.out.println("BlockDemo->{}");  
17.     }  
18.     public BlockDemo() {  
19.         System.out.println("BlockDemo->BlockDemo");  
20.     }  
21.     // 构造方法、构造代码块和静态代码块初始化顺序呢?  
22.     // 静态块、构造块、构造方法 // 表面初步分析，具体有待研究  
23. }  
24. public class MyDemo {  
25.     /** 
26.      * @description 
27.      * @param args 
28.      */  
29.     public static void main(String[] args) {  
30.         // 静态块、代码块、同步块  
31.         {  
32.             // 在方法中用{ //... }定义的为普通代码块  
33.             int x = 100;  
34.             System.out.println(x); // 100 相当于局部变量  
35.         }  
36.         int x = 200;  
37.         System.out.println(x); // 200  
38.   
39.         new BlockDemo();  
40.         new BlockDemo();  
41.         // BlockDemo->static static代码块只会被初始化一次  
42.         // BlockDemo->{}  
43.         // BlockDemo->BlockDemo  
44.         // BlockDemo->{}  
45.         // BlockDemo->BlockDemo  
46.     }  
47. }  

5、构造方法、匿名对象、单例定义以及实现 

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description 构造方法、匿名对象学习测试类 
5.  * @history 
6.  */  
7. public class MyDemoTest {  
8.     private String username; // 定义私有属性username  
9.       
10.     // 构造方法的作用是初始化操作  
11.     // 构造方法是一种特殊的方法，构造方法也有重载  
12.     public MyDemoTest(){  
13.         // 无参数构造方法  
14.     }  
15.     public MyDemoTest(String username) { // 定义构造方法  
16.         this.username = username; // 对属性初始化赋值操作  
17.     }  
18.     /** 
19.      *@description  
20.      *@param args 
21.      */  
22.     public static void main(String[] args) {  
23.         // 实例化一个匿名对象  
24.         // 匿名对象不在栈中开辟空间赋地址值  
25.         new MyDemoTest("eclipse");   
26.     }  
27. }  

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description 单例学习测试类 
5.  * @history 
6.  */  
7. class Singleton {  
8.     private Singleton() {  
9.         // 将构造方法私有化，外部不能直接调用  
10.         System.out.println("private Singleton(){//...}");  
11.     }  
12.     // 饿汉式获取单例代码  
13.     private static Singleton instance = new Singleton();  
14.     // 对外提供一个getInstance方法获取单例  
15.     public static Singleton getIntance() {  
16.         return instance;  
17.     }  
18. }  
19. class Singleton2{  
20.     private Singleton2(){  
21.         // 构造方法私有化，外部不能直接调用  
22.         System.out.println("private Singleton2(){//...}");  
23.     }  
24.     // 懒汉式获取单例代码  
25.     private static Singleton2 instance = null;  
26.     private static Object lock = new Object();  
27.       
28.     // 获取单例方法，效率比较低  
29.     // 每次进入都要进行锁判断，而实际情况我们是第一次null比较特殊  
30.     /*public static Singleton2 getIntance(){ 
31.         synchronized (lock) { 
32.             if (instance == null) { // 如果为null进行实例化对象操作 
33.                 instance = new Singleton2(); 
34.             } 
35.         } 
36.         return instance; 
37.     }*/  
38.     // 上面同步代码的另外一种写法如下，效率比较低  
39.     // public static synchronized getInstance(){ //...}  
40.       
41.     // 对同步代码进行改写  
42.     public static Singleton2 getIntance(){  
43.         if(instance == null){  
44.             synchronized(lock){  
45.                 if(instance == null){ // 进行双重检验操作  
46.                     instance = new Singleton2();  
47.                 }  
48.             }  
49.             // 如果换为下面这种形式那么就可能不是产生一个实例对象了  
50.             /*synchronized(lock){ 
51.                 instance = new Singleton2(); 
52.             }*/  
53.         }  
54.         return instance;  
55.     }  
56. }  
57. public class SingletonTest {  
58.     /** 
59.      *@description  
60.      *@param args 
61.      */  
62.     public static void main(String[] args) {  
63.         Singleton.getIntance(); // 饿汉式获取单例  
64.         Singleton2.getIntance(); // 懒汉式获取单例  
65.     }  
66. }  

6、内部类、匿名内部类应用 

Java代码  

1. class Outer{ // 定义外部类  
2.     private String info = "helloworld" ; // 定义外部类属性  
3.     private static String info2 = "helloeclipse"; // 定义静态变量  
4.     class Inner{  // 定义内部类  
5.         public void print(){      
6.             // 内部类的好处之一：直接访问外部类属性  
7.             System.out.println(info) ; // 直接访问外部类属性  
8.         }  
9.     }  
10.     static class StaticInner{ // 通过static定义的内部类为外部类  
11.         public void print(){  
12.             System.out.println(info2);  
13.         }  
14.     }  
15.     public void fun(){  
16.         new Inner().print() ; // 通过内部类的实例化对象调用方法  
17.     }  
18. }  
19. /** 
20.  * @author Administrator 
21.  *  
22.  * @description 内部类以及匿名内部类学习测试类 
23.  * @history 
24.  */  
25. public class InnerClassDemo{  
26.     /** 
27.      *@description  
28.      *@param args 
29.      */  
30.     public static void main(String[] args){  
31.         new Outer().fun() ; // 调用外部类的fun()方法  
32.         // 另外一种实例化方式  
33.         Outer out = new Outer();  
34.         Outer.Inner in = out.new Inner();  
35.         in.print();  
36.           
37.         // 通过外部类.内部类实例化内部类对象  
38.         //StaticInner sin = new Outer.StaticInner(); //需要导入外部类所在的包  
39.         //sin.print();  
40.     }  
41. }  

二、 面向对象高级部分 
1、继承的进一步讨论 

Java代码  

1. class Base{  
2.     // 定义基类  
3.     void print(){  
4.         System.out.println("Base->print()");  
5.     }  
6.     public void print1(){  
7.         // 父类方法的访问权限，子类覆写该方法的时候不能降低权限  
8.     }  
9. }  
10. class ZiLei extends Base{  
11.     // 定义子类覆写print方法  
12.     void print(){  
13.         // 子类访问父类中的方法，前面super关键字内容  
14.         // super.print();  
15.         System.out.println("Super->print()");  
16.     }  
17.     /*void print1(){ 
18.         // Cannot reduce the visibility of the inherited method from Base 
19.     }*/  
20.     // 覆写override和重载overload区别  
21.     // 覆写是父类子类之间的关系，重载是同一个类之间的关系  
22. }  
23. /** 
24.  * @author Administrator 
25.  *  
26.  * @description 继承中的方法覆写 
27.  * @history 
28.  */  
29. public class OverrideDemo{  
30.     public static void main(String args[]){  
31.         new ZiLei().print(); // 调用的内容是覆写后的方法实现  
32.         // 另外java中只能够单继承，不同于C++，但是可以多重继承  
33.         /*class A{ 
34.             // ... 
35.         } 
36.         class B extends A{  //class C extends A,B{ // ...}编译错误 
37.             // ... 
38.         } 
39.         class C extends B{ 
40.             // ... 
41.         }*/  
42.     }  
43. }  

2、接口和抽象类进一步讨论 

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description 接口测试类 
5.  * @history 
6.  */  
7. interface Interface{  
8.     public static final String INFO = "helloeclipse";  
9.     public void print(); // 定义方法  
10.     public abstract void printInfo();  
11. }  
12. class I implements Interface{  
13.     public void print() {  
14.         // 方法实现  
15.         System.out.println(INFO); // helloeclipse  
16.     }  
17.     public void printInfo() {  
18.         // ...  
19.     }  
20. }  
21. public class InterfaceTestDemo {  
22.     /** 
23.      *@description  
24.      *@param args 
25.      */  
26.     public static void main(String[] args) {  
27.         // 接口interface  
28.         // 接口interface和抽象类abstract一样不能直接实例化必须通过子类来实现  
29.         new Interface(){  
30.             public void print() {  
31.                 // 匿名内部类，方法实现  
32.                 System.out.println(INFO); // helloeclipse  
33.             }  
34.             public void printInfo() {  
35.                 // ...  
36.             }  
37.         };  
38.         // 接口和抽象类对比，接口更像一种规范、抽象类更像一种模板  
39.         // 抽象类定义一些公共的实现，以及一些未实现的方法交给子类具体实现特定的功能-模板方法  
40.     }  
41. }  

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description 抽象类学习测试类 
5.  * @history 
6.  */  
7. abstract class Abstract{ // 定义抽象类  
8.     public final static String INFO = "helloeclipse"; // 定义全局变量/常量  
9.     abstract public void print(); // 定义抽象方法  
10.     // 抽象类不能直接实例化，抽象类的子类如果不是抽象类那么一定要实现所有的抽象方法  
11. }  
12. class AbstractZiLei extends Abstract{ // 定义抽象子类  
13.     public void print() { // 实现子类方法  
14.         System.out.println(INFO);  
15.     }   
16. }  
17. public class AbstractTestDemo {  
18.     /** 
19.      *@description  
20.      *@param args 
21.      */  
22.     public static void main(String[] args) {  
23.         // 接口和抽象类interface,abstract  
24.         // 抽象类：含有抽象方法的类叫做抽象类用abstract修饰的  
25.         new Abstract(){  
26.             public void print() {  
27.                 System.out.println(INFO); // 匿名抽象类实现  
28.             }  
29.         };  
30.         // 抽象类能不能被final修饰呢?final定义的类为终结类，抽象类是需要子类来实现的  
31.         // final abstract class Abstract{ //... } // 编译报错  
32.     }  
33. }  

3、object类和包装类进一步讨论 

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description Object类学习测试类 
5.  * @history 
6.  */  
7. public class ObjectTestDemo {  
8.     /** 
9.      *@description  
10.      *@param args 
11.      * @throws ClassNotFoundException  
12.      */  
13.     public static void main(String[] args) throws ClassNotFoundException {  
14.         // Object类学习测试代码  
15.         // 1、toString方法  
16.         // 2、equals和hashCode方法  
17.         // 3、getClass方法  
18.         ObjectTestDemo otd = new ObjectTestDemo();  
19.         System.out.println(otd);  
20.         System.out.println(otd.toString());// 现实调用toString方法  
21.         /* 
22.          * Object类中toString方法 
23.          * public String toString() { 
24.             return getClass().getName() + "@" + Integer.toHexString(hashCode()); 
25.         } 
26.         * Object类中equal方法 
27.         * public boolean equals(Object obj) { 
28.             return (this == obj); 
29.         }*/  
30.         // 定义昵称和年龄属性，如果昵称和年龄相同则equal方法返回true  
31.         ObjectTestDemo otd1 = new ObjectTestDemo();  
32.         otd1.nickname = "eclipse";  
33.         otd1.age = 20;  
34.         ObjectTestDemo otd2 = new ObjectTestDemo();  
35.         otd2.nickname = "eclipse";  
36.         otd2.age = 20;  
37.         System.out.println(otd1==otd2); // false  
38.         System.out.println(otd1.equals(otd2)); // 如果不覆写的话返回的一直是false  
39.           
40.         // hashCode方法和equals方法的关系，没有绝对的关系  
41.         // 具体参看源代码的注释说明，在实际用中尽量同时覆写这两个方法，保持一致性  
42.           
43.         // public final native Class<?> getClass();  
44.         // getClass方法是一个本地方法，调用底层代码，返回当前对象对应的一个类对象实例  
45.         // 类对象实例，理解为内存中对应的那份字节码对象，java反射内容初步学习  
46.         // 通过字节码对象构造出一个个的对象实例  
47.         Class claz = otd.getClass();  
48.         Class claz1 = ObjectTestDemo.class;  
49.         Class claz2 = Class.forName("ObjectTestDemo"); // 类的完整路径  
50.         System.out.println(otd.getClass()); // class ObjectTestDemo  
51.         // VM内存中只会产生一份字节码对象  
52.         System.out.println(claz == claz1); // true  
53.           
54.     }  
55.     // 方法模拟，添加两个属性昵称和年龄  
56.     private String nickname;  
57.     private int age;  
58.       
59.     // 注意参数类型不要写成了ObjectTestDemo  
60.     public boolean equals(Object obj) {  
61.         ObjectTestDemo otd = (ObjectTestDemo) obj; // 向上转型，强制转换  
62.         if (this == otd) {  
63.             return true;  
64.         }  
65.         if (otd instanceof ObjectTestDemo) {  
66.             if (this.nickname.equals(otd.nickname) && this.age == otd.age) {  
67.                 return true;  
68.             }  
69.         }  
70.         return false;  
71.     }  
72.     public String toString(){  
73.         return "helloworld"; //覆写toString方法，返回helloworld  
74.     }  
75. }