面向对象之继承/多态/抽象/接口/内部类

面向对象

1、代码块：用{}括起来的代码,统称为代码块;

根据其位置以及声明不同:分为以下:

  局部代码块: 在main()里面,给变量限定它的生命周期
  构造代码块:在一个类中的成员位置中,用{}括起来,

  作用:可以将多个构造方法中的相同的代码放到构造代码块中,对对象进行初始化.

  在每次执行构造方法之前,先执行构造代码块.

  静态代码块:在一个类的成员位置,也是用{}包起来,但是他被static修饰
  作用:一般情况 它的作用给类进行初始化

面试题:
   构造代码块,构造方法,静态代码的优先级?
   静态代码块>构造代码块>构造方法
   静态代码:只能执行一次
    构造代码块在每次执行构造方法之前都会被执行.

2、final关键字可以干什么?有什么特点?

  final:表示最终,终态(不能被更改的)
  (1)它可以修饰 类,那么该类不能继承
  (2)它可以修饰成员方法,成员方法不能被重写
  (3)它可以修饰变量,此时这个变量是一个常量
  final不仅可以修饰基本数据类型,还可以引用类型
  如果final修饰的是一个基本数据类型:基本数据类型的值不能再改变了...
  如果final习俗的是一个引用类型数据:引用类型的地址值不能再改变了,但是堆内存中的成员变量的值可以变得
  final的初始化时机:
  1) 被final只能被赋值一次(final int a = 10 )
  final int a ;

  //在使用之前进行初始化,赋值(在构造方法之前赋值) (非静态的...)

3、继承:将多个类抽取位一个独立的类,让独立的类和多个类产生继承关系

  关键字:extends
  格式:
  class 子类名 extends 父类名{
  ...
}
  继承的好处:
  1)提供了代码复用性,解决了代码的臃肿
  2)它是多态的前提(多态的前提是必须有继承关系)
  
  继承的特点:

  1）子类继承父类,是继承了父类所有的东西(成员变量,成员方法,包括私有),但是子类不能使用私有的东西,只能通 2）过父类的公共的访问间接的让子类访问它.

3）继承的另外一个特点:在Java中,继承只支持单继承,不支持多继承(子类名 extends 父类名1,父类名2,...)
  但是,Java是可以支持多层继承...
 * 类和类之间的关系:继承关系
 * 类和接口之间的关系:实现关系

继承中的注意事项:
  1)构造方法不能被继承,但是通过super关键字去访问

  2)私有的可以间接的去访问

3）不要随意使用继承，如果A是B的一种或者B是A的一种,这个可以使用继承!（包含种类关系）

Java开发设计原则:低耦合,高内聚
  耦合:类和类之间的关系 ,尽量降低耦合性
  内聚:指的是做一件事情能力(尽量使用一个类完成的事情不要多个类去完成..)
  在继承中,成员变量的名称问题：
  当前子类继承父类的时候,子类和父类中的成员变量名称不一致的情况,非常简单,分别输出就可以了;
  当子类和父类中的成员变量名称一致的情况:
  1)先到子类的局部位置找,如果找到了,就输出
  2)没有找到,到子类的成员位置找,有就输出,
  3)在类的成员位置还没有找到,直接父类的成员位置找,有就输出

  4)如果还没有,就保存了,不存在这个变量

关于继承的用法:
  父类中被private修饰的,是可以继承,但是只能间接的去访问私有的..

  父类被private修饰 成员属性,子类不不能直接访问的

问题盲区：子类继承父类,都会默认的访问父类的无参构造方法，如果父类的无参构造没有提供?怎么办?
  肯定报错;
  如何解决:
  1)可以将父类的无参构造提供出来
  2)可以super关键字去访问父类的带参构造...
  3)还可以在子类中通过this(),访问本类中的有参构造,间接的去访问父类带参构造

  子类的构造方法必须有一个(有参构造/无参构造),让父类进行初始化!

代码展示：

