从0到1学java：面对对象的高级特性

/   前言   /

 

• 面向对象OOP是基于面向过程而言，面向对象简单来说就是将功能封装到对象（数据和操作结合）里，我们面向对象，让对象去完成这些功能。万物皆对象。

• （在我们程序员眼中，一切皆对象）

• 理解面向对象，经典案例：把大象塞进冰箱

  1. 面向过程的做法：1.打开冰箱门 2.把大象塞进去 3.关闭冰箱门 当有两个不同的人用不同的方法实现这样的步骤，我们需要为不同的人量身定做不同解决事情的方法。

  2. 面向对象，找个对象帮你做事 我们把冰箱作为对象，1.冰箱门可以被打开 2.大象可以被塞进去 3.冰箱门可以被关闭（面向对象写出通用的方法，屏蔽了所有人的差异）

 

/   正文   /

 

面对对象的高级特性

要点

• static的含义

• 继承的规则

• 子类实例化的过程

• 方法的覆盖

• final关键字

• 抽象类的特性

• 接口的规范

• 数据类型的转换

• 包和访问权限修饰符

• 包装类和内部类

静态修饰符static

• static可以修饰的元素

  • 属性 – 共享

  • 方法 – 访问的方式

  • 块 – 执行的时机

  • 只能修饰类成员，不能修饰局部变量。

• 需要注意的问题：

  • 静态方法可以直接访问静态变量，如要访问非静态变量必 须先实例化。

  • 静态方法中不能this。

  • 静态方法不能被非静态方法覆盖。

静态属性

• 所有对象共享

  • 也称为类变量

• 两种方式访问：

  • 类名.属性；

  • 对象名.属性

静态方法

• 不需要实例化，可以直接访问；

  • 也称为类方法

• 两种方式访问：

  • 直接访问：类名.方法名()；

  • 实例化后访问：对象名.方法名()；

• 作用：

  • 简化方法的使用；

  • 便于访问静态属性；

• 限制：

  • 静态方法只能直接访问静态成员。静态方法中不能this；

  • 静态方法不能被非静态方法覆盖；

特殊的静态方法main

• 必须public权限修饰符

• 必须static静态修饰符

• 必须返回空值void

• main函数名不可改变

• String[] args命令行参数

变量初始化的顺序

1. 隐式赋予变量默认值；

2. 显式赋予初始值；

3. 构造方法体赋予新值；

程序块

• 静态程序块

• 非静态程序块

类的继承

• 格式：修饰符 class 子类名 extends 父类名

• Java中只能单继承，也就是说每个类只能有一个父类。

• 父类的别名：

  • 基类BaseClass

  • 超类SuperClass

• 子类的别名：

  • 衍生类

  • Child Class

  • Derived Class

类继承的规则

• 子类继承父类的所有属性和所有方法；

• 但是构造器不继承；

子类实例化过程

• 子类实例化是先实例化其父类，然后实例化子类。

• 要先调用父类的构造器，父类构造器运行完毕，才调用子类的 构造器。

• 如果实例化类D，说出构造器执行的顺序。

super和this关键字

• super()

  • 指向父类的引用。

  • 作用：调用父类的构造器

  • 只能出现在子类的构造器中，且必须是第一行

  • super()中的参数，决定了调用父类哪个构造器

  • 如果子类构造器中没有出现super，那么默认super()，即调用父类的空构造器。

• this()

  • 指向本类的引用。

  • 作用：调用本类的构造器

  • 只能写在构造器的第一行

• 在同一个构造器中super()和this()不能同时出现

方法的覆盖

• 所谓 “覆盖(override)” 是在声明子类的成员方法时，其名称和参数都与父类的成员方法的名称和参数一样，在面向对象的程序设计中称为方法的覆盖。

• 规则

1. 在父子类之间继承时发生

2. 多个方法的名称相同

3. 返回值类型必须相同

4. 每个方法参数数量和参数类型和顺序相同

5. 权限修饰符要求：子类方法的要不小于父类方法的

6. 子类方法只能抛出父类方法异常或其异常的子类。

7. 方法覆盖如下例所示：

   • 父类方法：protected void getArea( int w, int h) throws IOException;

   • 子类方法：public void getArea( int x, int y) throws FileNotFoundException;

关键字final

