黑马程序员——黑马学习日志之七 抽象类，接口，内部类，包

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

黑马学习日志之七  抽象类，接口，内部类，包

1 抽象类

1.1抽象类和抽象方法

抽象就是从多个事物中将共性的，本质的内容抽取出来。

抽象类：使用abstract关键字修饰的类就是抽象类。

抽象方法：使用abstract关键字修饰。只有方法的定义，但是没有方法体的方法，该方法的   具体实现由子类完成，包含抽象方法的类需要定义为抽象类。

 例子：

abstract class Demo {

public abstract void live();

}

1.2 抽象类的特点
   （1）一个类如果有了抽象方法，那么这个类必须是抽象类。
   （2）抽象类里边可以没有抽象方法。
   （3）抽象类是不能够被实例化的，不能够创建对象的。
   （4）如果一个类继承抽象类，它要么重写抽象类中的所有抽象方法，要么本身也是抽象类。

1.3 抽象类的成员特点：
  成员变量：子类可以直接继承抽象类中的成员变量。  

  成员方法：抽象方法在子类中必须要被实现。普通方法可以被子类直接继承使用。

  构造方法：抽象类中有构造函数，子类创建对象的时候，调用父类构造函数，为父类中 的成员初始化。 

1.4 不可以和abstract共存的关键字：
    private私有的，外部直接无法访问。抽象方法是为了让子类重写 一旦加了private，子   类无法重写
   static抽象方法就可以可以通过类名调用，但是这样是没有意义的。
   final final修饰的方法不能被重写。所以它和abstract冲突。

2 接口

2.1 接口概念

2.1.1接口理解

接口可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。解决了java中只能单继承的问题。

接口中定义的方法默认是公有的抽象的，被public abstract修饰;接口中定义的变量默认为全局常量，使用public static final修饰  

使用abstract修饰的抽象方法在子类中必须实现，而接口在扩展当前类的新功能的时候使用。

定义接口使用interface，实现一个接口使用impentents。

2.1.2接口的特点：

接口是对外暴露规则；

接口是程序的功能扩展；

接口的出现降低了耦合性，使用原则低耦合高内聚；

接口不能直接创建对象，是抽象的，不能实例化；

接口可以用来多实现，类与接口之间是实现关系，可以继承一个类同时实现多个接口。

例子：

interface Person {

public abstract void work();

}

class CarWorker implements Person {

public void workt(){

System.out.println("造汽车");

}

}

class ITWorker implements Person {

public void work(){

System.out.println("敲代码");

}

}

2.2 接口成员特点：

构造函数：接口没有构造函数；

成员方法：只有抽象方法，默认的修饰符：public abstract;

成员变量：只有 final修饰的常量；默认的修饰符：public static final

2.3类、接口的关系

类与类之间的关系：继承关系，java中只支持单继承，不支持多继承，支持多层继承。

类与接口之间的关系：实现关系，java中支持单实现，也支持多实现。

接口与接口之间的关系：继承关系，java中的接口而言，支持单继承，也支持多继承。

注意：在一般情况下，java中只支持单继承，但是接口是一个特列，接口能实现多继承。

例子：

interface Inter1 {

public abstract void show1();

}

interface Inter2 {

public abstract void show2();

}

// 接口可以多继承

interface Inter extends Inter1, Inter2 {

}

abstract class Fu {

//抽象方法

public abstract void show();

//普通方法

public void method(){

System.out.println("Fu method");

}

}

class Zi extends Fu implements Inter1,Inter2 {

//重写父类中所有的抽象方法

public void show(){

System.out.println("Zi show");

}

//重写接口中的抽象方法

public void show1(){

System.out.println("Zi show1");

}

public void show2(){

System.out.println("Zi show2");

}

}

class InterfaceDemo3 {

public static void main(String[] args) {

Zi z = new Zi();

z.method();

z.show();

z.show1();

z.show2();

}

}

2.4接口与抽象类的区别

共性：都是从不同的类中将公共的内容抽取出来，不断抽取出来的抽象概念

区别：

(1)关键字：

接口：interface

抽象类：abstract

(2)关系：

接口：实现关系，可以多实现；

抽象类：继承关系只能单继承。

(3)成员的区别：

接口：

构造函数：没有

成员方法：抽象方法

成员变量：常量

抽象类：

构造函数：有。

成员方法；普通方法，抽象方法

成员变量：普通变量，常量

(4)什么时候使用抽象类，什么时候使用接口

接口：部分子类必须要做的操作，定义在接口中。

抽象类：所有子类都必须要做的操作，定义在抽象类中

3 内部类

3.1 内部类概念 

在类里面定义的类称之为内部类，内部类是外部类的一个成员。

例如：

class  A{

             class  B{

     }

 }

 3.2 内部类访问规则

内部类可以直接访问外部类中成员，包括私有。

外部类访问内部类要建立对象。

之所以内部类可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用：外部类名.this

例子：

class Demo {

private int num = 10; 

// 内部类

class InnerDemo{

System.out.println(num); // 内部类直接访问外部类

private int num2 = 20;

}

public void method(){

Test t = new Test(); //外部类访问内部类要建立对象

sop(num2);

}

3.3 成员内部类

