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

类变量（静态变量）

类方法（静态方法）

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

代码块

单例设计模式

final关键字

抽象类

抽象模板模式

接口

内部类

2-1：局部内部类

2-2：匿名内部类

2-3成员内部类

2-4静态内部类

类变量（静态变量）

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

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

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

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

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

类方法（静态方法）

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

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

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

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

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

代码块

基本介绍：

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

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

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

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

[修饰符] {

代码

}

理解：

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

Eg：

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

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

细节：

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

创建对象示例时；

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

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

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

创建一次就调用一次。

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

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

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

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

·最后，调用构造方法

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

先静态，先父类。

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

Exercise：

单例设计模式

共有23种设计模式；

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

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

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

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

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

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

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

public class SingleTom {
public static void main(String[] args) {
girlfriend instance = girlfriend.getInstance();
System.out.println(instance);
}
}
class girlfriend{
private String name;
//第二步：在类内部创建一个对象：
private static girlfriend qq=new girlfriend("qq");
//这里的static为了能在静态方法中返回；
//第一步：将构造器私有化——》保证只能有一个实例化对象
private girlfriend(String name) {
this.name = name;
}
@Override
public String toString() {
return "girlfriend{" +
"name='" + name + '\'' +
'}';
}
//第三步：提供一个static方法，这样返回一个girlfriend对象，
// 可以不需要去实例化，在main中只需要调用方法，就能返回qq；
public static girlfriend getInstance(){
return qq;
}
}

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

可能存在线程安全问题；

//懒汉式的单例模式；
public class SingleTom2 {
public static void main(String[] args) {
Cat instance = Cat.getInstance();
System.out.println(instance);
}
}
class Cat{
private String name;
//第二步：在类内部创建一个对象：
private static Cat cat;
//这里的static为了能在静态方法中返回；
//第一步：将构造器私有化——》保证只能有一个实例化对象
private Cat(String name) {
this.name = name;
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
'}';
}
//第三步：提供一个static方法，这样返回一个Cat对象，
// 可以不需要去实例化，在main中只需要调用方法，就能返回qq；
public static Cat getInstance(){
if (cat == null) {
cat=new Cat("xx");
}
return cat;
}
}

3、小结

final关键字

不希望某个类被继承，可以用final修饰类；——>final class A{}
不希望父类的某个方法被重写，可以用final修饰方法。
不希望类的某个属性被修改，可以用final修饰属性。
不希望某个局部变量被修改，也可也用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、

public class InterfacePolyParameter {
public static void main(String[] args) {
//接口的多态体现
USBinterface phone = new phone();
phone=new car();
}
}
interface USBinterface{}
class phone implements USBinterface{}
class car implements USBinterface{}

数组：

public class InterfacePolyArr {
public static void main(String[] args) {
//接口类型的多态数组
USB[] usb = new USB[2];
usb[0] =new Iphone();
usb[1]=new Icar();
for (int i = 0; i < usb.length; i++) {
usb[i].work();//动态绑定。
//向下转型；
if (usb[i] instanceof Iphone) {//判断运行类型；
((Iphone) usb[i]).call();
}
}
}
}
interface USB{
void work();
}
class Iphone implements USB{
void call(){
System.out.println("myphone lllllllll");
}
@Override
public void work() {
System.out.println("phone working ---");
}
}
class Icar implements USB{
@Override
public void work() {
System.out.println("car working ---");
}
}

多态传递：

public class InterfacePolyPass {
public static void main(String[] args) {
ia a = new C(); //如果 ib 没有extends ia无法创建
ib b=new C();
}
}
interface ia{}
interface ib extends ia{}
class C implements ib{}

Tip：

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

内部类

介绍：

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

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

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

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

内部类的分类

2-1：局部内部类

在外部类的局部位置；

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

2-2：匿名内部类

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

Dog是普通方法；

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

/** AnonymousInnerClass（匿名内部类）
* 演示
*/
public class AnonymousInnerClass {
public static void main(String[] args) {
Outer04 outer04 = new Outer04();
outer04.method();
}
}
class Outer04 {
private int n1 = 1;
public void method() {
dog dog1 = new dog();
dog1.cry();
//匿名内部类tiger1
A tiger1 = new A() {
@Override
public void cry() {
System.out.println("hu ku ");
}
};
tiger1.cry();
}
}
interface A {
public void cry();
}
class dog implements A {
@Override
public void cry() {
System.out.println("gou ku ");
}
}

匿名内部类使用细节

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

练习：

public class AnonymousInnerClassExercise_2 {
public static void main(String[] args) {
Cellphone cellphone = new Cellphone();
//匿名内部类当做实参
cellphone.alarmclock(new Bell() {
@Override
public void ring() {
System.out.println("pig getup");
}
});
cellphone.alarmclock(new Bell() {
@Override
public void ring() {
System.out.println("gays study");
}
});
}
}
//铃声接口
interface Bell{
void ring();
}
class Cellphone{
void alarmclock(Bell bell){
bell.ring();
}
}

2-3成员内部类

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

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

访问方法：

public class MemberInnerClass_ {
public static void main(String[] args) {
Outer outer = new Outer();
//第一种方式：
//用外部类的对象，outer来new一个内部类Inner；
Outer.Inner inner = outer.new Inner();
//第二种，外部类中返回一个inner
Outer.Inner inner = outer.getInner();
}
}
class Outer{
class Inner{ }
//第二种，外部类中返回一个inner
public Inner getInner(){
return new Inner();
}
}

2-4静态内部类

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