黑马程序员——继承、多态、内部类和接口

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

一丶继承
1、让类与类之间产生了关系，有了这个关系才有了多态的特性。类与类之间有所属关系！

2、java只支持单继承，不支持多继承。多继承容易带来安全隐患：当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。

3、支持多层继承

4、super关键字：代表父类对象的引用；this代表本类对象的引用。super和this的使用几乎一致

。

5、当子类出现和父类一模一样的函数时，子类对象调用该函数，会运行子类函数的内容，这种情况是函数的另一个特性：重写（覆           盖

）

6、子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则便以失败。静态只能覆盖静态。

7.重载：只看同名函数的参数列表；重写：子父类方法要一模一样

二丶子父类中的构造函数

1、在对子类对象进行初始化时，父类的构造函数也会运行。是因为子类的构造函数默认第一行有一条隐式的语句:super();

       super();会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是:super();

2、当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数；

      当然子类的构造函数第一行也可以手动指定this语句来访问类中的构造函数。子类中至少有一个构造函数会访问父类中的构造函         数。

三丶抽象类

1、当多个类中出现相同功能，但是功能主题不同，这时可以进行向上抽取，这时，只抽取功能定义，而不抽取功能主体。

2、抽象类示例

/*
抽象类的特点：
1.抽象方法一定在抽象类中。
2.抽象方法和抽象类都必须用abstract关键字修饰。
3.抽象类中不可以用new创建对象，因为调用抽象方法没有意义。
4.抽象类中的抽象方法要被使用，必须由子类复写所有的抽象方法，建立子类对象调用。
如果子类只覆盖部分抽象方法，那么该子类还是一个抽象类。
5.抽象类和一般类没有太大的不同，该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。
这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体。通过抽象方法来表示。
抽象类中可以有非抽象方法。抽象类比一般类多了个抽象函数。抽象类不可以实例化。
6.抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
*/
abstract class Student
{
abstract void study();
//abstract void study1();
void sleep()
{
System.out.println("躺着");
}
}

class BaseStudent extends Student
{
void study()
{
System.out.println("base study");
}
//abstract void study1();如果这个类中没有复写study1那么BaseStudent类就成为了抽象类
void study1(){}//这样也是可行的，表示复写了study1方法
}

class AdvStudent extends Student
{
void study()
{
System.out.println("adv study");
}
}

class AbstractDemo
{
public static void main(String[] args)
{
new BaseStudent().study();//这样可行
}
}

3、抽象类的应用
/*
就发一个系统时需要对员工进行建模，员工包含3个属性：姓名、工号以及工资。经理也是员工，除了包含员工的属性外， 多了一个奖金属性
使用继承的思想设计出员工类和经理类，要求类中提供必要的方法进行属性访问。
思路：
1.员工类：name id pay
2.经理类：继承了员工类，并有自己的奖金。
*/
class Employee
{
private String name;
private String id;
private String pay;
Employee(String name,String idk,double pay)
{
this.name=name;
this.id=id;
this.pay=pay;
}
public abstract void Work();
}

class Manager extends Employee
{
private int bonus;
Manager(String name,String id,double pay,int bonus)
{
super(name,id,pay);
this.bonus=bonus;
}
public void Work()
{
System.out.println("manager work");
}
}

class Pro extends Employee
{
Pro(String name,String id,double pay)
{
super(name,id,pay);
}
public void Work()
{
System.out.println("pro work");
}
}
四丶多态

1、多态：某一类事物的多种存在形态。例如：“人”可以表现为：男人，女人；“动物”可以表现为：猫，狗......

2、多态的体现：父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象

3、多态的前提：必须是类与类之间有关系，要么继承，要么实现。还有一个前提：存在覆盖

4、多态的好处：多态的出现很大的提高了代码的复用性

5、多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类中的成员

6、多态的应用示例代码

/*
基础班学生：学习，睡觉。
高级班学生：学习，睡觉。
可以将这两类事物进行抽取。
*/
abstract class Student
{
public abstract void stduy();
public void sleep()
{
System.out.println("躺着睡");
}
}

class BaseStudent extends Student
{
public void study()
{
System.out.println("base study");
}
public void sleep()
{
System.out.println("坐着睡");
}
}

class AdvStudent extends Student
{
public void study()
{
System.out.println("adv study");
}
}

class DoStudent
{
public void doSome(Student stu)
{
stu.study();
stu.sleep();
}
}
class DuoTaiDemo
{
public static void mian(String[] args)
{
DoStudent ds=new DoStudent();
ds.doSome(new BaseStudent());
ds.doSome(new AdvStudent());
/*
BaseStudent bs=new BaseStudent();
bs.study();
bs.sleep
4000
();
AdvStudent as=new AdvStudent();
as.study();
as.sleep();
*/
}
/*
public void doSome(BaseStudent bs)
{

}
public void doSome(AdvStudent as)
{

}
*/
/*
public void doSome(Student stu)
{
stu.study();
stu.sleep();
}
*/
}
7、多态的使用注意事项

      ①在多态中成员函数（非静态）的特点：在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果           没有编译失败。

          在运行时期：参阅对象所属类中是否有调用的方法。

      ②简单总结就是：成员函数在多条调用时，编译看左边，运行看右边。

      ③在多态中成员变量的特点：无论编译和运行，都参考左边（引用型变量所属的类）

      ④在多态中静态成员函数的特点：无论编译和运行，都参考左边。
