黑马程序员--java基础--面对对象2

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

 

目录：1、抽象类 2、接口 3、内部类 4.静态内部类 5 匿名内部类

1、抽象类

抽象类的特点：
 1 抽象方法一定在抽象类中
 2 抽象方法和抽象类都必须被abstract关键字修饰
 3 抽象类不可以用new创建对象，因为调用抽象方法没意义，抽象方法没有方法体
 4 抽象类中的抽象方法要被使用，必须子类继承父类，子类复写所有的抽象方法后，建立子类对象调用
   如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类！
   抽象类强制子类覆盖所有父类方法

abstract class Student //如果是抽象类要用acstract关键字标识
{
 abstract void study();//抽取了功能定义的方法,没有方法体.要标明一下,就是abstract(抽象)
 
}
//基础班学生类
class BaseStudent extends Student
{
 void study()
 {
  System.out.println("Study");
 }
}
//高级班学生类
class AdvStudent  extends Students
{
 void study()
 {
  System.out.println("Study"); 
 }
}

 

抽象关键字abstract不能和哪些关键字组合
 1 final
 2 static(静态可以被类名调用,调用抽象函数没什么意义)
 3 private(写private不能被覆盖)

2、接口

interface {}
 接口中的成员修饰符是固定的
 成员常量：public static final
 成员函数：public abstract
 接口中的成员都是public的
 接口不继承object，接口不能建立对象，没有构造函数！
 继承里有方法体，所以不能实现多继承，会有安全隐患接口里没有方法体，所以没有安全隐患，一个类可以实现多个接口！

使用接口：
 接口不能实例化对象
 可以定义一个子类，用一个更贴切的关键字是implements(实现)
 子类实现一个接口，覆盖接口中全部抽象方法
 建立子类对象
 子类可以继承一个类，同时可以实现多个接口
 子类只能继承一个类，但是可以同时实现多个接口，覆盖掉接口中的全部抽象方法！

 接口与接口之间是继承关系,而且可以多继承!

//接口的格式
interface Inter
{
 //接口里面的成员全抽象
 public static final int NUM();//num为全局最终常量
 public abstract void show();
}
class Test implements Inter
{
 public void show(){};//对接口进行覆盖,权限要大于等于接口权限
}
//覆盖后就可以建立对象了
class InterfaceDemo
{
 public static void main(String[] args)
 {
  Test t = new Test();
  System.out.println(t.NUM);//对象调用成员
  System.out.println(Test.NUM);//类调用成员,静态
  System.out.println(Inter.NUM);//接口名调用成员
 }
}

实例练习：

分析烟民领域：
学生  抽烟 有的不抽
老师  抽烟 有的不抽

可以将抽烟功能，定义在一个接口中
如实你是抽烟的学生，实现抽烟接口
如果你不抽烟的学生，就不要实现抽烟接口
但是你抽烟不抽烟，你总是学生，还要学习.

class Student
{
 abstract void study();
 void sleep();
 {
  System.out.println("sleep");
 }

 abstract void smoke()
 {
  System.out.println("smoking");
 }
}
//建立一个接口
interface Smoking
{
 void smoke();
}
//zhangsan继承了Student类,并扩展了Smoing类
//这句话的意思是,zhangsan像烟民
class ZhanSan extends Student implements Smoking
{
 void study(){}
 public void smoke(){}
}
*/

abstract class Sporter
{
 abstract void play();//抽象方法的缩写,因为play什么不确定
}
interface Study
{

}
class wangwu extends Sport implements Study
{
}

三 多态：

通过以下特点来理解多态
 1. 多态的体现：父类的引用指向了自己的子类对象,父类的引用也可以接受自己的子类对象
 2. 多态的前提：必须是类与类之间有关系,要么继承,要么实现,通常还有一个前提,存在覆盖
 3. 多态的好处：多态的出现大大提高了程序的扩展性
 4. 多态的弊端：提高了扩展性，只能调用子父类中的公共方法，不能调用子类中的特有方法!但是只能使用父类的引用访问父类中的成员，不能预先的使用子类，因为子类那时候还不在呢！

