第一、JAVA语言语法之 三、static修饰符 四、final修饰符 五、接口 六、内类

三、static修饰符

3.1、静态变量

成员变量前加上static，叫类变量，被这个类创建的所有对象共有。在多个对象间共用数据时，可以使用这种方法

3.2、静态方法

方法前加上static，该方法可以通过类的名字直接访问

①静态方法只能访问类变量和方法参数，不能直接访问成员变量，否则编译出错

如果确实需要访问成员变量，可以先创建对象，再通过对象访问

②静态方法不能直接访问非静态的方法，否则编译出错

③静态方法不可被覆盖

1）如果父类有个方法是静态的，子类中有个方法与其名称、参数都相同，但不是静态的，这时编译出错

2）如果父类有个方法是静态的，子类中有个方法与其名称、参数都相同，但是静态的，这时编译能通过，但这种用法不是覆盖

3.3、静态初始化

static...{
    代码
}

 

这段代码和成员变量、方法并列，在第一次创建对象时执行，以后都不再执行

四、final修饰符

4.1、final类

表明该类不可以有子类

4.2、final方法

表示该方法不可以被覆盖，final只影响覆盖，不影响重载

static、private方法和final方法一样，都不可以被覆盖，只是final编译时会报错，static、private不报错，但是也不会被覆盖

4.3、final变量

代表常量，只能赋值一次

五、接口

5.1、抽象类——abstract修饰符

abstract用在类和方法定义中，表示类中有方法还没有写完，只写了方法的名称和参数，没有写方法的代码

如：编写一个类，知道类中一定要有某个方法，但是该方法的细节还不能确定，只能在它的子类中才能确定，这个时候就使用abstract。

/**//*
**抽象类--abstract修饰符
*/

abstract class Vehicle...{//定义一个交通工具类
    abstract int getFuel();//定义getFuel()方法计算油耗，抽象的，在子类中去实现
}
class Car extends vehicle...{//汽车
    int getFuel()...{
        //具体的油耗计算方法
    }
}
class Bus extends vehicle...{    //工交车
    int getFuel()...{
        //具体的油耗计算方法
    }
}
class Company...{//定义一个公司类
    Vehicle fleet[];//定义一个车队，只要是交通工具都可以包含
    void reportFuel(Company c)...{//统计车队每个月的耗油量
        int fuel = 0;
        for(int i = 0; i<c.length; i++)...{
            fuel += fleet[i].getFuel();//则要求每种车都有个getFuel()方法来计算油耗
        }
    }
}

 

5.2、接口——interface

①当一个类中所有的方法都是抽象的，我们就把这个类定义为接口，所有的方法都只有方法名和参数

 

③使用时通过类来实现，必须把接口中所有的方法都实现，如果不能完全实现，就说明该类还没有定义完，应该声明为抽象的类。

/**//*
**接口的实现--通过类来实现，若不能完全实现，则该类须定义为抽象类
*/
class aa implements xx,yy...{
    public void tt()...{
        //...
    }
    public void ss()...{
        //...
    }
    public void mm()...{
        //...
    }
}

 

④使用接口，可以把不同类之间的相似点提取出来

如：鸟和飞机都有会飞的特点，需要定义一系列与飞相关的方法（如飞行高度、速度等），则定义一个接口

 

/**//*
**通过接口提取类的相似点
*/
interface Fly...{
    public void getflyHeight();//高度
    public void getflySudu();//速度
}

 

六、内类

内类又叫类的嵌套，把一个类定义在另一个的内部，与成员变量和方法并列，主要用于在内类中访问外类的成员变量。

6.1、内类就象外类的方法一样，在静态方法中不能直接使用，需要先创建外类对象，通过外类的new类创建内类对象，在其他类中使用内类也应如此。

class Aa...{
    private int size;
    class Bb...{
        void tt()...{
            size = 100;//内类中可以直接使用外类的成员变量
        }
    }
    void ss()...{
        Bb x = new Bb();//非静态方法中直接创建内类对象
    }
    public static void main(String ejing[])...{
        Aa s = new Aa();//在静态方法中先创建外类对象
        Bb y = s.new Bb();//再通过外类的new来创建内类对象
    }
}

6.3、方法中定义内类

在包含内类的方法中，局部变量（常量除外）不能被内类直接访问

/**//*
**方法中定义内类
*/
public class Aa...{
    private int size;
    void test()...{
        int i;//包含内类的方法中，局部变量不能被内类访问
        final int j = 102;//常量可以被内类访问
        class Bb...{
            void tt()...{
                size = 100;
                System.out.println(j);
            }
        }
        Bb x = new Bb();
        x.tt();
        System.out.println(size);
    }
    public static void main(String ejing[])...{
        Aa s = new Aa();
        s.test();
    }
}

6.4、内类可以定义为抽象的

6.5、静态内类

①只是位置在外类中，实际上是与外类并列，不能直接访问外类的成员变量

②内类一般不可以定义静态的成员变量，但是静态内类可以

 

/**//*
**接口的定义
*/
public interface xx...{
    public void tt();
    public void ss();
}

②接口支持多重继承：一个子接口可以有多个父接口，突破类的单一继承限制

/**//*
**创建内类对象
*/

/**//*
**接口的多重继承
*/
interface xx...{
    public void tt();
    public void ss();
}
interface yy...{
    public void mm();
}
interface zz extends xx,yy...{
}