2-01 Java面向对象-封装继承和多态

灰太狼 2022-02-27 03:56 167阅读 0赞

**目录**

二.数据封装

三.继承和多态

六.Java核心类

--------------------

一.面向对象的概念

面向对象基础

OOP：Object Oriented Programming
    class和instance是“模版”和“实例”的关系：
    类：class，对象模版
    实例：instance，具体对象
    class用字段（field）封装了数据，不同的instance拥有各自独立的field
    通过变量.字段名访问某个字段
    指向instance的变量都是引用变量

# 二.数据封装 #

> 1. 类的构造方法
> 
> 2.类的方法
> 
> 3.类的方法重载
> 
> 4.访问修饰符
> 
> 5.类属性
> 
> 6.类方法
> 
> 7.属性初始化
> 
> 8.单例模式
> 
> 9.枚举类型

1.类的构造方法

构造方法Constructor

*  构造方法可以在new操作时初始化实例对象
 *  构造方法名就是类名
 *  构造方法没有返回值
 *  编译器会为没有定义构造方法的类自动生成默认构造方法

初始化顺序：

*  1.初始化字段
 *  2.初始化块
 *  3.执行构造方法代码

可以定义多个构造方法，编译器根据参数自动判断使用哪个可以在一个构造方法中通过this()调用另一个构造方法

2.类的方法

方法是一组执行语句，遇到return返回 void表示不返回任何值（注意区分null） 方法内部的隐式变量this

方法封装了访问实例字段的逻辑  
        实例字段修饰符：  
            public：外部代码可以访问该字段  
            private：外部代码无法访问该字段  
        方法修饰符：  
            public：外部代码可以访问该方法  
            private：外部代码无法访问该方法

3.类的方法重载

方法重载Overload

*  指方法名相同，但参数不同：类型不同  数量不同  但方法返回值类型相同
 *  方法重载的目的是方便调用重载方法应该完成相同的功能不要去交换参数顺序
 *  重载方法返回值类型应该相同

4.访问修饰符

成员变量有四种修饰符  
private 私有的  
package/friendly/default 不写  
protected 受保护的  
public 公共的

5.类属性

类属性： 又叫做静态属性   
对象属性： 又叫实例属性，非静态属性   
如果一个属性声明成类属性，那么所有的对象，都共享这么一个值

访问类属性有两种方式:  
1. 对象.类属性

teemo.copyright  
2. 类.类属性

Hero.copyright  
这两种方式都可以访问类属性，访问即修改和获取，但是建议使用第二种 类.类属性 的方式进行，这样更符合语义上的理解

6.类方法

类方法： 又叫做静态方法  
对象方法： 又叫实例方法，非静态方法  
访问一个对象方法，必须建立在有一个对象的前提的基础上  
访问类方法，不需要对象的存在，直接就访问

和[访问类属性][Link 1]一样，调用类方法也有两种方式:  
1. 对象.类方法

garen.battleWin();  
2. 类.类方法

Hero.battleWin();  
这两种方式都可以调用类方法，但是建议使用第二种 类.类方法 的方式进行，这样更符合语义上的理解。

7.属性初始化

1.对象属性初始化

对象属性初始化有3种  
1. 声明该属性的时候初始化   
2. 构造方法中初始化  
3. 初始化块

package charactor;
    
    public class Hero {
    	public String name = "some hero"; //声明该属性的时候初始化 
    	protected float hp;
    	float maxHP;
    	
    	{
    		maxHP = 200; //初始化块
    	}	
    	
    	public Hero(){
    		hp = 100; //构造方法中初始化
    		
    	}
    	
    }
    
    //初始化顺序位 声明时初始化 然后 初始化块 然后 构造方法

2.类属性初始化

类属性初始化有2种  
1. 声明该属性的时候初始化  
2. 静态初始化块

package charactor;
    
    public class Hero {
    	public String name; 
    	protected float hp;
    	float maxHP;
    	
    	//物品栏的容量
    	public static int itemCapacity=8; //声明的时候 初始化
    	
    	static{
    		itemCapacity = 6;//静态初始化块 初始化
    	}
    	
    	public Hero(){
    		
    	}
    	
    	public static void main(String[] args) {
    		System.out.println(Hero.itemCapacity);
    	}
    	
    }
    
    //初始化循序为  声明时初始化  然后 静态初始化块初始化

8.单例模式

> 1.定义
> 
> 2.饿汉模式
> 
> 3.懒汉模式

1.定义

单例模式又叫做 Singleton模式，指的是一个类，在一个JVM里，只有一个实例存在。

