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

Posted Spring-_-Bear

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面向对象编程(高级部分)相关的知识,希望对你有一定的参考价值。

第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. 我亦无他唯手熟尔

以上是关于面向对象编程(高级部分)的主要内容,如果未能解决你的问题,请参考以下文章

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

8. Scala面向对象编程(高级部分)

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

进击的Python第七章:Python的高级应用面向对象编程进阶

C++面向对象高级编程(下)

Python7 - 面向对象编程进阶