JAVA面向对象

package enjory;

public class Test {

    public static Test t1 = new Test();
    public static Test t2 = new Test();
    {
        System.out.println("非静态块");
    }
    static {
        System.out.println("静态块");
    }

    public Test() {
        // TODO Auto-generated constructor stub
        System.out.println("构造函数");
    }

    public static void main(String[] args) {
        Test t = new Test();
    }
}

public class Testa {

    public static T t1 = new T();

    public static void main(String[] args) {
        T a1 = new T();
        T a2 = new T();
    }
}

class T {
    {
        System.out.println("非静态初始化块");
    }
    static {
        System.out.println("静态初始化块");
    }

    public T() {
        System.out.println("无参的构造方法");
    }

}

public class TEST {

    public static void main(String[] args) throws Exception {

        System.out.println("main:" + Tdsa.class);
    }

    private static class Tdsa {
        static {
            System.out.println("Tdsa................");
        }
    }
}

 

一、类的修饰符与一些小知识：

1、类的简单知识

①当我们打印一个对象的引用时，实际上默认调用的就是这个对象的toString方法

②类的可见性

　　public：可以被任何地方的其他类引用

　　缺省：只能被本包内的其他类引用

③成员变量和局部变量

　　局部变量必须显示的初始化，没有默认初始化值

　　成员变量会有默认的初始化的值

④类的修饰符

　　final

　　abstract

2、抽象类(是基于重写的)

　　①抽象类不可被实例化

　　②有构造器

　　③有抽象方法的类一定是抽象类

　　④没有抽象方法的类也可以为抽象类

　　⑤若子类继承抽象类，并重写了所有的抽象方法，那么这个类可以定义为实体类或者抽象类

　　⑥若子类继承抽象类，没有重写所有的抽象方法，那么这个类必须定义为抽象类，因为他里面继承了抽象方法

　　⑦抽象类的静态属性和静态方法是可以直接调用的

3、接口

　　①没有构造器

　　②只能有常量和抽象方法

　　③接口里面的常量修饰符都必须是（public static final）但是是可以省略的

　　④接口里面的方法的修饰符都必须是（public abstract）但是是可以省略的

　　⑤接口本身的修饰符是public或者缺省

　　⑥若子类实现接口，并重写了所有的抽象方法，那么这个类可以定义为实体类或者抽象类

　　⑥若子类实现接口，没有重写所有的抽象方法，那么这个类必须定义为抽象类，因为他里面继承了抽象方法

　　⑥一个类可以实现多个接口

　　⑦接口之间的可以多继承的

二、类的五类成员

1、属性

（1）可见性和修饰符

　　①可见性

　　　　public：

　　　　protected：

　　　　private：

　　　　缺省：

　　②修饰符

　　　　static

　　　　final

（2）属性的初始化过程：

　　属性的默认初始化 --> （属性的显示初始化 -->  代码块的执行） --> 构造器的赋值 --> setter方法的赋值；注意中间两个用括号括起来的两个部分是没有顺序的，谁写在前面就先执行谁。

　　final修饰的静态属性不支持默认初始化，（支持显示初始化，静态代码块初始化）只能其中一个赋值

　　final修饰的普通属性不支持默认初始化，（支持显示初始化，代码块初始化，构造器初始化）只能其中一个赋值

2、方法

（1）可见性

　　public：

　　protected：

　　缺省：

　　private：

（2）修饰符

　　static

　　final

　　abstract

3、构造器

（1）修饰符

　　public

　　protected

　　缺省

　　private

（2）特性

　　①抽象类也是有构造器的，只有接口没有构造器

　　②如果一个类没有定义构造器，那么会有一个默认的无参的构造器；如果定义了构造器，那么就没有默认的无参的构造器了

　　③类的多个构造器之间构成重载

　　④构造器不能被继承和不能被重写，但是可以被调用

　　⑤构造器的首行必须是this(args),this(),super(args),super()结构之一；当构造器中不显示调用时，首行默认调用的是super()父类空参的构造器，当然父类必须有空参的构造起了。

