黑马程序员----java面向对象03（接口、多态）

----------------------
ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

一.接口概述

* 接口概述：

* 接口的成员修饰都是固定的

* 属性：public static final

* 方法：public abstract

*

*

* 1、接口与接口之间可以多继承，因为没有方法体，不冲突

* 2、一个类可以实现多个接口

* 3、一个类可以继承另一个类同时又实现多个接口，因为没有方法体，不冲突

* */

代码示例

public class Interface {
public static void main(String[] args) {
ImpTnter it = new ImpTnter();
System.out.println(it.NUM);   //对象调用
System.out.println(ImpTnter.NUM);   //类名调用
System.out.println(Inter.NUM);   //接口名调用
}
}

//interface 接口名
interface Inter{
public static final int NUM=3;
public abstract void show();
}

class ImpTnter implements Inter{
public void show(){      //注意public权限
System.out.println("。。。");
}
}

interface A{

}

interface B extends A{

}

interface C extends A,B{    //例1

}

class A_ implements A,B{

}

class B_ extends A_ implements A,B,C{    //例3

}

二.模板方法（获取一段程序运行的时间）

* 模板方法

* 需求：获取一段程序运行的时间

* 实现：程序运行前的时间减去运行后的时间差即可

代码示例：

public class Template_Method {
public static void main(String[] args) {
GetTime1 gt1 = new GetTime1();
gt1.time();    //此时调用的就是已经本类中已经复写过的方法
}
}

abstract class GetTime{
//打印出时间差的功能
final void time(){    //final修饰后，此方法不能被复写
long start = System.currentTimeMillis();   //运行前的时间
method();
long end = System.currentTimeMillis();   //运行后的时间
System.out.println("程序运行的时间为："+(end-start));
}
//程序运行过程
abstract void method();  //不需要明确功能内容，所以抽象出功能声明即可
}

//继承了GetTime类，复写了method方法
class GetTime1 extends GetTime {
void method(){
for(int i = 0;i<6000;i++){
System.out.println("i");
}
}
}

三.多态概述

* 多态的概念：事物的多种体现形式

*

* 例如：

* 猫 a = new 猫();

* 猫也是属于动物

* 动物 a = new 猫();

*

* 思路：

* 定义了一个动物类，此类拥有eat方法，然后猫类、狗类等等继承了动物类

* 此时如果需要调用猫类吃鱼的方法，必须创建猫类对象Cat c= new Cat();狗类似

* 如果有很多猫，就需要多次调用eat方法，这样代码重复使用了，所以把eat方法封装起来

* 如果由很多动物，就需要定义若干个show方法，这样代码又重复使用了，所以把show方法的参数类型改成Animal

*

*

* 1、多态的体现

* 父类的引用指向自己的子类对象;父类的引用也可以接收自己的子类对象

* 2、多态的前提

* 父类和子类之间存在关系，要么继承，要么实现

* 3、多态的好处

* 提高了代码的扩展性，这样以后有新动物产生了直接调用show方法就可以吃东西

* 4、多态的弊端

* 只能使用父类的引用访问父类存在的成员，而父类中没有定义的就不能够这样访问

* 5、多态的应用

* */

代码示例：

public class DuoTai_Demo {
public static void main(String[] args) {
//		Cat c = new Cat();
//		c.eat();
//
Animal a = new Cat();   //例1，父类的引用指向自己的子类对象

//		Cat c1 = new Cat();
//		c1.eat();
show(new Cat());
show(new Cat());
show(new Dog());
}
public static void show(Animal a){
a.eat();
}
}

/*
//动物类
abstract class Animal{
public abstract void eat();
}

//猫类
class Cat extends Animal{
public void eat(){
System.out.println("吃鱼");
}
void shangshu(){
System.out.println("上树");
}
}

//狗类
class Dog extends Animal{
public void eat(){
System.out.println("啃骨头");
}
void kanjia(){
System.out.println("看家");
}
}
*/

四.多态中非静态成员函数的特点

*编译时期，是参阅的引用类型变量所属的类是否有此函数，如果由，编译通过，反之编译失败

*运行时期，是参阅的对象所属的函数是否有此函数，并运行此函数

*

*多态中静态成员函数的特点

*编译时期和运行时期都参阅的引用类型变量所属的类是否有此函数，并运行此函数

*