   定义在类中，方法外。

外部类访问内部类格式： 外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

成员内部类用到的修饰符：

private：提高数据的安全性。内部类被私有private修饰的话，不可以访问。

static：静态内部类。

注意：面试中问类可以被private，static修饰吗？可以的 当内部类位于外部类的成   员变量的位置时才可以。

例子：

class Outer {

private int num = 10;

//成员内部类

class Inner {

int num = 20;

public void show(){

int num=30; 

System.out.println(num); //30

System.out.println(this.num);// 20 

System.out.println(Outer.this.num); //10

}

}

}

class InnerClassDemo2 {

public static void main(String[] args) {

//外部类名.内部类名 对象名 = new 外部类名().new 内部类名();

Outer.Inner oi = new Outer().new Inner();

oi.show();

}

}

3.4 静态内部类

就是在成员内部类的基础上加static关键字。

静态内部类访问原则：静态内部类只能访问外部类的静态成员。

外部类访问静态内部类的方法：外部类名.内部类名 对象名 = new 外部类名.内部类名();

    Outer.Inner  oi = new Outer.Inner();

    oi.innerShow();

外部类访问静态内部类的静态方法：Outer.Inner.innerShow();

内部类方法是静态的，内部类不是静态的，不能访问。因为内部类中定义了静态成员，内部类必须是静态的。

外部类的静态方法访问内部类时，内部类必须是静态的。

内部类私有并非静态 内部类方法是非静态 只能用外部类方法访问。

例子：

class Demo8 {
  public static void main(String[] args) {
    //1.内部类是静态的 内部类中方法非静态，可以用下面方法访问
    Outer.Inner oi = new Outer.Inner();
    oi.show();
    //2.内部类静态的内部类方法也是静态的，可以用下面方法访问
    Outer.Inner2.show2();*/
    //内部类私有并非静态，内部类方法是非静态，只能用外部类方法访问
    Outer o= new Outer();
    o.print();
  }
 }

class Outer {
   //内部类是静态的 方法非静态 
   static class Inner {
    public void show() {
     System.out.println("Hello World!");
    }
   }
   static class Inner2 {
    public static void show2() {
     System.out.println("Hello World!2");
    }
  }

   //不要在非静态的内部类中定义静态的方法
   /*class Inner3 {
    public static void show3() {
     System.out.println("Hello World!3");
    }   }*/
   //私有非静态内部类，非私有非静态内部类函数 
   private class Inner4{
    public  void show4() {
     System.out.println("Hello World!3");
    }
   }
   public void print() {
    new Inner4().show4();
   }
 }

3.5 局部内部类

在外部类成员方法中定义的内部类。

局部内部类特点：

局部内部类不能被定义为static。Static只修饰成员，不修饰局部。

局部内部类不能被成员修饰符修饰，用于修饰局部内部类的只有final和abstract。

方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。

可以直接访问外部类的成员，因为还持有外部类的引用。

3.6 匿名内部类

匿名内部类：没有名字的内部类，是内部类的简化写法。匿名内部类就是一个继承     外部类或者实现接口的子类对象。匿名内部类定义在局部位置。

匿名内部类的前提：继承一个类和接口。

匿名内部类的格式：

              new  外部类名或者接口名（）{

              重写父类或者接口的抽象方法，也可以定义特有方法

               }；

注意：

匿名内部类就是一个匿名子类对象，带内容的对象；

匿名内部类中定义的方法最多不超过3个。

例子：

interface Inter {

public abstract void show();

public abstract void show2();

}

class Outer {

private int num = 10;

public void method(){

// 匿名内部类

new Inter(){

public void show(){

System.out.println("show");

}

public void show2(){

System.out.println("show2");

}

};

new Inter(){

public void show(){

System.out.println("show");

}

public void show2(){

System.out.println("show2");

}

}.show();

new Inter(){

public void show(){

System.out.println("show");

}

public void show2(){

System.out.println("show2");

}

}.show2();

//调用匿名内部类特有方法

new Inter(){

public void show(){

System.out.println("show");

}

public void show2(){

System.out.println("show2");

}

public void function(){

System.out.println("funciton");

}

}.function();

//匿名内部类就是一个接口或者外部类的子类对象

Inter inter = new Inter(){

public void show(){

System.out.println("show");

}

public void show2(){

System.out.println("show2");

}

};

inter.show();

inter.show2();

}

}

class NiMingInnerClassDemo {

public static void main(String[] args) {

Outer ou = new Outer();

ou.method();

}

}

4 包

4.1 包的概念    

     包 package 

     package name；

     import 导入 ：一个Java源文件只能包含一个package语句，但是可以包含多个import     

                  语句。

                  import只能导入类，import java.util.*; //导入java.util包中的全部类

                  导入静态类：import static java.lang.System.*;

4.2 包之间的访问

不同包之间访问： 包名.类名

权限访问修饰符

	public	protected	default	private
同一类中	可以	可以	可以	可以
同一包中	可以	可以	可以	不可以
子类	可以	可以	不可以	不可以
不同包中	可以	不可以	不可以	不可以

     

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