Java学习日记——接口/继承/多态、高级特性（JAVA类包、final）、内部类 20190304

LEARNING

## 一、接口、继承、多态

1、类的继承

class Test2 extends Test{                      //关键字extends标识继承关系
        public Test2(){                        
          super();                             //关键字super调用父类构造方法和成员方法
          super.doSomething();                 //调用构造方法只能在构造方法中
          }
         public void doSomethingnew(){
            //SomeStence
            }
         public void doSomething(){
            //SomeNewStence
          }
          protected Test2 dolt(){
            return new Test2();
            }
            }

重写：将父类的成员方法名称保留，重写实现内容，更改权限
重构：子、父类的成员方法返回值、方法名、参数类型以及个数完全相同，唯一不同的是方法实现内容

2、Object类 java.lang.O—bject——所有类的父类

①getCalss()——getClass().getName();
返回对象执行时的Class实例，然后使用getName()取得类的名称

②toString()——将一个对象返回为字符串形式，通常重写

public class ObjectInstance{
      public String toString(){
             return "在"+getClass().getName()+"类中重写toString()");
             }   //重写toString()方法使返回类名
      public static void main(String [] args){
               System.out.println(new ObjectInstance());
               }  //输出本类对象
               }

③equals()——自定义类中比较引用地址会返回boolean变量，想要比较内容需要重写

3、对象类型转换
①向上转型——把子类对象赋值给父类类型的对象
比如：
平行四边形是一种四边形，因此属于四边形类的子类，当实例化平行四边形类对象时
可以使用 平行四边形 a = new 平行四边形();
等同于 四边形 a = new 平行四边形();

②向下转型——将父类对象强制转换为某子类对象（显式类型转换）
比如：Parallelogram p = (Parallelogram) q;

4、instanceof操作符——判断父类对象是否为子类对象实例
当程序中执行向下转型，若父类对象非子类对象的实例，发生ClassCastException错误
因此需要判断父类对象是否为子类对象实例。

myobject instanceof ExampleClass
比如：
Quadrangle q = new Quadrngle();   //实例化父类对象
if(q instanceof Parallelogram){ }   //q是否属于四边形类的实例对象

返回值为boolean类型

5、方法重载
希望以不同方式实例化对象，则需要多个构造方法来完成，而构造方法名为类名，
为了让方法名相同而形参不同的构造方法同时存在，需要方法重载。
参数类型、个数、顺序不同均可构成重载。
定义不定长参数

返回值 方法名（参数数据类型…参数名）    //相当于数组

也可与原方法构成重载关系。

6、多态
如：定义一个四边形类，处理继承该类的对象，根据向上原则，四边形类的对象作为方法的参数，在方法中作一些限定即可根据不同类四边形对象处理方法。

public class Quadrangle {
       private Quadrangle[] qtest = new Quadrangle[6];
       private int nextIndex = 0;
       public void draw(Quadrangle q) {
           if(nextIndex < qtest.length) {
               qtest[nextIndex] = q;
               System.out.println(nextIndex);
               nextIndex++;
               }
        }
public static void main (String[] args){
           Quadrangle q = new Quadrangle();
           q.draw(new Square());
           q.draw(new Parallelogram());
           }
}
   class Square extends Quadrangle{
         public Square(){
               System.out.println("正方形");
               }
    }
   class Parallelogram extends Quadrangle{
         public Parallelogram(){
                   System.out.println("平行四边形");
                   }
   }

7、抽象类和接口
**①抽象类abstract：**一般将父类定义为抽象类，需要使用父类进行继承&多态处理

 public abstract class Test{         //关键字abstract定义抽象类
           abstract void testAbstract();
           }

继承抽象方法的所有子类需要将抽象类中的抽象方法进行覆盖。
比如：将四边形类修改成抽象类，则其中的draw()方法设置为抽象方法，那么子类继承四边形类后，需要将draw()方法进行重写，无论需不需要都必须重写。
——因此出现①代码冗余 ②局限性大
**∴概念：**将draw()方法放入另一个类，需要的则继承，不需要的则不继承，但是一个子类只可继承一个父类，因此出现——接口。

