面向对象编程进阶

• 1.static关键字：
• 2.代码块：
• 3.设计模式：
• 4.继承：

1.static关键字：

static是静态的意思，可以修饰成员变量和成员方法。static修饰成员变量，该成员变量就成为了静态成员变量，静态成员变量属于类和对象共享，在内存中只存储一份，即在内存中只加载一次，可以被共享访问、修改。常表示在线人数信息等需要被共享的信息。

注： 实例成员变量属于每个对象，且每个对象信息不同时（name,age,…等），需要使用这个实例成员变量

静态成员变量的访问：

推荐：类名.静态成员变量。（同一个类中静态成员变量的访问可以不加类名，但是在其它类中是需要加的）

不推荐：对象.静态成员变量。

静态成员变量的内存原理：


首先类class加载进入方法区，静态成员变量属于类和对象共享，所以静态成员变量onLineNumber随的类的加载进入堆内存，main方法进栈，通过类名直接访问到堆内存的静态成员，由于main方法和静态成员变量在同一个类中，因此可以直接访问静态成员变量，然后在栈内存中创建对象变量，并在堆内存中new了一个对象，通过对象变量名可以访问对象中的成员变量，当然也可以通过对象名访问静态成员变量，但是不推荐。

静态成员方法：

静态成员方法（有static修饰，属于类和对象共享），建议用类名访问（类名.静态成员方法），也可以用对象访问（对象.静态成员方法）。实例成员方法（无static修饰，属于对象），只能用对象触发访问。表示对象自己的行为的，且方法中需要访问对象成员的，则该方法必须申明成实例成员方法。如果该方法是以执行一个共用功能为目的，则可以申明成静态方法。

实例成员方法（无static修饰，属于对象）的访问格式：对象.实例成员方法。

静态成员方法的内存原理：

main方法和getMax方法有static修饰，属于类和对象共享，因此和class类一起加载进入方法区，main方法进栈，之后getMax方法进栈，并通过类名访问该静态成员方法，同一个类中访问静态成员方法，类名也可以不写，然后在栈内存中创建一个对象变量，并在堆内存中new一个对象，实例成员方法加载进方法区，之后通过对象名访问实例成员变量，成员方法，也可以通过对象访问静态成员，但是不推荐

工具类： 工具类中定义的都是一些静态方法，每个方法都是以完成一个共用的功能为目的。

工具类的好处：一是调用方便，二是提高了代码复用（一次编写，处处可用）

为什么工具类中的方法不用实例方法做？
实例方法需要创建对象调用，此时用对象只是为了调用方法，这样只会浪费内存。

工具类的定义注意：
建议将工具类的构造器进行私有，工具类无需创建对象。
里面都是静态方法，直接用类名访问即可。

static访问注意实现：

• 静态方法只能访问静态的成员，不可以直接访问实例成员。
• 实例方法可以访问静态的成员，也可以访问实例成员。
• 静态方法中是不可以出现this关键字的。

2.代码块：

代码块是类的5大成分之一（成员变量、构造器，方法，代码块，内部类），定义在类中，方法外。在Java类下，使用 { } 括起来的代码被称为代码块 。

代码块的分类：

静态代码块:
格式为static{}，需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次,比main先执行，在类加载的时候做一些静态数据初始化的操作，以便后续使用。即当系统启动的同时需要准备好数据，此时可以用静态代码块完成。

构造代码块（了解，用的少）：
格式为{}，每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行，用于初始化实例资源。

3.设计模式：

开发中经常遇到一些问题，一个问题通常有n种解法的，但其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。设计模式有20多种，对应20多种软件开发中会遇到的问题，学设计模式主要是学2点：
第一：这种模式用来解决什么问题。
第二：遇到这种问题了，该模式是怎么写的，他是如何解决这个问题的。

单例模式：
可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。
例如任务管理器对象我们只需要一个就可以解决问题了，这样可以节省内存空间。

饿汉单例设计模式：
在用类获取对象的时候，对象已经提前为你创建好了。

设计步骤：
定义一个类，把构造器私有。
定义一个静态变量存储一个对象。

/** a、定义一个单例类 */
public class SingleInstance {
 /** c.定义一个静态变量存储一个对象即可 :属于类，与类一起加载一次 */
 	public static SingleInstance instance = new SingleInstance ();
 	/** b.单例必须私有构造器*/
 	private SingleInstance (){        
 		System.out.println("创建了一个对象");
 	}
}

懒汉单例设计模式：
在真正需要该对象的时候，才去创建一个对象(延迟加载对象)。

设计步骤：
定义一个类，把构造器私有。
定义一个静态变量存储一个对象。
提供一个返回单例对象的方法

/** 定义一个单例类 */
class SingleInstance{  
  /** 定义一个静态变量存储一个对象即可 :属于类，与类一起加载一次 */   
   public static SingleInstance instance ; // null  
     /** 单例必须私有构造器*/  
   private SingleInstance(){
   }   
    /** 必须提供一个方法返回一个单例对象  */  
   public static SingleInstance getInstance(){        
   		...      
     return ...;    
    }
}