class Father2{
//	public  Father2() {
//		System.out.println("父类 无参构造...");
//	}
	public Father2(String name) {
		System.out.println("父类的有参构造....");
	}
}
//子类继承父类
class Son2 extends Father2{
	public Son2() {
//		super("随便给") ; //访问父类的有参构造
	        super("随便给") ;
		System.out.println("子类的无参构造...");
	}
	
	public Son2(String name) {
//		super("随便给") ;//访问父类的有参构造
		this() ;
		System.out.println("子类的有参构造..");
	}
}
public class ExtendsDemo4 {
	
	public static void main(String[] args) {
		Son2 s = new Son2() ;
	}
}

继承中成员方法的问题：
  子类继承父类,访问成员方法名不一致的情况,分别调用!
   当子类中的成员方名和父类中的成员方法名一致的情况:
  1)现在子类的成员位置找,如果有就调用
   2)如果没有找到,在父类的成员位置找,有就调用

4、多态是什么，前提是什么?

  多态:在同一个时刻,体现出来的不同状态;
  多态的前提:
  1)必须有继承关系
  子类继承父类,存在一些特点
  2)必须有方法重写

  子类继承父类,方法重写的目的,举例:动物吃的方法,每一个具体动物吃的东西不一样,所有必须要方法覆盖

  3)就是必须有父类的引用指向子类对象 (向上转型)
  父类名  fu = new  子类名() ;
    
  通过父类对象的创建是通过子类在堆内存新建了了一个对象,由于子类又继承了父类,
  父类的引用(初始化)是通过子类新建对象进行的..
5:多态中成员访问的特点?
  1)成员变量: 编译看左,运行看左...
  2)成员方法(非静态): 编译看左,运行看右(存在方法重写)
  3)构造方法:构造方法(无论子类,还是父类),都是对对象进行初始化
  4)静态成员方法:     编译看左,运行看左(静态跟类有关系,算不上方法重写)
  

Father2 f  = new Son2() ;
f.show();//编译看左边,运行看右边

6:多态的好处及弊端？如何解决多态的弊端？
 多态的好处:
  可以提供代码的复用性:继承保证
  可以提高的代码的扩展性:由多态保证...  (父类的引用指向子类对象)
 多态的弊端:
  父类引用指向子类对象,
  通过父类的引用调用子类特有功能,不能调用....
 父类的引用指向子类对象             (向上转型)
 将父类的引用强制转换子类的引用 (向下转型)

 异常：将父类的引用强制转换子类的引用  ,向下转型使用不当,会出现一个异常:属于运行时期异常:ClassCastException

Father3 f  = new Son3() ;//向上转型
		f.show();
		
		Son3 s = (Son3) f ; //前提是必须有父类的引用
		//将父类的引用强制转换子类的引用  ,向下转型使用不当,会出现一个异常:属于运行时期异常:ClassCastException
		s.method()；

7:什么是向上转型？什么是向下转型？
 向上转型：父类的引用指向子类对象

 向下转型：将父类的引用强制转换子类的引用

例题：

/**
 * 看程序,写结果
 * 	继承:继承父类中所有的东西,除过构造方法
 * 		继承的初始化:分层初始化
 * @liuxiaofan
 */
class A {
	public void show() {
		show2();
	}
	public void show2() {
		System.out.println("我");
	}
}
class B extends A {
	/**
	 *解决问题的关键
	 * public void show(){
	 * 	show2() ;
	 * }
	 */
	public void show2() {
		System.out.println("爱"); //爱
	}
}
class C extends B {
	public void show() {
		super.show();
	}
	public void show2() {
		System.out.println("你");// 你
	}
}
public class DuoTaiTest {
	public static void main(String[] args) {
		A a = new B();
		a.show();		
		B b = new C();
		b.show();
	}
}