*多态中成员变量的特点（非静态和静态一样）

*编译时期编译时期和运行时期都参阅的引用类型变量所属的类是否有此变量，并调用此变量

*

**/

代码示例：

public class DuoTai_function {
public static void main(String[] args) {
Fu f = new Zi();
f.show1();   //编译时父类有，运行时子类也有，所以结果是子类的
f.show2();   //编译时父类有，因为继承，运行时子类也有，所以结果是子类的
//f.show3();   //编译时父类没有，编译不通过
}
}

class Fu{
void show1(){
System.out.println("Fu show 1");
}
void show2(){
System.out.println("Fu show 2");
}
}

class Zi extends Fu{
void show1(){
System.out.println("Zi show 1");
}
void show3(){
System.out.println("Zi show 3");
}
}

六.转型

* 思路：

* 如果想要使用子类特有的方法时，该怎么办呢？

* 1、因为是父类的引用指向了子类的对象，所以把父类的引用强制转换成子类类型

* 2、然后用用此引用去调用子类特有的方法

* 这样的话出现了一个问题，如果传入的不是猫，是狗，就会出现错误

* 所以要加以判断

*

*

* 注意：转换的是父类的引用， 而父类的对象是不能够被转换成子类类型的

* ！！！多态自始至终都是子类对象在做着变化

* */

代码示例：

public class DuoTai_zhuanxing {
public static void main(String[] args) {
/*
* 如果想要使用子类特有属性时，该怎么办？
* 解决办法：把父类的引用强制转化为子类类型
* */
//		Animal a = new Cat(); //父类的引用指向了子类对象;向上转型
//		a.eat();
//		Cat c = (Cat)a;   // 类似：int a ; byte b = (byte) a;
//		c.shangshu();

show(new Cat());
show(new Dog());

}
public static void show(Animal a){   //向上转型
a.eat();
if(a instanceof Cat){    //判断a的引用所指向的类型是不是Cat
Cat c = (Cat) a;    //向下转型
c.shangshu();
}else if(a instanceof Dog){    //判断a的引用所指向的类型是不是DOg
Dog c = (Dog) a;
c.kanjia();
}
}
}

//动物类
abstract class Animal{
public abstract void eat();
}

//猫类
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
void shangshu(){
System.out.println("猫上树");
}
}

//狗类
class Dog extends Animal{
public void eat(){
System.out.println("狗啃骨头");
}
void kanjia(){
System.out.println("狗看家");
}
}

七.电脑主板运行示例

public class DuoTai_zhuban {
public static void main(String[] args) {
ZhuBan zb = new ZhuBan();
zb.open();
zb.usePCI(new Wk());
zb.usePCI(new Sk());
}
}

class ZhuBan{
public void open(){
System.out.println("zhuban open");
}
public void usePCI(PCI p){
p.open();
p.end();
}
}

//PCT规范
interface PCI{
public abstract void open();
public abstract void end();
}

//网卡
class Wk implements PCI{
public void open(){
System.out.println("wangka open");
}
public void end(){
System.out.println("wangka end");
}
}

//声卡
class Sk implements PCI{
public void open(){
System.out.println("shengka open");
}
public void end(){
System.out.println("shengka end");
}
}

八.Object

/*

* 任何类的父类都直接或间接为Object

* */

public class Object_equals {
public static void main(String[] args) {
Demo d1 = new Demo(3);
Demo d2 = new Demo(4);

//	Person p = new Person();
//	System.out.println(d1.equals(p));   //如果把p传入进去

//System.out.println(d1.equals(d2));
//System.out.println(d1.compare(d2));
System.out.println(d1.equals(d2));     //相当于：Object obj = d2;
}
}

class Demo{     //extends Object
//	public boolean compare(Object obj){
//		return this.equals(obj);
//	}
private int num;
Demo(int num){
this.num = num;
}
//复写Object类中的equals方法
public boolean equals(Object obj){   //Object obj = new Demo();
//所以要加上判断
if(obj instanceof Demo){
Demo d = (Demo)obj;    //向上转型,把父类的引用转为子类类型
return this.num == d.num;    //因为父类中没有num属性，所以不能直接访问，必须向上转型
}else{
return false;   //如果对象不同型，比较值绝对不同
}
}
}

class Person{

}

----------------------
ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------详细请查看：http://edu.csdn.net