java (技术篇)

接口interface:

1.接口的定义:

[修饰符]  interface 接口名 [externds 父接口名列表] {    [public] [static] [final] 变量；    [public] [abstract] 方法；}//创建ICalculate接口public interface ICalculate {    final float PI = 3.1415926F;    float getArea(float r);    float getCircumference(float r);}

2.接口的实现：

[修饰符] class <类名> [extends 父类名] [implements 接口列表] ｛

｝

//创建一个Cire类，实现ICalculate接口public class Cire implements ICalculate {    //实现接口中定义的getArea方法    float getArea(float r) {        float area = PI * r * r;        return area;    }    //实现接口中定义的getCircumference方法    float getCircumference(float r) {        float cir = 2 * PI * r;        return cir;    }}

类的继承：

[修饰符] class 子类名 extends 父类名 ｛
类体
｝

//父类Bird类public class Bird {    String color = "red";    String skin = "green";}//子类Pigeonpublic class Pigeon extends Bird {    public static void main(String[] args) {        Pigeon pigeon = new Pigeon();        System.out.println(pigeon.color);    }}

继承中的重写：

子类可以重写父类中的方法。

super关键字

子类中可以通过super关键字调用父类构造方法
super(“red”);

子类中操作父类中被隐藏的成员变量或被重写的成员方法
super.成员变量名；
super.成员方法名；

重写父类中的方法：

多态

java 语言通常使用 重载 和 重写 实现类的多态性。

方法的重载：是指在一个类中出现多个方法名相同，但参数个数或 参数类型不同的方法。
方法的重写：是指子类中重写父类中的方法。

//getArea() 方法实现了重载class Calculate {        final float PI = 3.1415926f;        //        public float getArea(float r) {            float area =  PI * r * r;            return area;        }        //         public float getArea(float l, float w) {            float area = l * w;            return area;        }    }

public class P{        public void getInfo() {            System.out.println("jack");        }    }    public class X extends P {        public void getInfo() {            System.out.println("henry");        }    }

抽象类

abstract class 类名 ｛
类体
｝

abstract class Fruit {    public String color;    // 构造方法    public Fruit(){        color = "red";    }}

抽象方法

abstract <方法返回值类型> 方法名 （参数列表）；
注：抽象方法不能使用private, static关键字进行修饰。抽象类中的抽象方法由子类实现。

//定义抽象类abstract class Fruit {    //定义成员变量    public String color;    //构造类，初始化了color变量;    public Fruit() {        color = "green";    }    //定义抽象方法    public abstract void getInfo();}public class Apple extends Fruit {    @Override    public abstract void getInfo() {        System.out.println("this is Apple Class");    }}public class Orange extends Fruit {    @Override    public abstract void getInfo() {        System.out.println("this is Orang Class");    }}

内部类

成员内部类：
在一个类中使用内部类可在内类中直接存取其所在类的私有成员变量，成员方法。
外部方法不可以直接访问内部类成员变量 。

public class OuterClass {    InnerClass in = new InnerClass(); //在外部类实例化内部类对象引用    private void ouf(){ //在外部方法中调用内部类方法        in.inf();    }    class InnerClass {        InnerClass () {  //内部类构造方法        }        public void inf() { //内部类成员方法        }        int y = 2; //内部类成员变量    }    public InnerClass doit() { //外部类方法返回内部类引用        //y = 5; //外部类不可直接访问内部类成员变量        in.y = 8;        return new InnerClass(); //返回内部类引用    }    /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub        OuterClass out = new OuterClass();        //内部类的对象实例化操作必须在外部类或外部类中的非静态方法中实现        OuterClass.InnerClass in = out.doit();    }}

this关键字

this 关键字指向外部类的一个对象引用。

局部内部类：

局部内部类是指在类的方法中定义的内部类，

public class SellOutClass {    private String name;    public SellOutClass(){    }    public void sell(int price) {        class Apple {            int innerPrice = 0;            public Apple (int price) {                innerPrice = price;            }            public void price() {                System.out.println("SELL :"+name);                System.out.println("Price :"+innerPrice);            }        }        Apple apple = new Apple(price);        apple.price();    }    /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub        SellOutClass tmp = new SellOutClass();        tmp.sell(100);    }}

匿名内部类：

匿名内部类所有实现代码都需要在大括号之间进行编程。
匿名内部类格式如下
return new A{ //内部类体 }

IStringD.java  //定义接口public interface IStringD {    public String filterBlank();}Main.javapublic class Main {    /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub        final String orgStr = "hello java a b c";        IStringD s = new IStringD(){  //匿名内部类            public String filterBlank() {                // TODO Auto-generated method stub                String conver = orgStr;                conver = conver.replaceAll(" ", "");                return conver;            }        };        System.out.println(orgStr);        System.out.println(s.filterBlank());    }}

静态内部类：

在内部类前添加修饰符static,这个内部类就变成了静态内部类，一个静态内部类中可以声明static成员，但在非静态内部类中不可以声明静态成员。静态内部类的最大特点就是不可以使用外部类的非静态成员。

public class StaticInnerClass {    static int x = 9;    static class InnerClass {        void doInner(){            System.out.println(x);        }    }    public static void main(String[] args) {        doInner();//访问内部类的方法    }}

内部类的继承：

创建OutputInnerClass类，继承ClassA类中的内部类ClassB:

public class OutputInnerClass extends ClassA.ClassB  //继承ClassA类中的内部类ClassBclass ClassA{    class ClassB{    }}