//程序运行结果：爱你

  分析：首先运行主函数吗，因为A a = new B( );因为B又继承于A，所以先执行A类，再执行B类，然后执行show函数，B中省略继承于A类的show（）函数为解题关键.

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

  抽象类的概念:针对一个事物,比如:动物类---->总体概括,之前定一个具体的动物---->必须给他的某个功能只是声明即可),

  只有,猫或者狗等等这些才是具体事物

 Java中,如果一个类中有一个方法声明(抽象方法)抽象功能,那么这个类定义为抽象类
 关键字:abstract  抽象的意思
 抽象类的特点:抽象类不能直接 实例化!(不能创建对象) 接口也不能实例化
  关于抽象类:
  1)如果一个类中有抽象方法,那么这个类是一定是一个抽象类
  2)抽象类必须有抽象方法吗? 抽象类中不一定都是抽象方法
  抽象类的子类
  1)如果子类是抽象类,没有意义,因为都不能实例化,对象如何创建
  2)子类具体类,那么子类必须实现父类中的抽象功能.
9:抽象类成员特点:
  成员变量:可以是变量,也是一个常量
  构造方法:可以有无参,可以有有参,作用:给对象进行初始化的.
  成员方法:可以有抽象方法,还可以有非抽象方法...

10:抽象类的小问题
A:一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
        可以
B:abstract不能和哪些关键字共存
          abstract 和private
  abstract 和final
  abstract和static 
11:接口的概述及其特点?
   接口:体现的是事务的扩展性功能(额外动作,后天经过学习等等)
   接口格式(标识符:类,接口:见名知意)
  interface  接口名{
  //抽象功能
  public abstract void jump() ;

  }

//public void show() {
			}
	//接口中的方法不能有方法体,只能是抽象方法
	public abstract void jump() ;
	public abstract void speak() ;

  接口的特点:不能实例化
  接口的子实现类:实现类 (具体的实现类)
  class 类名+impl implements 接口名{
  }
  接口的子类如果是抽象类:没有意义,不能实例化
  接口多态(最多)
  抽象类多态(比较多)
  具体对象的创建(经常会使用)
12:接口的成员特点?
   接口成员的特点:
  成员变量:是一个常量,不能更改,并且默认的修饰符
  public static final:
  构造方法:接口不存在构造方法
  成员方法:都是抽象方法
  默认的修饰符:public abstract

13:抽象类和接口的区别?
A) 成员的区别
成员变量:
抽象类:既可以常量,也可以是变量
接口:只能是常量,默认的修饰符:public static final
构造方法:
抽象类:有构造方法,无参/有参 (给对象进行初始化的)
接口:没有构造方法
成员方法:
抽象类:可以有抽象方法,也可以有非抽象方法
接口:只能是抽象方法 :默认的修饰符:public abstract

B)类与类/类与接口关系的区别
类与类之间的关系:
继承关系,只支持单继承,不支持多继承,但是可以多层继承
类与接口的关系:
实现关系,一个类继承另一个类的同时,还可以实现多个接口...
接口与接口的关系:
是一种继承关系,既可以单继承,也可以多继承...

接口1 extends 接口2,接口3...

C)设计原则的 区别
1)抽象类: 是有继承关系---->体现的是一种"is a"的关系   (A是B的一种或者B是A的一种)

2)接口:类和接口:实现关系--->体现的是一种" like a"的关系(扩展功能)  :跳高猫 像猫

      14：方法重写和方法重载的区别?

Overload：给多个方法起同一个名字,还不报错---->方法重载 
   方法重载: 指的是方法名相同,参数不同,返回值没有关系
参数不同:
1)参数个数不同
2)参数类型不同

Override：由于子类继承父类的时候,提供一摸一样的方法声明,然后会将父类该方法覆盖掉(重写,复写)

      15:内部类：

       关于成员内部类的修饰符:
  private: 作用:保证数据的安全性!
   static修饰:可以把静态内部类看成是外部类的成员.

  特点:静态成员内部类访问外部类的数据,该数据必须static修饰

       内部类的分类:
   成员内部类:在外部类的成员位置
   局部内部类:在外部类的局部位置

       成员内部类:
   可以直接外部类的成员,包括私有 
   外部类要访问内部类(非静态的内部类)的成员方法:
   格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象

//格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象

/对于静态的成员内部类的访问格式
//		外部类名.内部类名 对象名 = new 外部类名.内部类名() ; //把静态的成员内部类看成了外部类的成员