韩顺平Java学习 面向对象【高级】（笔记）

目录

类变量（静态变量）

类方法（静态方法）

Main方法public static void main(String[] arg){}

代码块

         单例设计模式

        final关键字

        抽象类

抽象模板模式

        接口

        内部类

2-1：局部内部类

2-2：匿名内部类

2-3成员内部类

2-4静态内部类

---

类变量（静态变量）

①静态变量，可以被同一个类的多个对象实例共享；

可以通过类名直接访问。【也要满足访问权限】

②Static变量在类加载的时候生成的；

不需要实例化就可以通过 类名.类变量 来访问

Static变量保存的在class实例的尾部，class对象在堆中；

类方法（静态方法）

当我们不希望创建实例，也可以调用某个方法【当作工具】，我们就可以做成静态方法。

1. 类方法中，不允许使用和对象有关的关键字，（this、super）----普通方法可以。
2. 静态方法只能访问静态的成员； 【遵守访问权限】
3. 非静态的方法可以访问静态和非静态的成员； 【遵守访问权限】

Main方法public static void main(String[] arg){}

1. Main方法是由Java的虚拟机调用的；
2. Java虚拟机需要调用main方法，所以main必须是public
3. Java虚拟机在执行main方法时，不必创建对象，所以用static；
4. 该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数，【案例】
5. Java执行的程序 参数1 参数2 参数3、、、【例】

6. 

——静态方法main如果要访问非静态的成员，先创建对象，在调用！

代码块

基本介绍：

1、代码块（又称：初始化块），属于类中的成员（类的一部分），类似于方法，将逻辑语句封装在方法体中，通过 { } 包围起来。

2、和方法不同，没有方法名，没有返回，没有参数，只有方法体。

不用通过对象或类显式调用， 是加载类时或创建对象时隐式调用；

3、修饰符可以写static，静态代码块； ——或普通代码块；

[修饰符] {

代码

}

理解：

相当于另外一种形式的构造器，（对构造器的补充机制），可以做初始化操作；

Eg：

如果多个构造器中，出现重复的语句，可以抽取出来，放到初始化代码块中，提高代码的重用性；

代码块调用顺序优先于构造器； 

细节：

1. Static代码块，作用是对类进行初始化，而且随着类的加载而执行。并且只会执行一次，如果是普通的代码块，每创建一个对象，就执行。
2. 类什么时候被加载：

创建对象示例时；

创建子类对象，父类也被加载；

使用类的静态成员时（静态属性，静态方法）；

1. 普通的代码块，在创建对象实例时，会被隐式的调用。

创建一次就调用一次。

如果，只是使用类的静态成员时，普通代码块并不会执行；

1. 创建一个对象时，在一个类中的调用顺序：

·调用静态代码块和静态属性初始化，两种都按顺序调用。

·再调用普通代码块和普通属性初始化，顺序调用；

·最后，调用构造方法

1. 构造器 的最前面其实隐含了super（）和调用普通代码块。

1. 先静态，先父类。

静态代码块只能调用静态成员；普通代码块可以调用任意成员；

Exercise：

• 单例设计模式

共有23种设计模式；

1. 设计模式：静态方法和属性的经典使用；
2. 设计模式是在大量的实践中总结和理论之后优选的代码结构、编程风格、以及解决问题的思考方式

单例模式（饿汉式、懒汉式）

1. 饿汉式：不管用不用，它都先把对象创建好了；可能造成资源浪费

第一步：将构造器私有化，保证只能有一个实例化对象  

第二步：在类内部创建一个对象

第三步：提供一个static方法，这样返回一个girlfriend对象，  

    // 可以不需要去实例化，在main中只需要调用方法，就能返回 对象；

