韩顺平循序渐进学Java零基础 第10章 面向对象编程(高级部分)

Posted 2022-01-10 Spring-_-Bear

第10章 面向对象编程(高级部分)

374. 类变量引出

375. 类变量快速入门

376. 类变量内存剖析

• JDK 8 以前类变量放在方法区的静态域中，JDK 8 以后放在堆的对应类的 class 对象尾部

##377. 类变量定义访问

• 类变量也即静态变量

##378. 类变量使用细节

379. 类方法快速入门

• 类方法也即静态方法

380. 类方法最佳实践

• 当方法中不设计到与任何对象相关的成员时，则可以将方法设计为静态方法以提高运行效率

381. 类方法注意事项

• 静态方法只能访问静态成员；非静态方法，可以访问静态和非静态成员

382. 类成员课堂练习

383. main语法说明

384. main特别说明

385. main动态传值

386. 代码块快速入门

• 代码块可以理解为只有方法体的方法，它没有方法名、返回值、参数，不能通过对象或类显式调用，只有在加载类或是创建对象时隐式调用
• 代码块的修饰符只能是 static，方法体中的语句可以是任何正确逻辑语句
• 类代码块的调用顺序优先于构造器

387. 代码块使用细节1

• 类加载时机：创建该类的对象时；创建子类的对象时父类也会加载；使用类的静态成员时
• 如果只是调用类的静态成员，普通代码块并不会执行

388. 代码块使用细节2

• 普通代码块可以看作是构造器的一种补充机制，所以在调用类的静态成员但没有创建类的对象时，构造器并未被调用，因而类的普通代码块不会被执行

389. 代码块使用细节3

• 创建类的对象时，执行顺序

1. 静态代码块与静态成员优先级一致，按定义先后顺序依次执行
2. 普通代码块与普通成员优先级一致，按定义先后顺序依次执行
3. 调用构造器

• 理解：构造器的开头隐含了 super() 和 调用普通代码块

class Temp 
   public Temp() 
       super();
           
   

390. 代码块使用细节4

• 代码执行顺序

1. 父类的静态代码块和静态属性按定义顺序依次执行
2. 子类的静态代码块和静态属性按定义顺序依次执行
3. 父类的普通代码块与普通属性按定义顺序依次执行
4. 父类的构造器
5. 子类的普通代码块与普通属性按定义顺序依次执行
6. 子类的构造器

• 静态代码块、静态方法只能调用静态成员；普通方法和普通代码块可以调用任何成员

391. 代码块课堂练习

392. 单例模式饿汉式

• 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格以及解决问题的思考方式。设计模式好比经典的棋谱，不同的棋局采用不同的棋谱，免去再次思考和摸索的过程
• 类的单例设计模式：采取一定的方法在整个软件系统中，某个类有且仅有一个对象实例，并且该类只提供一个取得该对象的方法
• 单例模式的实现：构造器私有化；在类的内部创建对象；向外部提供一个静态的公共方法取得该对象

// 单例设计模式饿汉式
class GirlFriend 
   private GirlFriend() 
   
   private static final GirlFriend girlFriend = new GirlFriend();
   public static GirlFriend getGirlFriend() 
       return girlFriend;
   

393. 单例模式懒汉式

// 单例设计模式懒汉式
class GirlFriend 
   private GirlFriend() 
   
   private static GirlFriend girlFriend;
   public static GirlFriend getGirlFriend() 
       if (girlFriend == null) 
           girlFriend = new GirlFriend();
       
       return girlFriend;
   

• 饿汉式与懒汉式的区别：创建时机不同 - 饿汉式在类加载是就创建了对象而懒汉式在使用到对象时才创建
• 饿汉式不存在线程安全问题，懒汉式存在线程安全问题
• java.lang.Runtime 类就是经典的单例模式

public class Runtime 
   private static Runtime currentRuntime = new Runtime();

   /**
    * Returns the runtime object associated with the current Java application.
    * Most of the methods of class <code>Runtime</code> are instance
    * methods and must be invoked with respect to the current runtime object.
    *
    * @return  the <code>Runtime</code> object associated with the current
    *          Java application.
    */
   public static Runtime getRuntime() 
       return currentRuntime;
   

   /** Don't let anyone else instantiate this class */
   private Runtime() 

394. final基本使用

• final 的使用场景：不希望某个类被继承；不希望父类的方法被子类重写；不希望类的成员值被修改；不希望局部变量的值被修改

395. final使用细节1

• final 修饰的属性必须初始化，此后不能更改，初始化可在三个地方进行：定义时初始化；构造器中初始化；代码块中初始化
• 如果 final 修饰的属性同时是 static 的，那么只能在两个地方初始化：定义时初始化；静态代码块中初始化
• 如果非 final 类中含有 final 修饰的方法，则该方法可以被继承不能被重写