Animal a=new Cat();//类型提升，向上转型
/*
如果想要调用猫的特有方法时，应该将父类的应用强制转换成子类类型，向下转型。
*/
Cat c=(Cat)a;
c.catchMouse();
/*
千万不要出现下面的操作，将父类对象转换成子类类型
我们能转换的是父类应用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。
多态自始至终都是子类对象在做着变化
*/
Animal a=new Animal();
Cat c=(Cat)a;
//instanceof是用来判断两边的类型是否相同不能用“==”
public static void function(Animal a)
{
a.eat();
if(a instanceof Cat)
{
Cat c=(Cat)a;
c.catchMouse();
}
else if(a instanceof Dog)
{
Dog g=(Dog)a;
g.kanjia();
}
}
9.多态的扩展示例    
/*
需求：数据库的操作
数据是：用户信息
1.连接数据库:JDBC Hibernate
2.操作数据库
c create r read u update d delete
3.关闭数据库连接
*/

interface UserInfoDao
{
public void add(User user);
public void delete(User user);
}

class UserInfoByJDBC implements UserInfoDao
{
public void add(User user)
{
//JDBC连接数据库
//使用sql语句添加数据
//关闭连接
}
public void delete(User user)
{
//JDBC连接数据库
//使用sql语句删除数据
//关闭连接
}
}

class UserInfoByHibernate implements UserInfoDao
{
public void add(User user)
{
//Hibernate连接数据库
//使用sql语句添加数据
//关闭连接
}
public void delete(User user)
{
//Hibernate连接数据库
//使用sql语句删除数据
//关闭连接
}
}

class DBOperate
{
public static main(String[] args)
{
//UserInfoByJDBC ui=new UserInfoByJDBC();
//UserInfoByHibernate ui=new UserInfoByHibernate();
//UserInfoDao ui=new UserInfoByJDBC();
//UserInfoDao ui=new UserInfoByHibernate();
ui.add(user);
ui.delete(user);
}
}

五丶内部类

1、将一个类定义在另一个类的里面

2、内部类可以直接访问外部类中的成员，包括成员。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引       用，格式：外部类.this（Outer.this.x）

3、外部类要访问内部类，必须建立内部类对象。

4、当内部类定义在外部类的成员位置上，而且非私有，可以再外部其他类中直接建立内部类对象。

      格式为：外部类.内部类名 变量名=外部类对象.内部类对象；例如：Outer.Inner in=new Outer().new Inner();

5、当内部类在成员位置上，就可以被成员修饰符所修饰。比如：private；将内部类在外部类中进行封装。static：内部类就具备了         静态的特性，被修饰后，只能访问外部类中的静态成员变量。

6、在外部其他类中，直接访问静态内部类的非静态成员：new Outer.Inner().function();

      在外部其他类中，直接访问静态内部类的静态成员：Outer.Inner().function();

7、当内部类中定义了静态成员，该内部类必须是静态的

8、当描述事物时，事物的内容中还有事物，该事物用内部类来描述。因为内部事物在使用外部事物的内容。

9、内部类定义在局部时，不可以被成员修饰符修饰，可以直接访问外部类中的成员，因为持有外部类中的引用，但是不可以访问它       所在的局部中的变量，只能访问被final修饰的局部变量

六丶匿名内部类

1、匿名内部类其实就是内部类的简写格式，没有名字的内部类。 

2、定义匿名内部类的前提：内部类必须继承一个类或者实现接口。

 

3、匿名内部类的格式：new 父类或者接口(){定义子类的内容}

4、其实匿名内部类就是一个匿名子类对象，可以理解为带内容的对象。

5、匿名内部类中定义的方法最好不要超过三个。

5、示例代码

abstract class AbsDemo
{
abstract void show();
}

class Outer
{
int x=3;
/*
class Inner extends AbsDemo
{
void show()
{
System.out.println("show:"+x);
}
//类中特有的方法
void abc()
{
System.out.println("haha");
}
}
*/
public void function()
{
//new Inner().show();
new AbsDemo()
{
void show()
{
System.out.println("x=="+x);
}
void abc()
{
System.out.println("haha");
}
}.show();
/*
new AbsDemo()
{
void show()
{
System.out.println("x==="+x);
}
void abc()
{
System.out.println("haha");
}
}.abc();
*/
}
}

七丶接口
1、接口：可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的方式来表示。

      class用于定义类，interface用于定义接口，接口中成员必须是全抽象。

2、定义接口，格式特点：

     ①接口中常见定义：常量，抽象函数。

     ②接口中的成员都有固定修饰符：常量：public final;方法：public abstract  

3、接口中的成员都是public修饰的。

4、类与类之间有继承关系，类与接口之间是实现关系，通过：implements来实现 

5、接口不可创建对象，需要被子类实现，子类覆盖接口中的全部抽象方法，才可以实例化，否则子类是一个抽象类。

6、接口可以被类多实现。

7、一个类在继承一个类的同时还可以实现多个接口

8、示例代码

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

interface InterA
{
public abstract void method();
}

class Demo
{
public void function(){}
}
/*
多实现，必须覆盖两个接口的全部方法
*/
class Test extends Demo implements Inter,InterA
{
public void show(){}
public void method(){}
}

interface A
{
void methodA();
}
interface B //extends A
{
void methodB();
}
interface C extends B,A//接口与接口之间可以多继承
{
void methodC();
}

class D implements C
{
public void methodA(){}
public void methodC(){}
public void methodB(){}
}

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

                                                                      详细请查看：http://edu.csdn.net/heima