目录
二、面向对象
1.三大特征
- 封装
- 继承
- 多态
2.类
一类事物的抽象。
2.1类的创建：
通过class关键字创建类
class Car{
}3.对象
每个对象具有三个特点：对象的状态，对象的行为和对象的标识。
3.1对象创建：
通过new关键字创建对象
Car c = new Car();
1.2对象在内存中的存储：
1.堆(Heap):
* 凡是new出来的东西都存在堆中。
* 堆是先进先出
* 堆里面的东西都有一个地址值：16进制
* 堆里面的数据都有默认值
2.栈（Stack）：
* 存放的都是方法中的局部变量。方法运行一定要在栈中运行。
* 栈是先进后出。
* 局部变量：方法的参数，或者是方法{}内部的变量。
* 作用域：一旦超出作用域，立刻从栈内存中消失。
3.方法区（Method Area）：
* 存储.class的相关信息，包含方法的信息。
4.本地方法栈（Native Method Stack）：
* 与操作系统相关。
5.寄存器（pc Register）:
* 与CPU相关
4.封装
4.1定义：
封装是指隐藏对象的属性和实现细节，仅仅对外提供公共的访问方式。
4.2封装的优点
1.提高安全性
2.提高重用性
4.3private（私有的）：
访问修饰符，用来修饰成员变量和成员方法。被修饰过的成员只能在本类中访问。要想修改只能对外提供公共的（public修饰的）get和set方法。
public class Demo {
public static void main(String[] args) {
Person p = new Person();
p.setName("张三");
System.out.println(p.getName());
p.setAge(18);
System.out.println(p.getAge());
}
}
class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
4.4匿名对象
《1》定义：
没有名字的对象，是对象的简化表现形式。
《2》使用场景
1.当被调用的对象只调用一次（多次创建对象会浪费内存）。
new Demo().show();//创建了一个对象调方法
new Demo().game();//又创建了一个对象调方法5.构造方法
5.1定义：
构造方法是一种特殊的方法，它是一个与类同名且返回值类型为同名类类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的创建或者对象的初始化。当类实例化一个对象时会自动调用构造方法。
构造方法和其他方法一样也可以重载。
5.2形式：
修饰符 类名 (参数类表){
方法体；
}
class Car{
//构造方法
public Car(){
System.out.println("构造方法");
}
}
5.3this关键字
1.this关键字代表对本类对象的应用；
public class Demo {
public static void main(String[] args) {
Person p = new Person();
p.test();
}
}
class Person {
String name = "张三";
int age = 18;
public void test() {
int age = 20;
System.out.println(age);//局部变量age
System.out.println(this.age);//成员变量age
}
}
2.在构造方法中this()必须放在第一行。
public class Demo {
public static void main(String[] args) {
new Person();
}
}
class Person {
public Person() {
this(10);//调用本类中的含参构造
System.out.println("无参构造");
}
public Person(int a) {
System.out.println("含参构造");
System.out.println(a = 10);
}
}
6.继承extends
6.1特点
1、 使用extends关键字
2、 相当于子类把父类的功能复制了一份
3、 java只支持单继承
4、 继承可以传递（爷爷，儿子，孙子的关系）
5、 不能继承父类的私有成员
6、 继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展
7、 像是is a 的关系
6.2super关键字
1、 通过super关键字可以使用父类的内容
2、 super代表父类的一个引用对象
3、 如果在构造方法中互相使用，必须出现在调用位置的第一行
public class Demo {
public static void main(String[] args) {
new Person();
}
}
class Person {
String name = "人";
public void eat() {
System.out.println("父类吃的方法");
}
}
class Baby extends Person {
String name = "小孩";
public Baby() {
System.out.println(name);// 小孩
System.out.println(super.name);// 人
}
}
面试题：
this和super的区别：（一）
1.this和super都代表什么
* this:代表当前对象的引用,谁来调用我,我就代表谁
* super:本类当前对象的父类内存空间标识
2.this和super的使用区别
a:调用成员变量
this.成员变量 调用本类的成员变量,也可以调用父类(本类中没有该变量,继承来的)的成员变量(this.num1)
super.成员变量 调用父类的成员变量(super.num2)
b:调用构造方法
this(...) 调用本类的构造方法
super(...) 调用父类的构造方法
* super(…)或者this(….)必须出现在构造方法的第一条语句上
c:调用成员方法
this.成员方法(...) 调用本类的成员方法,也可以调用父类(本类中没有该方法,继承父类来的)的方法
super.成员方法(...) 调用父类的成员方法
面试题：
this和super的区别：（二）
1、 this代表本类对象的引用，super代表父类对象的引用。
2、 this用于区分局部变量和成员变量
3、 super用于区分本类变量和父类变量
4、 this.成员变量 this.成员方法() this(【参数】)代表调用本类内容
5、 super.成员变量 super.成员方法() super(【参数】)，代表调用父类内容
6、 this和super不可以同时出现在同一个构造方法里，他们两个只要出现都得放在第一行，同时出现的话，到底第一行放谁呢。
6.3方法重写：
在继承中如果父类的方法无法满足子类的需求，那么就要进行方法的重写。
方法的重写就是方法名、参数列表都相同。
注意：
1、父类中的私有方法不能被重写
2、子类重写父类方法时，修饰符要大于等于父类修饰符的权限
3、子类重写父类的方法如果返回值类型是基本类型的话，要求相同。
public class Demo {
public static void main(String[] args) {
new Baby();
}
}
class Person {
String name = "人";
public void eat() {
System.out.println("父类吃的方法");
}
}
class Baby extends Person {
String name = "小孩";
// eat()重写
public void eat() {
System.out.println("子类吃的方法");
}
}
面试题：
重载和重写的区别（Overload和Override的区别）：
1、重载：（发生在同一类中）是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同
2、重写：是存在父子类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型
3、重写是父类与子类之间多态性的一种表现
4、重载是一类中多态性的一种表现
6.4继承中的内存结构图
7.static静态
7.1特点
1、 可以修饰成员变量，成员方法
2、 随着类的加载而加载，优先于对象加载
3、 只加载一次，就会一直存在，不再开辟新空间
4、 全局唯一，全局共享
5、 可以直接被类名调用
6、 静态只能调用静态，非静态可以随意调用
7、 static不能和this或者super共用，因为有static时可能还没有对象
7.2静态方法的内存图
7.3静态的调用关系
静态只能调用静态（变量或者方法），非静态可以访问所有的不管是不是静态
public class Demo {
public static void main(String[] args) {
new Person().eat();
}
}
class Person {
String name = "张三";
static int age = 18;
public void eat() {
System.out.println("eat()");
System.out.println(name);
System.out.println(age);
play();// 非静态可以调用静态
}
public static void play() {
System.out.println("play()");
}
}
7.4静态代码块、构造代码块、局部代码块
1.定义：
1、静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化
2、 构造代码块：在调用构造方法前会自动调用，每次创建对象都会被调用
3、 局部代码块：方法里的代码块，方法被调用时才会执行
2.触发的时间节点、作用
| 名称 | 位置 | 触发时间节点 | 作用 |
| 构造代码块 | 类里方法外 | 在调用构造方法之前 | 用来提取构造方法的共性 |
| 构造方法 | 类里 | 在创建对象时 | 用来创建对象或完成对象的初始化 |
| 静态代码块 | 类里方法外 | 在类加载时 | 完成项目的初始化（只加载一次，并且加载的最早） |
| 局部代码块 | 方法里 | 在方法调用时 | 用来控制变量的作用范围 |
3.执行顺序: 静态代码块 > 构造代码块 > 构造方法 > 局部代码块
public class Demo {
public static void main(String[] args) {
new Demo1();
}
}
class Demo{
// 构造代码块
{
System.out.println("构造代码块");
}
// 构造方法
public Demo() {
// 局部代码块
{
System.out.println("局部代码块");
}
System.out.println("构造方法");
}
// 静态代码块
static {
System.out.println("静态代码块");
}
}8.final最终的
8.1概念：
1、 是java提供的一个关键字
2、 final是最终的意思
3、 final可以修饰类，方法，成员变量
初衷是因为：java出现了继承后，子类可以更改父类的功能，当父类功能不许子类改变时可以利用final关键字修饰父类。
8.2特点：
1、 被final修饰的类，不能被继承
2、 被final修饰的方法，不能被重写
3、 被final修饰的变量是个常量，值不能被更改
4、 常量的定义形式： final 数据类型 常量名 = 值
public class Demo01 {
public static void main(String[] args) {
new Zi().show();
new Zi();
System.out.println(Zi.NAME);//调用常量
}
}
class Fu {
public static final String NAME = "Jim";//定义常量，常量字母都要大写
public final void show() {
System.out.println("Fu--show()");
}
}
class Zi extends Fu {
}9.多态
9.1概念：
多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOP）的一个重要特征。
主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
好处是可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。
例如：水，在不同时刻可以有多种形态，包括水蒸气，冰，水。
9.2特点：
1、 多态的前提是继承
2、 要有方法的重写
3、 父类引用指向子类对象,如：Animal a = new Dog(); -- 小到大，向上转型
//方法声明：使用父类的；
//方法体：使用子类的；
4、 多态中，编译看左边，运行看右边
//编译看左边--是指能够调用的功能,一定是左边也就是父类提供的
//运行看右边--是指运行的结果看右边,看子类的实现方式
public class Demo02 {
public static void main(String[] args) {
Animal a = new Dog();//多态--向上造型
a.eat();
}
}
class Animal {
public void eat() {
System.out.println("Animal--eat()");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("Dog--eat()");
}
}9.3多态的好处
1、 多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法。
2、 提高了程序的扩展性和可维护性。
9.4多态使用中的特点：
1、成员变量：使用的是父类的
2、成员方法：由于存在重写现象所以使用的是子类的
3、静态成员：随着对象而存在，谁调用的就返回谁的
public class K {
public static void main(String[] args) {
Fu2 f = new Zi2();// 多态，只能用父类的。。。
// 多态的成员变量，就是父类的
System.out.println(f.num);// 10
// 成员方法，因为存在重写，所以是子类的
f.study();// Zi..study()
// 静态成员,谁调用就是谁的
System.out.println(f.count);// 10
f.sleep();// Fu..sleep()
}
}
class Fu2 {
int num = 10;
static int count = 10;
public void study() {
System.out.println("Fu..study()");
}
public static void sleep() {
System.out.println("Fu..sleep()");
}
}
class Zi2 extends Fu2 {
int num = 20;
static int count = 20;
public void study() {
System.out.println("Zi..study()");
}
public static void sleep() {
System.out.println("Zi..sleep()");
}
}
面试题：
静态变量和实例变量的区别：
在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
9.5向上造型和向下造型
在JAVA中，继承是一个重要的特征，通过extends关键字，子类可以复用父类的功能，如果父类不能满足当前子类的需求，则子类可以重写父类中的方法来加以扩展。
在应用中就存在着两种转型方式，分别是：向上转型和向下转型。
比如：父类Parent,子类Child
向上转型：父类的引用指向子类对象Parent p=new Child();
说明：向上转型时，子类对象当成父类对象，只能调用父类的功能，如果子类重写了父类的方法就根据这个引用指向调用子类重写方法。
向下转型(较少)：子类的引用的指向子类对象，过程中必须要采取到强制转型。
Parent p = new Child();//向上转型，此时，p是Parent类型
Child c = (Child)p;//此时，把Parent类型的p转成小类型Child
//其实，相当于创建了一个子类对象一样，可以用父类的，也可以用自己的
说明：向下转型时，是为了方便使用子类的特殊方法，也就是说当子类方法做了功能拓展，就可以直接使用子类功能。
public class Case02 {
public static void main(String[] args) {
Father1 f = new Son1();//向上造型
System.out.println(f.name);
f.eat();
System.out.println("--------------------------");
Son1 s = (Son1) f;//向下造型
System.out.println(s.name);
s.eat();
}
}
class Father1 {
String name = "Tom";
public void eat() {
System.out.println(1111111);
}
}
class Son1 extends Father1{
String name = "Jim";
public void eat() {
System.out.println(222222);
}
}10.异常Exception
10.1概述
用来封装错误信息的对象。
组成结构：类型，提示，行号。
10.2异常的继承结构
Object：祖宗级别的存在，所有的类都继承于Object类
Throwable - 顶级父类
-- Error：系统错误，无法修复
-- Exception：可修复的错误
--RunTimeException
--ClassCastException
--ClassNotFoundException
10.3异常处理
1.捕获异常（推荐）：
try{
需要捕获的代码
}catch(异常类型 异常名){
处理方案
}
import java.util.Scanner;
//测试异常的发生和解决
public class Test6_Exception {
// 接收键盘输入的两个整数并做除法运算
public static void main(String[] args) {
//1，捕获异常：把可能发生异常的代码放在try里，
//当异常发生时会被catch住并执行catch中的代码执行异常处理的代码
try {
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
System.out.println(a/b);
} catch (Exception e) {
//提出解决方案
System.out.println("您输入的两次整数有误！");
}
}
}2.抛出异常：
在会发生异常的方法上添加代码：throws 异常类型
例如：public void method() throws Exception
public class Case03 {
public static void main(String[] args) {
/*
异常抛出最终还是要捕获处理的，如果在main方法上抛出异常就真的没人给你处理了
*/
try {
method2();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void method2() throws Exception {
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
System.out.println(a/b);
}10.4访问修饰符
public > protected > default > private
| 访问修饰符 | 类 | 包 | 子类 | 任意 |
| public | √ | √ | √ | √ |
| protected | √ | √ | √ | |
| default | √ | √ | ||
| private | √ |
11.抽象类abstract
11.1概念
Java中可以定义没有方法体的方法，该方法由其子类来具体的实现。该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。
抽象类可以理解为是一个只有方法声明没有方法体的特殊类。
修饰符 abstract 返回值 方法名(参数列表);
11.2特点
1、 通过java关键字abstract实现
2、 可以修饰方法或者类
3、 抽象类中可以没有抽象方法（由子类去实现）
4、 如果类中有抽象方法，那该类必须定义为一个抽象类
5、 子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写
6、 多用于多态中
7、 抽象类不可以被实例化
11.3抽象类的用法
《1》构造方法
抽象类也有构造方法，但是不能本身实例化。
那抽象类的构造函一般用于给子类实例化。
《2》抽象类的成员变量
抽象类里既可以有变量，也可以有常量。
《3》抽象类的成员方法
抽象类里，既可以有普通方法，有可以有抽象方法。
public class Demo03 {
public static void main(String[] args) {
// 多态应用
Father f = new Son();
System.out.println(f.name);
System.out.println(Father.AGE);
f.eat();
f.play();
}
}
//抽象父类
abstract class Father {
// 构造方法
public Father() {
System.out.println("父类构造方法");
}
String name = "张三";// 成员变量
public static final int AGE = 18;// 常量
// 普通方法
public void eat() {
System.out.println("父类eat()");
}
// 抽象方法
public abstract void play();
}
class Son extends Father {
// 构造方法
public Son() {
// super();//默认会存在一个super来调父类无参构造
System.out.println("子类构造方法");
}
// 重写父类抽象方法
@Override
public void play() {
System.out.println("重写后的play()");
}12接口Interface
12.1概念
Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。
Java接口和Java抽象类代表的就是抽象类型，就是我们需要提出的抽象层的具体表现。OOP面向对象的编程，如果要提高程序的复用率，增加程序的可维护性，可扩展性，就必须是面向接口的编程，面向抽象的编程，正确地使用接口、抽象类这些太有用的抽象类型做为java结构层次上的顶层。
interface 接口名{ 代码… }
12.2特点
1、 接口中都是抽象方法
2、 通过interface关键字创建接口
3、 通过implements让子类来实现
4、 可以理解成，接口是一个特殊的抽象类
5、 接口突破了java的单继承的局限性
6、 接口和类之间可以多实现，接口和接口之间可以多继承
7、 接口是对外暴露的规则，是一套开发规范
8、 接口提高了程序的功能扩展，降低了耦合性
12.3接口的用法
《1》构造方法
接口里是没有构造方法的。
在创建实现类的对象时默认的super()，是调用的默认Object的无参构造。
《2》成员变量
接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上：public static final
《3》成员方法
接口里的方法，默认就都是抽象的，如果你不写明是abstract的，那会自动补齐。
例如：public abstract void save
public class Demo02 {
public static void main(String[] args) {
Inter2 i = new InterImpl();
i.add(20);
i.delete(02);
i.get("王五");
i.save(03);
i.update();
}
}
interface Inter {
// public Inter() {
// System.out.println("");
// }
void save(int id);//接口中的抽象方法可以简写
int add(int age);
void delete(int id);
}
interface Inter2 extends Inter {
void get(String name);
String update();
}
class InterImpl implements Inter2 {
@Override
public void save(int id) {
System.out.println("成功保存了" + id);
}
@Override
public int add(int age) {
System.out.println("增加了" + age);
return 18;
}
@Override
public void delete(int id) {
System.out.println("删除了" + id);
}
@Override
public void get(String name) {
System.out.println("获取用户名为" + name);
}
@Override
public String update() {
System.out.println("修改用户名");
return "zhangsan";
}
面向对象关系总结：
1、类和类的关系：继承 extends / 单继承 / 单根继承
-- 继承的意义：为了提高代码的复用性，减少了代码的编写提高开发效率。
-- 方法重写的意义：在不修改父类源码的前提下，在子类中重写业务，从此使用的就是重写后的功能。
-- 要求子类的方法声明和父类一样，只要改方法体。
-- 有了继承有了重写就产生了多态，多态的意义：为了统一程序的调用标准，标准就是父类。
-- 多态 也就是向上转型/向上造型。
-- 向下造型的意义：很少用，相当于想要使用子类的特殊功能，还不如直接创建子类对象简单。
-- class A extends B
-- 其中，A和B都是类，A是子类，B是父类，A就拥有了B的所有功能(除了私有的和构造方法)
-- 其他知识点：this 和super ，构造方法，各种代码块...
2、类和接口关系：实现implements / 单实现 / 多实现
-- class A implements B,C
-- 其中，A是实现类,B和C是接口
-- 要求A 可以把 B 和C 接口里的所有 抽象方法 都重写掉，否则 A 就是抽象类
-- 接口不能创建对象
-- 接口里没有构造方法，接口里都是常量，接口里都是抽象方法
3、接口和接口关系：继承extends / 单继承 / 多继承
-- 接口的多继承的关系，打破了java单继承的局限性
-- interface A extends B,C
-- 其中，A B C 都是接口，A是子接口，同时拥有B和C接口里的所有功能
-- class AImpl implements A
-- 要求AImpl需要重写A接口里的所有方法(是包含B和C接口的所有方法)，否则就是抽象类
4、接口和抽象类的区别！！！
-- 相同点：都是抽象层，都不能实例化
-- 不同点：
-- 1、抽象类用abstract关键字描述，接口用interface
-- 2、子类和抽象类之间是extends关系，实现类和接口之间是implements关系
-- 3、抽象类中 可以 有构造方法 ，接口里 不能 出现 构造方法
-- 4、抽象类里可以有 变量，接口里没有变量全都是静态的常量
-- 5、接口里定义常量的语法：public static final String NAME="jack"，会为变量自动拼接public static final
-- 6、抽象类里 可以有普通方法 也可以有 抽象方法，接口都是抽象方法
-- 7、抽象类和子类之间是继承关系，而且java中，只支持单继承
-- 8、接口突破了java单继承的局限性，因为接口可以多继承也可以多实现，甚至可以继承的同时多实现
-- 9、接口的复杂用法
-- 多继承： interface A extends B,C 其中A是子接口，同时拥有自己的和BC的功能
-- 多实现： class AImpl implements M,N,O,P 其中AImpl是实现类，需要同时重写MNOP的所有抽象方法，否则就是一个抽象类
-- 继承的同时多实现： class AImpl extends Object implements M,N 一定是先继承后实现
abstract注意事项（拓展）
抽象方法要求子类继承后必须重写。那么，abstract关键字不可以和哪些关键字一起使用呢？以下关键字，在抽象类中。用是可以用的，只是没有意义了。
1、 private：被私有化后，子类无法重写，与abstract相违背。
2、 static：静态的，优先于对象存在。抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的。
3、 final：被final修饰后，无法重写，与abstract相违背。
面试题：
接口和抽象类的区别：
1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
2、抽象类要被子类继承，接口要被类实现。
3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
6、抽象方法只能申明，不能实现，接口是设计的结果 ，抽象类是重构的结果
7、抽象类里可以没有抽象方法，如果要扩展抽象类的新方法，子类将很容易的就能得到这些新方法。
8、如果一个类里有抽象方法，那么这个类只能是抽象类
9、抽象方法要被实现，所以不能是静态的，也不能是私有的。
10、接口可继承接口，并可多继承接口，但类只能单根继承。
面试题：
final和finally的区别：
Final：
1.用来修饰数据
包括成员变量和局部变量，该变量只能被赋值一次并且他的值无法被改变。对于成员变量来讲时,我们必须在声明时，构造器或者代码块中对他赋值
2.用来修饰局部变量
表示在变量的生存期中它的值不能被改变，final修饰局部变量时，即可以在定义时指定默认值，也可以不指定默认值。当不指定默认值时，可以在后面代码块赋值一次。仅有的一次赋值
3.修饰方法
表示该方法无法被重写，如果父类的的方法不想被重写，那么可以在前面加上final关键字修饰
4.修饰类 表示该类无法继承 String是典型的final修饰符修饰的，不可以继承
5.修饰符不可以被继承，但是可以继承其他类
6. Final修饰的变量称为常量，这些变量只能被赋值一次
Finally块：
Finally块一般用来关闭物理资源(数据库连接，网络连接，磁盘文件)，这些物理资源必须显示关闭。除非在try块、catch块中调用了退出虚拟机的方法，否则不管在try块，catch块中执行怎样的代码，出现怎样的情况，异常处理finally一定会被执行。
面试题：
static和abstract的区别：
static关键字最基本的用法是：
- 被static修饰的变量属于类变量/类方法，可以通过类名.变量名直接引用，而不需要new出一个类
不同的类有自己的静态资源，这可以实现静态资源分类。避免重名。abstract:
目录
- 抽象方法 只有声明，没有实现，不可被实例化，只能被声明引用，不能创建对象，
- 如果一个类中有抽象方法，这个类就必须是抽象类，但是抽象类中未必有抽象方法，抽象类中可以有构造方法
- 子类继承抽象类，如果子类不希望也成为抽象类，他就必须实现父类中声明的所有抽象方法
- 抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法
注：
- 若子类继承抽象类，并重写了所有的抽象方法，则此类是一个”实体类”,即可以实例化
- 若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的！
228
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