1. public class SingleTom {  
2.     public static void main(String[] args) {  
3.         girlfriend instance = girlfriend.getInstance();  
4.         System.out.println(instance);  
5.     }  
6. }  
7. class girlfriend{  
8.     private String name;  
9.     //第二步：在类内部创建一个对象：  
10.     private static girlfriend qq=new girlfriend("qq");  
11. //这里的static为了能在静态方法中返回；  
12.   
13. //第一步：将构造器私有化——》保证只能有一个实例化对象  
14.     private girlfriend(String name) {  
15.         this.name = name;  
16.     }  
17.   
18.     @Override  
19.     public String toString() {  
20.         return "girlfriend{" +  
21.                 "name='" + name + '\'' +  
22.                 '}';  
23.     }  
24.   
25.     //第三步：提供一个static方法，这样返回一个girlfriend对象，  
26.     // 可以不需要去实例化，在main中只需要调用方法，就能返回qq；  
27.     public static girlfriend getInstance(){  
28.         return qq;  
29.     }  
30. }  

1. 懒汉式：只有当用户使用getinstance()时，才返回对象；再次调用返回上一次创建的对象； 从而保证单例；

可能存在线程安全问题；

1. //懒汉式的单例模式；  
2. public class SingleTom2 {  
3.         public static void main(String[] args) {  
4.             Cat instance = Cat.getInstance();  
5.             System.out.println(instance);  
6.         }  
7.     }  
8.     class Cat{  
9.         private String name;  
10.         //第二步：在类内部创建一个对象：  
11.         private static Cat cat;  
12. //这里的static为了能在静态方法中返回；  
13.   
14.         //第一步：将构造器私有化——》保证只能有一个实例化对象  
15.         private Cat(String name) {  
16.             this.name = name;  
17.         }  
18.   
19.   
20.         @Override  
21.         public String toString() {  
22.             return "Cat{" +  
23.                     "name='" + name + '\'' +  
24.                     '}';  
25.         }  
26.   
27.         //第三步：提供一个static方法，这样返回一个Cat对象，  
28.         // 可以不需要去实例化，在main中只需要调用方法，就能返回qq；  
29.         public static  Cat getInstance(){  
30.             if (cat == null) {  
31.                 cat=new Cat("xx");  
32.             }  
33.             return cat;  
34.         }  
35.     }  

3、小结

• final关键字

1. 不希望某个类被继承，可以用final修饰类；——>final class A{}
2. 不希望父类的某个方法被重写，可以用final修饰方法。
3. 不希望类的某个属性被修改，可以用final修饰属性。
4. 不希望某个局部变量被修改，也可也用final修饰变量；

• 抽象类

当父类的一些方法不能确定时，可以用abstract关键字来修饰该方法，这个方法就是抽象方法，用abstract来修饰该类就是抽象类；

一般来说，抽象类会被子类继承，由子类来实现抽象方法；

细节：

注释：static修饰的方法必须有方法体，抽象方法没有。

抽象模板模式

D:\IDEAproject\basis2\src\com\cc\Abstract\exercise2

• 接口

1、接口，就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。写法：

 

2、难的是，如何去使用；

[D:\IDEAproject\basis2\src\com\cc\Interface]

3、实现接口和继承类的区别，联系；

当子类继承父类，就自动继承了父类的功能；

如果子类需要扩展功能，可以通过实现接口的方式来扩展；

可以理解为【接口，是对java的单继承机制的一种补充】

D:\IDEAproject\basis2\src\com\cc\extends_interface\extends_interface.java

4、

1. public class InterfacePolyParameter {  
2.     public static void main(String[] args) {  
3.         //接口的多态体现  
4.         USBinterface phone = new phone();  
5.         phone=new car();  
6.     }  
7. }  
8. interface USBinterface{}  
9. class phone implements USBinterface{}  
10. class car implements USBinterface{}  

数组：

1. public class InterfacePolyArr {  
2.     public static void main(String[] args) {  
3.         //接口类型的 多态数组  
4.         USB[] usb = new USB[2];  
5.         usb[0] =new Iphone();  
6.         usb[1]=new Icar();  
7.         for (int i = 0; i < usb.length; i++) {  
8.             usb[i].work();//动态绑定。  
9.             //向下转型；  
10.             if (usb[i] instanceof Iphone) {//判断运行类型；  
11.                 ((Iphone) usb[i]).call();  
12.             }  
13.         }  
14.     }  
15. }  
16. interface USB{  
17.     void work();  
18. }  
19. class Iphone implements USB{  
20.     void call(){  
21.         System.out.println("myphone lllllllll");  
22.     }  
23.   
24.     @Override  
25.     public void work() {  
26.         System.out.println("phone working ---");  
27.     }  
28. }  
29. class Icar implements USB{  
30.     @Override  
31.     public void work() {  
32.         System.out.println("car working ---");  
33.     }  
34. }  