• final可以修饰的元素：

  • 变量(属性和局部变量和形参)：不能被重新赋值

• 在声明的同时赋值

  • 方法：不能被覆盖，即不能修改。类：不能被继承 注：* final类型的属性比较特殊，可以在声明的同时赋值，还可 以在构造器中赋值，在其他的方法中不能够赋值。

常量定义的一般格式

• 常量一般定义成下面的形式：

  • public static final double PI=3.14;

• 首先：

  • 一般把它设置为静态static，多个实例共享该常量，没有必 要每个对象保存一份；

• 其次：

  • 设置为final类型，赋值以后不能再改变；

• 第三：

  • 注意遵守常量命名规范，所有字母大写，单词之间使用下 划线，如MAX_VALUES。

抽象方法

• 只有方法声明，没有方法实现的方法；

• 抽象方法用abstract声明，以“;”结尾。

public abstract void getArea();

抽象类

• 含有抽象方法的类必须声明为抽象类；

• 用abstract声明class

public abstract class Rectangle{
    public abstract void getArea();
}

抽象类规则

• 注意：

  • 抽象类不能被实例化；

  • 其包含的抽象方法必须在其子类中被实现，否则该子类只 能声明为abstract；

  • 抽象方法不能为static；

• 在下列情况下，一个类必须声明为抽象类：

  • 当一个类的一个或多个方法是抽象方法时；

  • 当类是一个抽象类的子类，并且没有实现父类的所有抽象 方法，即只实现部分；

  • 当一个类实现一个接口，并且不能为全部抽象方法都提供实现时；

• 本质

• 抽象类是抽象方法和非抽象方法的集合

• 特殊情况

  • 全部是抽象方法

  • 全部为非抽象方法

• 实际上是一套规范

接口interface

• 接口不是一个类，不能实例化；

• 接口是常量和抽象方法的集合；

• 接口对类来说是一套规范，是一套行为协议；

• 定义格式如下：

public interface	MyInterface
{
interfaceBody
}

类实现接口

• 接口实质上就是一个常量和抽象方法的集合。为了使用一个接口，你要编写实现接口的类。

• 如果一个类要实现一个接口，那么这个类就必须实现接口中所有抽象方法。否则这个类只能声明为抽象。

• 格式如下：

public class MyClass implements	MyInterface{
//实现接口中所有抽象方法
}

接口的特点

• 接口使用interface关键字来定义，而不是class。

• 接口中定义的变量都是公共静态最终变量。

• 接口中没有自己的构造函数，而且接口中定义的方法全部都是 抽象方法，即只提供方法的定义，而没有提供方法的具体实现的语句。

• 接口采用多继承机制，而不像类一样采用单继承机制。

• 接口默认：

  • 常量：public static final

  • 抽象方法：public abstract

接口和抽象类的区别

• 接口不能含有任何非抽象方法，而抽象类可以。

• 类可以实现许多接口，但只能有一个父类。

• 接口不是类分级结构的一部分，没有联系的类可以实现相同的接口。

接口种访问常量

• public static final int MAX_SPEED=100;

• 有三种方式：

  • 对象名.MAX_SPEED

  • 类名. MAX_SPEED

  • 接口名. MAX_SPEED

引用数据类型的转换

• 前提：具有继承关系

• 原则：子类就是父类

• 向上造型：子类转换为父类，自动转换；

• 向下造型：强制转换

  • 曾经向上转换过的对象，才能再向下转换。

• 向上转换损失了子类新扩展的属性和方法

• 仅剩下父类中声明过的属性和方法

Person p = new Student();
Student s = (Student)p;

instanceof运算符

• instanceof运算符的一般格式：

  • object instanceof class

  • object instanceof interface

  • 返回值都是boolean

多态

• 本质上遵守引用类型的转换规则

• 分为两种表现形式

  • 赋值多态

  • 传参多态（隐式的赋值多态）

• 多态的机制

• Override

所有类的父类 Object

• Object类是所有类的超类，在Object类中定义的方法，在所有 类中都可以使用。

• 一个类可以不是Object类的直接子类，但一定是Object类的子 类，Java中的每一个类都是从Object扩展来的。

• Object是Java语言中唯一一个没有父类的类。

• Object类常用方法：

  • public int hashCode()

