面向对象知识点梳理(三)

(一)知识点概述

多态

1:多态是什么，前提是什么?

答：某一个事事物在不同时刻不显出的不同形态。

前提：有继承关系，有方法得重写，有父类指向子类的对象

2:多态中成员访问的特点?

成员变量 编译看左，运行看左。

成员方法 编译看左，运行看右。

静态方法 编译看左，运行看左。

3:多态的好处及弊端？如何解决多态的弊端？

答：好处：提高了程序的维护性（由继承保证）和扩展性（由多态保证）。弊端：不能访问子类特有功能，解决方法：进行转型。

4:什么是向上转型？什么是向下转型？

答：向上转型是从子到父 ，父类引用指向子类对象。

向下转型是从父到子，父类引用转为子类对象

5:多态练习

钢铁侠案例

榨汁机案例

6:抽象类概述及其特点?

答：一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

格式：abstract class 类名{}

public abstract void eat();

7:抽象类成员特点?

答：抽象类和抽象方法必须用abstract关键字修饰

8:抽象类练习:

A:案例

具体事物：基础班老师，就业班老师

共性：姓名，年龄，讲课。

B:案例

具体事物：猫，狗

共性：姓名，年龄，吃饭

9:抽象类的小问题

A:一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?

答：可以的.子类访问父类的数据的初始化.

B:abstract不能和哪些关键字共存 (写三个)

答:private final static

10:接口的概述及其特点?

答:对象本身开始并不具有的功能,为了体现事物功能的扩展性,就定义了这些额外的功能! 接口用关键字interface 表示

格式:interface 接口名{} 接口的实现用implements

格式class类名 implements 接口名{} 比如:class player implement study

接口的子类要么是抽象的 要么重写接口中的所有抽象方法.

11:接口的成员特点?

答:成员变量:只能是常量.默认修饰符 public static final

构造方法:没有,因为接口主要是扩展功能的,而没有具体存在

成员方法:只能是抽象的方法 默认修饰符 public abstract

12:接口的练习

汪星人数数

13:抽象类和接口的区别?

答:1.Java接口和Java抽象类最大的一个区别，就在于Java抽象类可以提供某些方法的部分实现，而Java接口不可以（就是interface中只能定义方法，而不能有方法的实现，而在abstract class中则可以既有方法的具体实现，又有没有具体实现的抽象方法）2.抽象类是但继承,而接口是多实现.

14:案例:

猫狗案例,加入跳高的额外功能

猫狗分析:

小结

面向对象思想

概述:基于面向过程. 就是你找一个对象来完成一件事,这个对象包含了完成事情的过程.

类与对象

类: 对事物的描述 -- 虚

对象: 该事物的实体,实例 -- 实

关系: 定义类,使用对象.

类是对象的描述,对象是类实体.

定义类

格式:

class 类名 {

}

成员变量: 事物的属性 --天生的 --通常叫属性

构造方法: 初始化数据 new 类(); --通常叫构造

成员方法: 事物的行为 --后天的 --通常叫方法

面向对象的三大特征

封装

步骤:1.使用private修饰成员(通常修饰属性),隐藏成员

2.提供公共的访问方式 (get/set)

private:

作用:隐藏属性,不让外界直接访问

特点:只能本类访问

this: 当局部变量隐藏成员变量时使用this

作用:指代当前(本类)对象,通常修饰成员变量

static:

特点:静态.

修饰的成员变量,值被所有对象共享.

修饰的成员方法,直接类名调用.

继承

概述:子类继承父类,

特点:1.父类成员子类可以直接使用

2.类与类形成了关系,从而形成体系

3.多态的前提

注意事项:

1.父类私有的子类不能访问

2.构造方法不能用

3.不能随便继承

4.类与类是 "is a" 的关系,可以使用继承

super:表示父类存储空间的标识(理解为父类引用)

成员关系

成员变量(同名):使用子类