多态传递：

---

1. public class InterfacePolyPass {  
2.     public static void main(String[] args) {  
3.         ia a = new C(); //如果 ib 没有extends ia无法创建
4.         ib b=new C();  
5.     }  
6. }  
7. interface ia{}  
8. interface ib extends ia{}  
9. class C implements ib{} 

Tip：

普通的类实现一个接口时，可以用alt+shift+enter或alt+enter快速创建抽象类的所有方法；

• 内部类

1. 介绍：

一个类的内部有完整的嵌套了另一个类结构。被嵌套的叫内部类（inner class）

嵌套其他类的类叫外部类（outer class）。

内部类的最大特点：能直接访问私有属性，并且可以体现类与类之间的包含关系；

类的五大成员：【属性，方法，构造器，代码块，内部类】

1. 内部类的分类

2-1：局部内部类

在外部类的局部位置；

1. 可以直接访问外部类的所有成员
2. 不能添加访问修饰符，但可以final修饰；
3. 作用域在方法体或代码块中
4. 本质仍然是一个类；

2-2：匿名内部类

同样在外部类的局部位置，但是没有类名

 Dog是普通方法；

Tiger是用匿名内部类的方法；

1. /** AnonymousInnerClass（匿名 内部 类） 
2.  * 演示 
3.  */  
4. public class AnonymousInnerClass {  
5.     public static void main(String[] args) {  
6.         Outer04 outer04 = new Outer04();  
7.         outer04.method();  
8.     }  
9. }  
10. class Outer04 {  
11.     private int n1 = 1;  
12.     public void method() {  
13.         dog dog1 = new dog();  
14.         dog1.cry();  
15.         //匿名内部类tiger1  
16.         A tiger1 = new A() {  
17.             @Override  
18.             public void cry() {  
19.                 System.out.println("hu ku  ");  
20.             }  
21.         };  
22.         tiger1.cry();  
23.     }  
24. }  
25.     interface A {  
26.         public void cry();  
27.     }  
28.     class dog implements A {  
29.         @Override  
30.         public void cry() {  
31.             System.out.println("gou ku  ");  
32.         }  
33.     }  

匿名内部类使用细节

可以把匿名内部类当做实参，来进行传递：

练习：

1. public class AnonymousInnerClassExercise_2 {  
2.     public static void main(String[] args) {  
3.         Cellphone cellphone = new Cellphone();  
4. //匿名内部类当做实参
5.         cellphone.alarmclock(new Bell() {  
6.             @Override  
7.             public void ring() {  
8.                 System.out.println("pig getup");  
9.             }  
10.         });  
11.         cellphone.alarmclock(new Bell() {  
12.             @Override  
13.             public void ring() {  
14.                 System.out.println("gays study");  
15.             }  
16.         });  
17.     }  
18. }  
19. //铃声接口  
20. interface Bell{  
21.     void ring();  
22. }  
23. class Cellphone{  
24.     void alarmclock(Bell bell){  
25.         bell.ring();  
26.     }  
27. }  

2-3成员内部类

说明：成员内部类是定义在外部类的成员位置，并且没有static修饰。

1. 可以直接访问外部类的所有成员；
2. 可以添加任意访问修饰符，因为它也相当于一个成员；

访问方法：

1. public class MemberInnerClass_ {  
2.     public static void main(String[] args) {  
3.         Outer outer = new Outer();  
4.         //第一种方式：  
5.         //用外部类的对象，outer来new一个内部类Inner；  
6.        Outer.Inner inner = outer.new Inner();  
7.         //第二种，外部类中返回一个inner  
8.         Outer.Inner inner = outer.getInner();  
9.     }  
10. }  
11. class Outer{  
12.     class Inner{    }  
13.     //第二种，外部类中返回一个inner  
14.     public Inner getInner(){  
15.         return new Inner();  
16.     }  
17. }  

2-4静态内部类

 访问方法跟成员内部类相似；