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

                         黑马程序员 

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

------- android培训、java培训、期待与您交流！----------

(一)知识点概述

多态

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();
}
}

  <--  多态