想要使用父类super.成员变量

构造方法:不能继承,但是子类会访问父类构造super()

加载顺序:创建子类时,先访问父类的构造

注意事项:

1.super(参数),访问父类的有参.

2.位置必须在第一行

成员方法(同名):使用子类

重写概述:父类和子类方法声明一模一样(返回值类型,方法名,参数列表)

注意事项:

私有:不能重写

权限:子类的权限不能更低

静态方法:必须使用静态重写.

面试题:

重写与重载的区别:

override: 父类和子类方法声明一模一样(返回值类型,方法名,参数列表)

overload: 同一类中,方法名一样,参数列表不同,与返回值类型无关

final: 最终

概述: 修饰类 成员变量,方法

特点:被修饰的东西不能被更改

类: 不能继承

变量: 只能赋值一次

方法: 不能重写

多态:

概述:一种事物多种形态(H2o , 动物 ,水果....)

前提:

1.子类继承父类,或者实现接口 (必须二选一)

2.方法重写(非必须)

3.父类引用指向子类对象(最必须)

Fu f = new Zi();

成员关系:

成员变量:编译看左边,运行看左边

构造方法:编译看左边,运行看左边

成员方法:编译看左边,运行看右边 *****

静态方法:编译看左边,运行看左边

子类特有的方法:

向上转型:从子类转向父类

格式: Fu f = new Zi();

向下转型:从父类转向子类

格式 : Zi z = (Zi)f;

注意: 参数传递为类,抽象类,接口 --案例练习 (钢铁侠,榨汁机,发牌机)

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

抽象类

概述:无法具体描述的类,通常定义父类为抽象类

特点:

1.格式:abstract class 类名{

}

2.类中可以有抽象方法,和非抽象

abstract 返回值类型 show();

3.有构造方法,但是不能new

4.想new抽象类,只能ne它的子类

5.子类: 要么是抽象的

要么必须重写抽象方法 ***

成员特点:

a:成员变量：既可以是变量，也可以是常量。

b:构造方法：有。

用于子类访问父类数据的初始化。

c:成员方法：既可以是抽象的，也可以是非抽象的。

面试题: abstract 不能和哪些关键字共存?

private 冲突 -- 对子类隐藏,而 abstract 必须让子类重写

final 冲突 -- 不能被重写,矛盾

static 无意义-- 类名调用,没有方法体,无意义

接口

概述:实现类的扩展功能

本质:定义的规则

特点:

1.格式: interface 接口名{

}

使用: class 子类 implements 接口名{ // 可以实现多个接口

//重写所有的抽象方法

}

2.成员变量: 只能是常量

3.成员方法: 只能是抽象

4.构造方法: 无

5.实例化: new 子类();

6.子类要求:重写所有的抽象方法

类与类,类与接口,接口与接口关系--看图

内部类

概述: 类里面的类 (人里面的心脏)

成员内部类:

格式:

class Outer{

class Inner{

}

}

注意:如果private 修饰 内部类,那么就不能直接创建,提供公共的访问方式.(封装的思想 )

局部内部类:

格式:

class Outer{

show(){

局部变量必须final;

class Inner {

}

}

}

问题:只能访问被final修饰的局部变量吗?

肯定的.局部变量和内部类的生命周期不同,所以使用final把局部变量变成常量.

匿名内部类:

前提:有一个接口或者类

本质: *匿名对象*-- 实现了接口,或者继承了类的匿名子类的对象

new 接口(){

抽象方法

};

代码块:

静态:执行一次,类加载的时候

static {

}

构造:执行多次,调用构造方法

局部:及时回收变量,提高运行效率

权限修饰符:

本类 同包不同包子类
不同包其他类

private
*

default
* *

protected
* * *

public
* * **

常用 public 修饰 类 和方法

和 private 修饰 成员变量

(二)相关代码实现

多态