　　⑥java new的任何一个对象都会调用到Object类的Object()方法

　　⑦ava编译器会默认的给类生成一个空参数构造函数，而这个构造函数的访问级别是和类访问级别相同的

4、代码块

　　（1）静态代码块

　　　　　　①随着类的加载而加载，只被加载一次

　　　　　　②静态代码块的执行早于非静态代码块的执行

　　　　　　③静态代码块可以调用静态属性或者静态方法

　　（2）非静态代码块

　　　　　　①每创建一次对象，就执行一次非静态代码块

　　　　　　②它的执行早于构造器

　　　　　　③但是它的执行不一定就在属性显示初始化的前面，和他们在代码里的顺序有关，谁在前面就先执行谁

　　　　　　④非静态代码块里面可以调用属性和方法

5、内部类(成员内部类，局部内部类，匿名内部类，静态内部类)

　　局部内部类或者匿名内部类只能访问定义为final的局部变量

　　（1）成员内部类

　　　　修饰符：public，protected，缺省，private，static，final，abstract

　　　　①静态的

　　　　②非静态的

public class Main{
    public static void main(String[] args) {
        //静态内部类的创建
        W.A a = new W.A();
        a.show();
        //非静态内部类的创建
        W w = new W();
        W.B b = w.new B();
        b.show();
    }
}
class W {
    String name = "wai";
    static String id = "waiid";
    static class A{
        static String id = "neiid";
        public void show() {
            System.out.println(id);
            System.out.println(W.id);
        }
    }
    class B{
        String name = "nei";
        public void show() {
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(W.this.name);
        }
    }
}

　　（2）局部内部类

public class Main{
    public static void main(String[] args) {
        
    }
}
class J {
    //使用方式二
    Comparable getComparable(){
        class MyComparable implements Comparable{
            @Override
            public int compareTo(Object o) {
                // TODO Auto-generated method stub
                return 0;
            }    
        }
        return new MyComparable();
    }
    //使用方式二
    Comparable getComparable2(){
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                // TODO Auto-generated method stub
                return 0;
            }
        };
    }
}

(3)内部类的可见性

三、面向对象的三个特征

1、封装性

　　属性私有化，增加getter和setter的方法

2、继承性

　　

3、多态性

　　①属性是不存在多态性的，它是基于隐藏的；如果在③的情况下调用的是父类的属性。

　　②重载与重写的多态性的一种表现

　　③子类对象的多态性（把new出来的子类赋值给父类的引用）。

　　④继承和重写是多态性的前提

　　⑤接口与具体的实现类之间也是存在多态性的

　　

四、关键字

1、this与super(是针对对象的，不针对类)

this和super不能出现在静态区域内

（1）this

　　this在java中就是指当前对象，在静态方法中不能出现

　　①修饰构造器（调用其它重载的构造器）这个结构必须在构造器的首行出现，这个结构只能在构造器里面出现

　　　　this()

　　　　this(args)

　　②修饰方法和属性

　　　　this.name

　　　　this.show()

（2）super

　　java中的super指的是继承的父类的对象，在静态方法中不能出现

　　①修饰属性和方法

　　　　super.name

　　　　super.show()

　　②修饰构造器（调用父类的构造器）这个结构必须在构造器的首行出现，这个结构只能在构造器里面出现

　　　　不写的话默认会调用super()，在这种情况下父类必须有无参构造器

　　　　super()

　　　　super(args)

2、static关键字

　　可以修饰：方法、属性、代码块、内部类

3、final关键字

　　final可以修饰类、属性和方法

　　①修饰的类不能被继承

　　②修饰的方法不能被重写

　　③final修饰的成员变量为常量

　　④final修饰局部变量和函数参数

　　⑤final修饰的引用变量，其变量内部的属性是可以改变的

4、abstract

　　可以修饰类和方法

10、注意的点

　　final和static可以同时修饰属性

　　final和static可以同时修饰方法

　　abstract只能和public或者protected或者缺省连用

　　abstract不能用来修饰属性、构造器、private、final、static

五、重写与重载

1、重载

前提条件：重载是针对方法来说的，