饿汉第一次拿对象速度更快，不用新创建，但是无需对象的时候，饿汉也会创建对象，浪费内存，懒汉单例拿对象比较慢，对于懒汉单例，对象变量建议私有，要不然别人看见对象变量是公开的，可能会调用，私有更加专业和安全。

4.继承：

Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起父子关系。继承格式：子类 extends父类
如：

public class Student extends People {}

Student称为子类（派生类），People称为父类(基类 或超类)。

当子类继承父类后，就具有并且可以使用父类的成员了。通常有多个类有相同的成员变量和成员方法，因此每个类都会把这些相同的成员变量和成员方法写一遍，造成了大量代码的冗余，我们可以把相同的属性和行为抽离出来成为一个父类，让子类继承父类，这样子类就都有了这些相同的成员，这可以减少代码冗余，提高代码的复用，增强类的功能扩展性

继承设计规范： 子类们相同特征（共性属性，共性方法）放在父类中定义，子类独有的的属性和行为应该定义在子类自己里面。

子类对象的内存原理：
子类空间中是子类对象自己独有的成员，父类空间中是子类对象从父类继承下来的成员

继承的特点：

• 子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。子类有自己的构造器，父类的构造器用于初始化从父类继承下来的成员变量。
• Java是单继承模式：一个类只能继承一个直接父类。Java不支持多继承、但是支持多层继承。
• Java中所有的类都是Object类的子类。Java中所有类，要么直接继承了Object , 要么默认继承了Object , 要么间接继承了Object, Object是祖宗类。
• 子类可以继承父类的私有成员，但是不能直接访问。

子类是否可以继承父类的静态成员？
有争议的知识点。子类可以直接使用父类的静态成员，但个人认为：子类不能继承父类的静态成员。

在子类方法中访问成员（成员变量、成员方法）满足：就近原则：
先子类局部范围找，然后子类成员范围找，然后父类成员范围找，如果父类范围还没有找到则报错。

如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的怎么办？

可以通过super关键字，super：代表父类存储空间的标识，格式：super.父类成员变量/父类成员方法。指定访问父类的成员。
如果子类和父类中出现了重名的方法，而你想使用父类的成员方法，此时你可以定义一个中转方法再结合super关键字。

public class ExtendsDemo2 {
    public static void main(String[] args) {
        Student s = new Student();
        s.run(); // 子类的
        System.out.println("-----------");
        s.go();
    }
}

class People{
    public void run(){
        System.out.println("可以跑~~");
    }
}

class Student extends People{
    public void run(){
        System.out.println("学生跑的贼快~~");
    }

//中转方法
    public void go(){
        super.run(); // 父类的
    }
}

方法重写：

什么是方法重写？
在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。

方法重写的应用场景：
当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。子类可以重写父类中的方法以覆盖父类的方法。

Override重写注解：
@Override是放在重写后的方法上，作为重写是否正确的校验注解。加上该注解后如果重写错误，编译阶段会出现错误提示。建议重写方法都加@Override注解，代码安全，优雅！

方法重写注意事项和要求：

• 重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。
• 私有方法不能被重写，否则会报错，去掉override就不会报错了，这实际上是子类自己独有的成员方法了。
• 子类重写父类方法时，访问权限必须大于或者等于父类 （暂时了解 ：缺省 < protected < public）
• 子类不能重写父类的静态方法，如果重写会报错的。去掉override就不会报错了，这实际上是子类自己独有的成员方法了。

子类继承父类后构造器的作用和特点：
父类构造器用于创建子类对象时初始化继承自父类的成员变量。子类中所有的构造器默认都会先访问父类中的构造器。

为什么？

从代码层面来看：子类构造器的第一行语句默认都是super()，不写也存在。所以再调用子类构造器后，就会先访问父类中的无参构造器。如果需要调用父类的有参构造器，那么子类构造器的第一句就是super(参数)，所以永远是先调用父类的构造器。

从设计层面来看：创建子类对象的时候，有可能会调用有参构造器初始化从父类继承的成员变量，所以要在子类构造器中先调用父类的有参构造器来初始化父类空间中的成员变量。

如果父类中没有无参数构造器，只有有参构造器，会报错，因为子类默认是调用父类无参构造器的。此时子类构造器中可以通过书写 super(…)，手动调用父类的有参数构造器。

this和super关键字的总结：

this访问本类其它构造器的用法：

public class Student {
	private String schoolName;
	private String name;
   
  public Student(String name){
  	this(name , “黑马培训中心”);	
  }	
     
  public Student(String name , String schoolName ){
  	this.name = name;
  	this.schoolName = schoolName;
    }	
}

this(…)和super(…)使用注意点：

• 子类通过 this (…）去调用本类的其他构造器，本类其他构造器会通过super去手动调用父类的构造器，最终还是会调用父类构造器的。
• this(…) super(…) 都只能放在构造器的第一行，所以二者不能共存在同一个构造器中。否则会造成调用两次父类构造器的情况。