/*

多态: 一种事物的多种形态

H2o

固态:冰,雪,霜,雹子

液态:水,雾,水蒸汽

气态:水蒸气

动物:

天上飞的:鸟

地上跑的:猫,狗

水里游的:鱼,海豚

1.满足继承关系

2.方法的重写.(如果不重写,就失去了多态的意义)

3.父类引用指向子类对象

成员变量

编译看左边,运行看左边.

成员方法

编译看左边,运行看右边

构造方法

编译看左边,运行看左边.

静态方法

编译看左边,运行看左边.

*/

class AnimalTest{

public static void main(String[] args){

Animal aa = new Animal();

Cat c = new Cat();

Animal a = new Cat(); //多态

a.sleep(); // 子类方法

System.out.println(a.leg);

a.eat();

}

}

class Animal {

//成员变量

int leg =4;

Animal(){}

public void sleep(){

System.out.println("晚上睡觉 ");

}

public static void eat(){

System.out.println("吃好吃的,饱饱的");

}

}

class Cat extends Animal{

//成员变量

int leg =3;

Cat(){}

//成员方法

public void sleep(){

System.out.println("白天想睡就睡");

}

public static void eat(){

System.out.println("吃鱼,不吐刺儿");

}

}

/*

B:看下面程序是否有问题，如果没有，说出结果

*/

class A {

public void show() {

show2();

}

public void show2() {

System.out.println("我");

}

}

class B extends A {

public void show2() {

System.out.println("爱");

}

}

class C extends B {

public void show() {

super.show();

}

public void show2() {

System.out.println("你");

}

}

public class DuoTaiTest4 {

public static void main(String[] args) {

A a = new B();

a.show();

B b = new C();

b.show();

}

}

抽象类

/*

定义抽象类

格式 :

abstract class 类名{}

举例 :

抽象类中的 方法

抽象方法 abstract void eat();

没有方法体,没有{},以; 结尾.

非抽象方法

void sleep(){

syso ....

}

抽象类子类:

1.非抽象类,但是必须重写父类的抽象方法

2.抽象类,无须管抽象方法,但是子类不能new了

抽象类中,有构造方法,但是有不能new,那么构造方法干嘛的呢?

给子类用的!!!

抽象类,一样可以使用多态来创建子类对象 .

总结: 一般来说,会把父类定义为抽象的类.测试的时候,可以通过多态,来实现子类功能.

抽象类 接口

成员变量 变量,常量

构造方法 有

成员方法 抽象,非抽象

*/

class AnimalTest{

public static void main(String[] args){

//Cat c = new Cat(); // 抽象的,无法创建对象

//c.eat();

//Animal a = new Animal();

//多态

Animal a = new Cat();

a.eat();

System.out.println(a.num);

System.out.println(a.num2);

}

}

abstract class Animal{

int num =10;

final int num2 = 20;

Animal(){}

//eat

public abstract void eat();

//sleep

public void sleep(){

System.out.println("合眼就睡");

}

}

class Cat extends Animal{

Cat(){

super();

}

//eat

public void eat(){

System.out.println("用爪子抓鱼,用舌头添鱼肉,不吐刺儿..喵喵儿~~");

}

//public abstract void eat();

//sleep

public void sleep(){

System.out.println("合眼就睡,白天,想睡就睡");

}

}

接口

/*

接口: 本质就是一种规则

作用: 就是扩展类功能

格式:

interface 接口名{}

相当于定义了规则

接口中可以写方法,但是必须是抽象的.

使用:

class 类名 implements 接口名{}

相当于给类扩展了接口的功能,需要重写接口的所有抽象方法

注意:

1.接口是不能实例化

创建实现了接口的类的对象,该对象也叫做这个接口的子类

2.类可以实现多个接口

抽象类 接口

成员变量 变量/常量
常量

构造方法 有没有

成员方法 抽象/非抽象抽象

*/

class {

public static void main(String[] args){

System.out.println();

}

}