②接口interface——其中所有方法都没有方法体
将draw()方法封装到一个接口中，使需要该方法的类实现这个接口，同时继承四边形类

public interface drawTest{
           void draw();     //接口内的方法，省略abstract关键字
}

一个类实现一个接口可以使用implements关键字

public class Parallelogram extends Quadrangle
      implements drawTest{
             ……//
}

使用接口需要覆盖接口中的方法
**接口的多重继承

class 类名 implements 接口1,接口2,...,接口n



  interface intf1{
    }interface intf2 extends intf1 {
    }

## 二、类的高级特性

1、Java类包——管理类文件，解决类名冲突问题

①创建包 package 包名
》包冲突？包名使用创建者的Internet反序，不会冲突

②导入包

import java.lang.Math;
import java.lang.Math.*;       //.*的作用是表示可以使用包中所有的类

import还可以导入静态成员

import static java.lang.Math.max;  //静态成员方法
import static java.lang.System.out; //静态成员变量

2、final变量
final关键字一般用于变量声明，通常定义的量是常量。
也可用于修饰数组，未赋值的final成员变量为空白final。
编码规则：被final修饰的常量需要以大写字母+下划线表示
如：

private final int VALUE_1 = 9;       //普通final值可以通过改变赋值改变
private static final VALUE_2 = 10;   //用static声明的final值无法改变

3、final方法——final方法不可重写 ∴private

private final void test(){
        ...//
        }

4、final类——final类不可继承

final class FinalClass{
               ...//
               }

5、内部类
①成员内部类——在一个类中使用内部类

public class OuterClass{
        private class InnerClass{
                         ...//
             }
        }

内部类可以随意使用外部类的成员变量&方法，即使是private修饰
外部类不可直接访问内部类成员变量

1. 内部类向上转型为接口 （Swing编程技术）

interface InnerInterface(){
            public void f();
            }
    class OuterClass{
           private class InnerClass implements InnerInterface{
                      InnerClass(String s){
                              System.out.println(s);
                              }
                      public void f(){
                         System.out.println("访问内部类的f()方法")；
                         }
              }

∴如果有一个类继承了OutClass类，无法向下转型为内部类InnerClass，因此也无法访问f()方法，但是可以访问InnerIterface接口的f()方法。

2. 使用this关键字获取内部类和外部类的引用
   public class TheSameName{
   private int x;
   private class Inner {
   private int x = 9;
   public void doit(int_x){
   x++; //调用形参x
   this.x++; //调用内部类x
   TheSameName.this.x++; //调用外部类x
   }

②局部内部类——在方法中定义的内部类只能访问final类型的局部变量

Interface OutInterface2{
}
class OuterClass3{
     public OuterInterface2 doit(final String x){
            class InnerClass2 implements OuterInterface2{   //在doit()方法中定义内部类
                  InnerClass2(String s){
                            s = x;
                            System.out.println(s);
                            }
                  }
                  return new InnerClass2("doit");
                  }
             }

③匿名内部类

class OuterClass4{
       public OutInterface2 doit(){
               return new OutInterface2(){
                     private int i = 0;
                     public int getValue(){
                         return i ;
                         }
                     };      //匿名内部类需要在大括号内编写
               }
          }

④静态内部类

public class StaticInnerClass{
            int x = 100;
            static class Inner{
                  void doitInner(){
                         //System.out.println("外部类"+x);
                         }
                  public class void main(String args[]){
                         System.out.println("a");
                         }
                  }
       }

⑤内部类の继承

public class OutputInnerClass extends ClassA.ClassB{
            public OutputInnerClass(ClassA a){    
             //继承内部类必须硬性给予这个类一个带参数的构造方法
                  a.super();
                  }
        }
class ClassA{
      class ClassB{
          }
    }