class DuoTaiDemo
{
 public static void main(String[] args)
 {
  
  Animal a = new Cat();//猫是子类型,Animal为父类型,类型提升,这个类型提升也被称为向上转型
  a.eat();

    //如果想要调用猫的特有方式时,如何操作?
 //强制将父类的引用,转成子类类型,向下转型
  Cat c = (Cat)a;
  c.catchMouse();
 //千万不要出现这样的操作,就是将父类对象转成子类类型
 // Animal a = new Animal();
 // Cat c = (Cat)a;

 
 编译时期：参考引用型变量所在的类中是否定义了静态变量，如果定义了编译成功，没定义编译失败
 运行时期：参考引用型变量，所在类中的结果

总结：
成员变量：不论是静态成员变量还是非静态成员变量，编译时期参考等号左边，运行时期参考等号左边
成员方法：静态成员方法编译时去参考等号左边，运行时期参考等号左边；

非静态成员方法：编译时期参考等号左边,运行时期看右边

简单点记
在多态中，除了非静态方法以外，编译看左边，运行看右边，其余全看左边

3 内部类

内部类的访问规则
1 内部类可以直接访问外部类中的成员,包括私有
2 外部类要访问内部类，必须建立内部类对象

要想访问内部类中的成员,当然要建立内部类的对象,然后调 用内部类中的方法
     外部类名称.内部类名称  对象名称 = new  外部类名称().new 内部类名称();

class Outer
{
 private int x = 3;//这三个x分别为,外部成员变量
 private class Inner//当内部类在外部类的成员位置上时,内部类可以被私有!!!(重要)
 {
  int x = 4;//内部类成员变量
  void function()
  { 
   int x = 6;//内部类局部变量
   System.out.println("inner:"+x);//内部类直接访问外部类的成员,当把x私有的时候,也有效,因为x在本类中
  //当想打印x = 3时,可以可以这样写:外部类名.this.变量名
  }
 }
 void mathod()
 {
  Inner in = new Inner();
  in.function();
 }
}
class InnerClassDemo
{
 public static void main(String)
 {
  Outer out = new Outer();
  out.method();
 }
}

/*
 上述程序执行顺序,当主函数进来,创建Outer对象,然后Out调用method方法,method方法中有Inner的对象
 然后再调用内部类总function方法.
*/

4静态内部类

当内部类在成员位置上,就可以被成员修饰符修饰
    比如，private:将内部类在外部类中进行封装
 还有static，内部类可以被静态修饰，内部类就具有静态的特性，当内部类被静态修饰后，就变成了静态内部类
 当内部类被静态修饰后，只能直接访问外部类中的静态成员，出现了访问局限

class Outer
 {
  private static int x = 3;

  static class Inner //静态内部类
  {
   void function()
   {
    System.out.println("inner:"+x);
   }
  }
 }
 class InnerDemo
 {
  public static void main(String[] args)
  {
   new Outer.Inner().function();//可以建立内部类对象,直接访问内部类 
  }
 }

5、匿名内部类

写匿名内部类的原因就是：简化书写，覆盖方法

  1 匿名内部类其实就是内部类的简写格式
  2 定义匿名内部类的前提：内部类必须继承一个类或者实现接口
 继承和实现的时候要复写类或者接口中的方法
  3 匿名内部类的格式
 当匿名内部类继承某个类时:：new 父类，覆盖接口方法。
   4 其实匿名内部类，就是一个匿名子类对象!但凡看到匿名内部类，那是一个子类对象，是把定义类和建立对象封装为一体的表现形式
      5 匿名内部类中，定义的方法最好不要超过3个

Class Outer{
 
//new父类 覆盖父类方法
//Inner是父类 里面有show（）方法
 new Inner(){
  void show（）{}
}}

 

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