• 返回十六进制整数，唯一标识一个对象

  • public String toString()

• 返回 类名@hashcode

  • public boolean equals(Object obj)

• 比较两个对象引用的值是否相等（比较地址）

equals()与==的区别

• 理解equals()方法和==运算符的区别是非常重要的。

• equals()只能比较引用类型，==既能比较引用类型又能比较 基本类型。

• equals()方法从Object类继承

  • 原意：比较对象引用的值

  • 一般都被子类方法覆盖，不再比较引用的值

• ==运算符

  • 比较基本数据类型：相当于算术等号

  • 比较引用数据类型：比较引用的值，不能被覆盖。

java种常用的包

• java.lang

  • Java语言包，任何程序中，该包都被自动导入。

• java.awt

  • 图形用户界面包。

• java.awt.event

  • 图形用户界面事件处理包。

• java.swing

  • 跨平台轻量级组件包。

• java.sql

  • 数据库访问包。

• java.io

  • 这个包由对您的输入/输出操作有用的类组成。

• java.util

  • 该包提供了许多创建如：lists, calendar, date等所需要的类和接口。

• java.net

  • 该包提供了许多进行TCP/IP网络编程的类和接口。

用import导入包

• 导入包中所有的类：import package_name.*;

• 依照下列语法导入单个类：import package_name.class_name;

• 导入网络包中所有的类：import java.net.*;

访问权限修饰符

• public > protected > friendly > private

• 封装

权限/位•置	private	friendly	protected	public
类内部	√	√	√	√
同包无继承关系类		√	√	√
同包子类		√	√	√
不同包子类			√	√
不同包无继承关系类				√

包装类wrapper

• Everything is object.

• Java编程语言不把基本数据类型看作对象。

• Java 编程语言提供包装类来将基本数据类型看作对象。

• 基本数据类型：byte char short int long float double boolean

• 引用数据类型：Byte Character Short Integer Long Float Double Boolean

包装类的创建办法

• 基本数据类型通过构造器转换为包装类

int pInt = 500;
Integer wInt = new Integer(pInt);
Integer a=new Integer(3);

包装类的常用方法

• primitive  wrapper

  • Contructor

• String  wrapper

  • Contructor(除Character,注意Boolean)

  • static valueOf( String s) 静态有参数

• wrapper  primitive

  • typeValue() 无参数

• String  primitive

  • static parseType()

• equals()

• toString()

内部类

• 内部类就是定义在另一个类内部的类。

• 内部类对于同一包中的其它类来说，内部类能够隐藏起来。

内部类与外部类

• 无需创建外部类的对象，即可从内部类访问外部类的变量和方法。

• 必须创建内部类的对象，否则无法从外部类访问内部类的变量和方法。

• 如果内部类中有和外部类同名的变量或方法，则内部类的变量和方法将获得比外部类的变量和方法更高的优先级。

• 不能定义static变量

从其他类访问内部类

• 在Outer内访问Inner,只需如下:

  • Inner in=new Inner();

• 在Outer外访问Inner,必须如下:

  • Outer o = new Outer(); //实例化外部类

  • Outer.Inner oi=o.new Inner(); //实例化内部类

内部类的权限修饰符

• 普通类的访问控制方式

  • friendly

  • public

• 内部类定义为

  • private

  • protected

  • public

  • friendly

静态内部类

• Outer.Inner inn=new Outer.Inner();

• 非静态内部类不可以使用上面的方式

• 可以定义static变量

• 就相当于定义在外部的类。

局部内部类

• Outer.Inner inn=new Outer.Inner();

• 非静态内部类不可以使用上面的方式

• 可以定义static变量

• 就相当于定义在外部的类。

class A{
    int a;
    public void method(){
    }
    class B{ }
}

class A{
    int a;
    public void method( int c ){ int b=0;
    class B{ }
    }
}

匿名内部类

• 匿名内部类：

  • 顾名思义，匿名内部类就是没有类名的内部类.

     

/   总结   /

 

本文主要讲了面对对象的高级特性和用法，这是面对对象的高级用法总结，理解好这些会有助于我们更加去深入了解java这门语言。

 

往期推荐：

如何入门做软件开发

为什么我不推荐入行程序员

做全栈开发很难吗

关注我的公众号，学习技术或投稿

长按上图，识别图中二维码即可关注