2.饿汉模式

GiantDragon 应该只有一只，通过私有化其构造方法，使得外部无法通过new 得到新的实例。  
GiantDragon 提供了一个public static的getInstance方法，外部调用者通过该方法获取12行定义的对象，而且每一次都是获取同一个对象。 从而达到单例的目的。  
这种单例模式又叫做饿汉式单例模式，无论如何都会创建一个实例

package charactor;
    
    public class GiantDragon {
    
        //私有化构造方法使得该类无法在外部通过new 进行实例化
    	private GiantDragon(){
    		
    	}
    
    	//准备一个类属性，指向一个实例化对象。 因为是类属性，所以只有一个
    
    	private static GiantDragon instance = new GiantDragon();
    	
    	//public static 方法，提供给调用者获取12行定义的对象
    	public static GiantDragon getInstance(){
    		return instance;
    	}
    	
    }

3.懒汉模式

懒汉式单例模式与饿汉式单例模式不同，只有在调用getInstance的时候，才会创建实例

package charactor;
    
    public class GiantDragon {
     
        //私有化构造方法使得该类无法在外部通过new 进行实例化
        private GiantDragon(){        
        }
     
        //准备一个类属性，用于指向一个实例化对象，但是暂时指向null
        private static GiantDragon instance;
         
        //public static 方法，返回实例对象
        public static GiantDragon getInstance(){
        	//第一次访问的时候，发现instance没有指向任何对象，这时实例化一个对象
        	if(null==instance){
        		instance = new GiantDragon();
        	}
        	//返回 instance指向的对象
            return instance;
        }
         
    }

4.什么时候使用饿汉模式和懒汉模式

饿汉式是立即加载的方式，无论是否会用到这个对象，都会加载。  
如果在构造方法里写了性能消耗较大，占时较久的代码，比如建立与数据库的连接，那么就会在启动的时候感觉稍微有些卡顿。  
  
懒汉式，是延迟加载的方式，只有使用的时候才会加载。 并且有[线程安全][Link 2]的考量(鉴于同学们学习的进度，暂时不对线程的章节做展开)。  
使用懒汉式，在启动的时候，会感觉到比饿汉式略快，因为并没有做对象的实例化。 但是在第一次调用的时候，会进行实例化操作，感觉上就略慢。  
  
看业务需求，如果业务上允许有比较充分的启动和初始化时间，就使用饿汉式，否则就使用懒汉式

5.单例模式三要素  
1. 构造方法私有化  
2. 静态属性指向实例  
3. public static的 getInstance方法，返回第二步的静态属性

9.枚举类型

*  Java使用enum定义常量类型，常量本身带有类型信息，可以使用==比较。
 *  enum定义的类型是class，继承自java.lang.Enum
 *  所有常量都是唯一引用实例
 *  常量可用于switch语句
 *  name()获取常量定义的字符串，注意不要使用toString()
 *  ordinal()返回常量定义的顺序（无实质意义）
 *  可以为enum类编写构造方法、字段、方法
 *  构造方法必须为private

# 三.继承和多态 #

> 1.继承
> 
> 2.super
> 
> 3. 方法重写
> 
> 4.多态
> 
> 5.隐藏
> 
> 6.final
> 
> 7.Object类

1.继承  
继承是面向对象编程的代码复用方式

*  Java使用extends继承  被继承类：超类，父类，基类继承类：子类，派生类
 *  Java只允许继承一个类
 *  Object是所有类的根类
 *  protected修饰的字段和方法可以被子类访问
 *  super表示父类 没有调用super()时编译器会自动生成super()语句  如果父类没有默认构造方法就必须显示调用super()

向上转型与向下转型Upcasting Downcasting

*  子类类型可以安全地向上转型为父类类型
 *  父类类型可以强制向下转型为子类类型（可能报错ClassCastException）可以用instanceof判断类型

继承和组合

*  继承是is关系
 *  组合是has关系

2.super

显示调用父类的属性 构造方法和普通方法

3. 方法重写

子类可以继承父类的对象方法   
在继承后，重复提供该方法，就叫做方法的重写   
又叫覆盖 override

4.多态

定义:同一类型 调用同一方法 产生不同的状态

条件:父类引用指向子类对象 子类复写了父类的方法

操作符的多态   
\+ 可以作为算数运算，也可以作为字符串连接   
类的多态   
父类引用指向子类对象

要实现类的多态，需要如下条件  
1. 父类（接口）引用指向子类对象  
2. 调用的方法有[重写][Link 3]

