黑马程序员-Java学习04-接口，多态，内部类，匿名内部类，Object类

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

1.接口

 接口：初期理解，可以认为是一个特殊的抽象类

 当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

 class用于定义类

 interface 用于定义接口。

接口定义时，格式特点：

• 接口中常见定义：常量，抽象方法。
• 接口中的成员都有固定修饰符。
•  常量：public static final
•  方法：public abstract
• 记住：接口中的成员都是public的 这此修饰符都可以省略，最好写全 

接口可以多重继承

接口：是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。

否则子类是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

基本功能和扩展功能，接口实现扩展功能

interface Smoking{void smoke();}class Student{String name;Student(String name){this.name =name;}void study(){System.out.println("studying");}}class BaseStudent extends Student implements Smoking{BaseStudent(String name){ super(name);}public void smoke(){System.out.println("smoking");}}public class InterfaceTest{public static void main(String[] args){BaseStudent bs = new BaseStudent("nuddlesW");bs.study();bs.smoke();}}

2.多态：

可以理解为事物存在的多种体现形态。

人：男人，女人

动物：猫，狗。

猫 x = new 猫();

动物 x = new 猫();

多态的体现

•  父类的引用指向了自己的子类对象。
•  父类的引用也可以接收自己的子类对象。

多态的前提

•  必须是类与类之间有关系。要么继承，要么实现。
•  通常还有一个前提：存在覆盖。

多态的好处

•  多态的出现大大的提高程序的扩展性。

多态的弊端：

•  提高了扩展性，但是只能使用父类的引用访问父类中的成员。

多态的应用

