java基础知识（五）java类

　　类是java的核心和本质，是java语言的基础。

一、java中的类

1、类class

　　一个类可以包含局部变量、实例变量、类变量（静态变量）

　　一个类至少有一个构造方法，如果没有，系统会默认给出一个无参构造方法

　　一个类可以通过关键字new来创建一个新的对象

2、接口interface

　　接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

　　接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。

　　接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误。

　　接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

3、抽象类abstract

　　抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

　　抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

　　抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

　　抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

　　构造方法，类方法（用static修饰的方法）不能声明为抽象方法

　　抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

4、最终类

　　用final修饰符修饰的类被称为最终类，最终类不能再有子类。

　　abstract和final不能同时修饰一个类，abstract类自身没有具体的对象，需要派生类创建子类对象。

5、内部类（成员内部类、局部内部类、匿名内部类、嵌套类）

　　定义在类内部的类，可以用public，default，protected和private修饰，也可以用static修饰。

　　内部类是一个编译时的概念，一旦编译成功就会成为两个完全不同的类（Outer.class、Outer$Inner.class），内部类的属性名、方法名可以和外部类的相同。

　　1）成员内部类：定义在外部类的类体中，不能用static修饰；可以直接使用外部类的变量和方法；可直接用内部类创建对象。

package com;/**
 * Created by Administrator on 2016/11/14.
 */
public class MyOuter {
    private int x = 100;    // 创建内部类
    class MyInner {
        private String y = "Hello!";        public void innerMethod() {
            MyInner my = new MyInner("内部实例化");
            System.out.println("内部类调用内部类中 y =" + y);
            System.out.println("内部类调用外部类中的x =" + x);// 直接访问外部类中的实例变量x
            System.out.println("内部类调用外部类的方法outerMethode =" + outerMethod());
        }        MyInner(String index) {
            System.out.println("我是内部类。。。" + index);
        }
    }    public int outerMethod() {
        x++;
        return x;
    }    public MyInner makeInner() {
        return new MyInner("外部实例化");
    }    public static void main(String[] args) {
        MyOuter mo = new MyOuter();
        //MyOuter.MyInner inner = mo.new MyInner("外部实例化");//与下面写法等价
        MyOuter.MyInner inner = mo.makeInner();//常规内部类需要通过外部类的实例才能创建对象，与实例变量需要通过对象来访问相似
        inner.innerMethod();
    }
}

　　2）局部内部类：在方法体（方法、构造方法）或语句块（局部块、静态初始化块）内部定义的类称为局部内部类；作用域同局部变量；方法中的内部类同方法定义局部变量一样，不能使用private、protected、public等访问修饰说明符修饰，也不能使用static修饰，但可以使用final和abstract修饰；

package com;/**
 * Created by Administrator on 2016/11/14.
 */
public class Jubu {    private int size = 5, y = 7;
    private static int z = 2;    static {
        class MyInnerKuai{
            final int kuai = 1;
            public String toString(){
                return "kuai = " + kuai + "";
            }
        }
        System.out.println(new MyInnerKuai().toString() + "; out-z = " + z);
    }    public Object makeInner(int localVar) {
        final int finalLocalVar = localVar;
        //创建内部类，该类只在makeInner（）方法有效，就像局部变量一样。在方法体外部不能创建MyInner类的对象
        class MyInner {
            int y = 4;
            public String toString() {
                return "out-ize = " + size + "; finalLocalVar = " + finalLocalVar + "; inner-y = " + this.y;
            }
        }
        return new MyInner();
    }    public static void main(String[] args) {
        Object obj = new Jubu().makeInner(47);
        System.out.println(obj.toString());
    }
}

　　3）匿名内部类：没有名字的内部类，只能使用一次，必须继承一个父类或实现一个接口(没有名字无法实例化，并且只能继承一个类或实现一个接口)，通常用来简化代码。

　　java中的匿名内部类总结

public class NiMing {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}abstract class Person {
    public abstract void eat();
}

　　4）静态内部类（嵌套类）：用static修饰内部类，非静态内部类需要在外部类实例化后才能实例化，如果你不需要内部类与外部类有联系就可以将内部类用static修饰。

public class MyOuter {
    public static String x = "hello ";    public static class MyInner {
        private String y = "static inner class!";        public void innerMethod() {
            System.out.println(x + y);
        }
    }    public static void main(String[] args) {
        MyOuter.MyInner si = new MyOuter.MyInner();//静态内部类不通过外部实例就可以创建对象；与类变量可以通过类名访问相似
        si.innerMethod();
    }
}

6、枚举类

　　枚举在日常开发中非常有用，有关具体作用详见主题：Java 枚举7常见种用法

二、类间关系

1、类的访问权限（public、default），内部类（public、default、protected、private）

2、类、接口、抽象类区别

　　接口与类的区别

• 接口不能用于实例化对象。
• 接口没有构造方法。
• 接口中所有的方法必须是抽象方法。
• 接口不能包含成员变量，除了 static 和 final 变量。
• 接口不是被类继承了，而是要被类实现。
• 接口支持多重继承。

　　抽象类与接口的区别

• 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
• 接口中不能还有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
• 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

3、继承、多态

　　继承：提高代码的重复利用和可维护性，实现继承的类有以下特征　

• 子类拥有父类非private的属性，方法和构造器。

• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

• 子类可以用自己的方式实现父类的方法。

• Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。

• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。

　　多态：多态就是同一个接口使用不同的实例执行不同的操作。多态的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象