5.隐藏

与重写类似，方法的重写是子类覆盖父类的对象方法   
隐藏，就是子类覆盖父类的类方法

6.final

final 修饰类,则类不可以被继承

final 修饰方法,则方法不可以被重写

final 修饰属性,则属性只有一次赋值的机会

7.Object类

声明一个类的时候，默认是继承了Object

1.toString()

Object类提供一个toString方法，所以所有的类都有toString方法  
toString()的意思是返回当前对象的字符串表达  
通过 System.out.println 打印对象就是打印该对象的toString()返回值

2.finalize()

当一个对象没有任何引用指向的时候，它就满足垃圾回收的条件  
当它被垃圾回收的时候，它的finalize() 方法就会被调用。  
finalize() 不是开发人员主动调用的方法，而是由虚拟机JVM调用的。

3.equals()

equals() 用于判断两个对象的内容是否相同  
4.==

这不是Object的方法，但是用于判断两个对象是否相同  
更准确的讲，用于判断两个引用，是否指向了同一个对象

5.hashCode()

hashCode方法返回一个对象的哈希值

6.getClass()

getClass()会返回一个对象的[类对象][Link 4]

7.线程相关同步方法

Object还提供线程同步相关方法  
wait()  
notify()  
notifyAll()

#    六.Java核心类 #

> 1.字符串和编码
> 
> 2.StringBuilder
> 
> 3.包装类型 Wrapper
> 
> 4.JavaBean
> 
> 5.常用工具

1.字符串和编码  
字符串  
Java字符串的特点：

*  内容不可变
 *  使用equals()判断是否相等

字符串常用操作：

*  是否包含子串：contains/indexOf/lastIndexOf/startsWith/endsWith
 *  去除首尾空白字符：trim
 *  提取子串：substring
 *  大小写转换：toUpperCase/toLowerCase
 *  替换子串：replace/replaceAll
 *  分割：split
 *  拼接：join

String和其他数据类型互相转换String和char\[\]互相转换   String和byte\[\]互相转换（需要指定编码）编码  
 ASCII    GB2312/GBK/GB18030   Unicode/UTF-8    建议总是使用UTF-8编码

2.StringBuilder

*  可以高效拼接String
 *  是可变对象
 *  可以进行链式操作
 *  不要使用StringBuffer

3.包装类型 Wrapper  
基本类型对应的包装类型

<table style="width:212px;"> 
 <thead> 
  <tr> 
   <th style="width:97px;">基本类型</th> 
   <th style="width:112px;">包装类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="width:97px;">byte</td> 
   <td style="width:112px;">Byte</td> 
  </tr> 
  <tr> 
   <td style="width:97px;">short</td> 
   <td style="width:112px;">Short</td> 
  </tr> 
  <tr> 
   <td style="width:97px;">int</td> 
   <td style="width:112px;">Integer</td> 
  </tr> 
  <tr> 
   <td style="width:97px;">long</td> 
   <td style="width:112px;">Long</td> 
  </tr> 
  <tr> 
   <td style="width:97px;">float</td> 
   <td style="width:112px;">Float</td> 
  </tr> 
  <tr> 
   <td style="width:97px;">double</td> 
   <td style="width:112px;">Double</td> 
  </tr> 
  <tr> 
   <td style="width:97px;">boolean</td> 
   <td style="width:112px;">Boolean</td> 
  </tr> 
  <tr> 
   <td style="width:97px;">char</td> 
   <td style="width:112px;">Character</td> 
  </tr> 
 </tbody> 
</table>

4.JavaBean

JavaBean是一种Java编程规范：  
目的：

*  方便IDE工具读写属性
 *  传递数据
 *  枚举属性

JavaBean特点：

*  一组public getter/setter方法
 *  boolean属性的读方法通常为isXxx()
 *  属性可以是只读或只写的
 *  属性只需要getter/setter方法，不一定需要实例字段利用IDE可以快速生成属性方法

5.常用工具类

*  Math：数学计算
 *  Random：生成伪随机数
 *  SecureRandom：生成安全的随机数
 *  BigInteger：表示任意大小的整数
 *  BigDecimal：表示任意精度的浮点数

[Link 1]: http://how2j.cn/k/class-object/class-object-class-attribute/296.html#step2259
[Link 2]: http://how2j.cn/k/thread/thread-synchronized/355.html#step793
[Link 3]: http://how2j.cn/k/interface-inheritance/interface-inheritance-override/309.html
[Link 4]: http://how2j.cn/k/reflection/reflection-class/108.html