/*动物，猫，狗。*/abstract class Animal{         abstract void eat(); } class Cat extends Animal{   public void eat(){             System.out.println("吃鱼");   }   public void catchMouse(){             System.out.println("抓老鼠");   }} class Dog extends Animal{   public void eat(){             System.out.println("吃骨头");   }   public void kanJia(){             System.out.println("看家");  }}  class Pig extends Animal{   public void eat(){             System.out.println("饲料");   }   public void gongDi(){             System.out.println("拱地");   }}  class DuoTaiDemo{   public static void main(String[] args){                     Cat c1 = new Cat();             function(c1);             function(new Dog());             function(new Pig());                             function(new Cat());            }   public static void function(Animal a)//Animal a = new Cat();{   //父类的引用指向子类             a.eat();             //a.catchMouse();   }}   

3.转型

 animal a = new Cat();//类型提升。 向上转型。

  a.eat();

  如果想要调用猫的特有方法时，如何操作？

  强制将父类的引用。转成子类类型。向下转型。

  animal a =new cat();

 Cat c = (Cat)a;

  c.catchMouse();

  千万不要出现以下这样的操作，就是将父类对象转成子类类型。

 Animal a = new Animal();

  Cat c = (Cat)a;

  我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。

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

 if(a instanceof 类名)  关键字instanceof 用来判断是否属于某类

4.封闭功能

学会使用类来封装功能，即该类中没有成员变量，只有封装方法如

class Function 

{

    public void function(Student s)

    {

        s.run()

    }

}

5.多态中成员函数的特点：

方法

• 在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
• 在运行时期：参阅对象所属的类中是否有调用的方法。
• 简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：

• 无论编译和运行，都参考左边(引用型变量所属的类)。

在多态中，静态成员函数的特点：

• 无论编译和运行，都参考做左边。

class Fu{ int num = 5;void method1(){System.out.println("fu method_1");}void method2(){System.out.println("fu method_2");} void method4(){System.out.println("fu method_4");}}class Zi extends Fu{ int num = 8;void method1(){System.out.println("zi method_1");}void method3(){System.out.println("zi method_3");}void method4(){System.out.println("zi method_4");}}class  DuoTaiDemo4{public static void main(String[] args) {Fu f = new Zi();System.out.println(f.num);f.method4();Zi z = new Zi();z.method4();System.out.println(z.num);}}

运行结果：成员变量不管有没有static, 都是5，8

                  方法，如果有static 就是fu method_4

                                                        zi method_4

                  如果没有static就都是     zi method_4

练习：

/*要求：模仿电脑主板工作过程思路：定义接口，主板连接相应接口，既能工作。*/interface Pci{void open();void close();}class SoundCard implements Pci{public void open(){System.out.println("soundcard start");}public void close(){System.out.println("soundcard close");}}class NetCard implements Pci{public void open(){System.out.println("netcard start");}public void close(){System.out.println("netcard close");}}class Board{public void run(Pci p){if(p != null){p.open();p.close();}}}public class Computer{public static void main(String[] args){Board b = new Board();b.run(new SoundCard());b.run(new NetCard());}}

-----------OUTPUT-----------  
soundcard start
soundcard close
netcard start
netcard close

6.程序执行内部过程

JAVA语言中除基本类型之外的变量类型，都称之为引用类型。 JAVA中对象是通过引用reference对其操作的。 新建对象时，引用类型的数据都是null，基本数据类型 int 是 0 string 是null boolean 是false (默认初始化) 方法：参数传递的值是 值传递。 局部变量 必须初始化，成员变量会被系统默认初始化。 

栈：自动分配连续的空间，后进先出，一般用来放置局部变量，数据使用完毕之后，会自动释放 

堆：不连续，用来放置 new出来的对象，

堆中的数据都会有默认初始化值。引用类型的数据都是null，基本数据类型 int 是 0 string 是null boolean 是false (默认初始化) 

方法区：属于堆的一部分，存放类的信息（代码）、static变量、常量池（字符串常量）等 解析：

 1、主函数中定义一个 int x=3; 主函数加载时，主函数就在内存中的栈中 开辟一个空间，此空间中就会定义一个变量 ，并且赋值为3.

 2、主函数中创建一个 int[] x=new int[3]; 左边 int[] x，在栈内存中定义了一个变量 x, new int[3],在堆内存中开辟了一个空间，每个在堆内存中存在的数据都会有一个地址值。 = 时，就将x的引用指向了new 对象在堆内存中的地址值。 注：操作对象就是操作地址。

例子： //通过类加载器 Class LOader加载Student类，加载后，在方法区中就有了Student中的类的信息 Student s1=new Student(); s1.name="张三"; 

7.内部类：

内部类讲一个雷定义在另一个类的里面，对立面那个类就叫做内部类，或者嵌套类。特点，内部类可以直接访问外部类中的成员。包括私有成员。而外部类要访问内部类中的成员必须要建立内部类对象。代码class outer   class inner           void function(){}   }}inner内部类。访问规则：1.内部类可以直接访问外部类中的成员，包括私有。是因为内部类中持有了一个外部类的引用。格式：外部类名.this         2.外部类要访问内部类，必须要建立内部类的对象。         3.内部类作为外部类的成员 可以被私有化如何直接访问内部类中的成员 function()outer.inner  in=new outer().new inner();   in.function();访问格式：1.当内部类定义在外部类的位置上的时候，而且非私有，可以在外部其他类中，可以直接建立内部类对象  格式 外部类名.内部类名  变量名=外部类对象.内部类对象       outer.inner  in=new outer().new inner();2.当内部类在成员的位置上，就可以被成员修饰符所修饰。  比如：private  static，  当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限  在外部其他类中，如何直接访问static内部类的非静态成员？  new Outer.Inner().sunction();  在外部其他类中，如何直接访问staic内部类的静态成员？  outer.inner.function();注意：当内部类中定义了静态成员，该内部类必须是static 的。     当外部类中的静态方法访问内部类是，该内部类必须是静态的内部类定义原则：当描述事物中，事物的内部还有事物，该事物用内部类来描述。因为内部事务在使用外部事物中的内容。

package nuddles.j2seDemo;public class InnerDemo {/** * @param args */public static void main(String[] args) {// TODO Auto-generated method stub//new Outer.Inner().info2();//System.out.println(Outer.Inner.name);new Outer().info(); Outer.Inner in = new Outer().new Inner(); in.info2();//new Outer().info();}}class Outer{private int num =7;public void info(){new Inner().info2();}class Inner{String name = "nuddles";public  void info2(){System.out.println(num+name);}}}

内部类定义在局部时，

不可以被成员修饰符修饰
可以直接访问外部类中的成员，因为还持有外部类中的引用。但是只能访问被final修饰的局部变量。

8.匿名内部类:

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

2，定义匿名内部类的前提：

内部类必须是继承一个类或者实现接口。

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

4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。

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

interface Demo  {public abstract void run();}class Wai{static int i = 9;static class Nei{static int y = 10;public  static void run( int x){i = x;System.out.println(i);}}public void fucntion(){new Demo(){int j = 9;public void run(){System.out.println(j);}}.run();// 匿名内部类实现了Demo接口}}class InnerTest{public static void main(String[] args) { Wai.Nei.run(11);/*Wai w = new Wai();w.Nei().run(10);*/new Wai().fucntion();}}

9.Object类

equals 方法：

其实和== 一样，比较的是引用地址是否一样，通常要复写，覆写要注意接收的类是object,然后判断，再向下转型

toString方法，返回值是：

getClass().getName() + '@' + Integer.toHexString(hashCode())

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------