①在同一个类当中，(不在同一个类中的子父类之间的方法也可以重载)
②函数名字相同，
③但是参数个数不同或参数类型不同或参数顺序不同
④只有返回值不同是不可以的

2、重写（权限修饰符子类可以大于父类；返回值类型和异常子类可以小于父类）

重写是在继承的机制下才形成的，继承是前提

前提条件：重写是针对实例方法来说的

1、要求子父类有相同的“返回值类型 方法名（参数列表）”都相同（返回值类型父类比子类的范围大也是可以的）
2、子类方法的权限修饰符不能小于父类方法的权限修饰符
3、若父类方法抛异常，那么子类方法抛的异常不能大于父类方法抛的异常
4、子父类的方法必须同为static或者同为非static

方法不能交叉覆盖：子类实例方法不能覆盖父类的静态方法；子类的静态方法也不能覆盖父类的实例方法

注意：重写是对子类中可见的父类方法而言的，如果在父类中的方法在子类中不可见，那根本就不存在重写一说

 

上图中绿色小三角就代表这个方法重写了。

下图中说明：返回值类型父类比子类的范围大也是可以的

3、覆盖

覆盖就是重写

4、隐藏

隐藏是对于静态方法和成员变量(实例变量和静态变量)而言的，就是父类和子类有相同名字的属性，或者父类和子类有相同名字的静态方法时，

属性是可以交叉隐藏：子类的实例变量可以隐藏父类的静态变量；子类的静态变量可以隐藏父类的实例变量

5、原理

覆盖的原理是RTTI，也就是通过Class对象实现的，看的是=后面，运行时类型为引用变量所指向的对象的类型

隐藏就是根据单纯的静态类型实现的，看的是=前面，编译时类型是引用变量自身的类型

6、枚举　

public class Main {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Rate[] rates = Rate.values();
        for (Rate rate : rates) {
            System.out.print(rate);
        }
        System.out.println();
        String str = "A";
        Rate rate = Rate.valueOf(str);
        System.out.println(rate);
        // --------------------------------
        Rate rate2 = Rate.getRateByNo(1);
        System.out.println(rate2);
        // ---------------------------------
        Rate.A.show();
        Rate.B.show();
        Rate.C.show();
    }

}

interface Info {
    void show();
}

enum Rate implements Info {
    A(0) {
        @Override
        public void show() {
            // TODO Auto-generated method stub
            System.out.println("Automtic");
        }
    },
    B(1) {
        @Override
        public void show() {
            // TODO Auto-generated method stub
            System.out.println("Bilibili");
        }
    },
    C(2) {
        @Override
        public void show() {
            // TODO Auto-generated method stub
            System.out.println("Customer");
        }
    };

    private Integer no;

    public Integer getNo() {
        return no;
    }

    public void setNo(Integer no) {
        this.no = no;
    }

    private Rate(Integer no) {
        // TODO Auto-generated constructor stub
        this.no = no;
    }

    public static Rate getRateByNo(Integer no) {
        switch (no) {
        case 0:
            return A;
        case 1:
            return B;
        case 2:
            return C;
        default:
            throw new IllegalArgumentException();
        }
    }
}

7、注解

1、注解

　　@Override限定重写父类方法，该注解只能用于方法

　　@Deprecated用于表示某个程序元素已过时

　　③SuppressWarnings抑制编译器警告

2、元注解

　　@Retention（存活周期）

　　　　RetentionPolicy.SOURCE（用于java文件）

　　　　RetentionPolicy.CLASS（用于class文件）默认的行为

　　　　RetentionPolicy.RUNTIME（用于运行时态）可以用于反射

　　@Target(可以用于修饰哪些程序元素)

　　　　TYPE

　　　　FIELD

　　　　METHOD

　　　　PARAMETER（形参）

　　　　CONSTRUCTORT

　　　　LOCAL_VARIABLE

　　@Documented（javadoc文档保留）

　　@Inherited(被修饰的注解具有继承性)

8、引用类型比较器

　　1、需要实现Comparable接口

　　2、Comparator接口脱离于类的比较器，自定义比较器