396. final使用细节2

• final 往往和 static 搭配使用，效率更高，因为底层编译器做了优化处理，不会导致类的加载

class GirlFriend 
   public static final int AGE = 2;
   // 当使用到 GirlFriend.AGE 时，此静态代码块不会执行即此类未加载
   static 
       System.out.println("I am your only girlfriend");
   

• 八大包装类都是 final 类型的

397. final课堂练习

398. 抽象类引出

• 当父类的某些方法需要被声明，但又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类
• 有抽象方法的类一定是抽象类，抽象类不一定有抽象方法
• 抽象方法没有方法体即

399. 抽象类细节1

• abstract 只可以修饰类和方法

400. 抽象类细节2

• 抽象类的本质也是类，可以有任何普通类有的属性
• 如果一个类继承自抽象类，则必须实现父类的所有抽象方法，除非它也是一个抽象类
• 抽象方法不能使用 private、final、static 来修饰，因为这些修饰符与重写相违背

401. 抽象类课堂练习

402. 抽象模板模式

403. 接口快速入门

404. 接口基本介绍

• JDK 7 及之前的版本，所有的方法都没有方法体及抽象方法
• JDK 8 及之后的版本，接口类中可以有静态方法、默认方法即接口中的方法可以有具体实现

interface Study
   default public void english() 
       System.out.println("Study english");
   
   public static void math() 
       System.out.println("Study math");
   

405. 接口应用场景

406. 接口使用细节1

• 抽象类实现接口可以不用实现方法；接口继承接口时可以不用实现方法

407. 接口使用细节2

• 接口中的属性能且仅能是 public static final 修饰符

408. 接口课堂练习

409. 接口VS继承

• 继承的价值：解决代码的复用性与可维护性
• 接口的价值：设计规范方法，一定程度上实现代码解耦即接口规范性 + 多态

410. 接口多态特性

411. 接口多态传递

412. 接口课堂练习

413. 四种内部类

• 匿名内部类、局部内部类、成员内部类、静态内部类

414. 局部内部类1

• 局部内部类定义在外部类的局部位置，比如方法或代码块中，并且有类名，有以下几个特点

1. 可以直接访问外部类的所有成员，包含私有的
2. 不可以添加访问修饰符，可以添加 final
3. 局部内部类可以理解为方法的局部变量

class Outer 
   private String name = "Spring-_-Bear";
   public void m1() 
       class Inner 
           private void test() 
               // 直接调用外部类的私有成员
               System.out.println(name);
           
       
       // 调用局部内部类的方法
       new Inner().test();
   

415. 局部内部类2

• 如果外部类和局部内部类的成员重名时，默认遵循就近原则。如果想访问外部类的成员，可以使用 外部类名.this.成员 的方式去访问

class Outer 
   private String name = "Spring-_-Bear";
   public void m1() 
       class Inner 
           private String name = "springbear";
           private void test() 
               // 调用局部内部类的成员
               System.out.println(name);
               // 调用外部类的成员
               System.out.println(Outer.this.name);
           
       
       // 调用局部内部类的方法
       new Inner().test();
   

416. 匿名内部类本质

• 匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名，同时还是一个对象

/**
* 基于接口的匿名内部类
* 
* @author Spring-_-Bear
* @date 2021-12-12 08:50
*/
public class C02 
   public static void main(String[] args) 
       // 方式1
       I03 i03 = new I03() 
           @Override
           public void cry() 
               System.out.println("呜呜呜~~~");
           
       ;
       i03.cry();
       // 匿名内部类的类名：I03
       System.out.println(i03.getClass());
   
   
   // 方式2
   new I03() 
           @Override
           public void cry() 
               System.out.println("呜呜呜~~~");
           
   .cry();


interface I03
   void cry();

417. 匿名内部类使用

418. 匿名内部类细节

• 匿名内部类本身既是一个类的定义，同时它本身也是一个对象，因而从语法层面看，它既有类定义类的特征也有创建对象的特征
• 只能定义在方法或代码块中，匿名内部类的地位就好比一个没有名字的局部变量

419. 匿名内部类实践

• 经典使用场景：将匿名内部类直接当作实参传递，简洁高效

420. 成员内部类1

• 成员内部类可以理解为类的成员

421. 成员内部类2

/**
* 成员内部类的使用
*
* @author Spring-_-Bear
* @date 2021-12-12 08:50
*/
public class C02 
   public static void main(String[] args) 
       new Outer().new Inner().m();
   


class Outer 
   private String name = "Spring-_-Bear";
   // 成员内部类
   public class Inner 
       public void m() 
           System.out.println(name);
       
   

422. 静态内部类1

• 静态内部类可以直接访问外部类的所有静态成员，但不能访问非静态成员
• 静态内部类可以理解类的静态成员

423. 静态内部类2

424. 我亦无他唯手熟尔