匿名類

static修飾成員及訪問

package com.ice.test00;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class Animal {
    //成員變數
    int age;
    String name;

    //成員方法
    public void eat() {
        System.out.println("eat...");
    }

    /**
     * 被static修飾的變數：靜態變數（類變數）
     * 被static修飾的方法：靜態方法（類方法）
     * 靜態變數和靜態方法稱為靜態成員
     * 靜態成員通過"類名.“訪問（標準）或者”物件.“訪問（非標準，不推薦使用）
     * <p>
     * static修飾的方法或代碼塊中不能使用this與super
     * static不能修飾構造器
     */
    //靜態變數
    static char sex;
    static int foot;

    //靜態方法
    public static void sleep() {
        System.out.println("sleep...");
    }

    public static void main(String[] args) {
        //通過”類名.“訪問靜態成員
        System.out.println(Animal.sex);
        System.out.println(Animal.foot);
        Animal.sleep();

        //通過”物件.“訪問靜態成員  非標準的，不推薦使用
        Animal a = new Animal();
        System.out.println(a.sex);
        System.out.println(a.foot);
        a.sleep();
    }
}

static應用

package com.ice.test;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class People {
    private String name;
    private int age;
    private static String city;

    public People() {
    }

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", city='" + city + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

package com.ice.test;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class Test02 {
    public static void main(String[] args) {

        People p1 = new People("max", 23);
        p1.setCity("北京");
        System.out.println(p1);

        People p2 = new People("小龍", 21);
        p2.setCity("貴陽");
        System.out.println(p2);

        People p3 = new People("小敏", 22);
        System.out.println(p3);
    }

}

static初始化塊

package com.ice.test;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class Count {
    public int number;

    private static int count;//用于計數

    //用于初始靜態變數，先于構造器執行
    static {
        System.out.println("類加載時執行了并且被執行一次");
        count = 1;
    }

    public static int getCount() {
        return count;
    }

    public Count() {
        count++;
        number = count;
        System.out.println("構造器被執行");
    }
}

package com.ice.test;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class Test01 {
    public static void main(String[] args) {
        Count c = new Count();
        new Count();
        System.out.println(c.number);
    }
}

執行結果：

類加載時執行了并且被執行一次
構造器被執行
構造器被執行
2

單例設計模式

懶漢式

package com.ice.test01;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
//懶漢式
public class SingleTon {
    public double r = Math.random();
    private static SingleTon single = null;

    //私有化構造器，不讓其他類創建物件
    private SingleTon() {

    }

    //靜態工廠：專門用來生產類的實體
    public static SingleTon getInstance() {
        if (single == null) {
            single = new SingleTon();
        }
        return single;
    }

}

餓漢式

package com.ice.test02;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 * 內部類：就是在一個類或方法中定義的類
 * 內部類實際也是一個類，可以有成員變數和成員方法
 * 分類：成員內部類，靜態內部類，區域內部類，匿名內部類
 */
//餓漢式
public class SingleTon {
    public double r = Math.random();
    private static SingleTon single = new SingleTon();

    //私有化構造器，不讓其他類創建物件
    private SingleTon() {

    }

    //靜態工廠：專門用來生產類的實體
    public static SingleTon getInstance() {
        return single;
    }

}

package com.ice.test02;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class Test {

    public static void main(String[] args) {
        SingleTon single1 = SingleTon.getInstance();
        System.out.println(single1.r);
        SingleTon single2 = SingleTon.getInstance();
        System.out.println(single2.r);
    }
}

內部類的定義

public abstract class Animal {
    public abstract void eat();
}

public interface Inf1 {
    //啟動
    public abstract void start();
}

public interface Inf2 {
    //開始
    public abstract void start();
}

public abstract class Other {
    public abstract void othereat();
}

package com.ice.test03;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
//外部類
public class Outerclass extends Other implements Inf1 {
    public static int a = 0;

    @Override
    public void start() {//啟動

    }

    @Override
    public void othereat() {

    }

    //內部類
    class InnerClass {
    }

    //內部類實作介面
    class InnerClassInf implements Inf2 {

        @Override
        public void start() {//開始

        }
    }

    //內部類繼承抽象類
    class InnerClassAbstract extends Animal {

        @Override
        public void eat() {

        }
    }

}

類的內容

package com.ice.test04;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public abstract class OuterClass {
    int a;//成員變數
    static int b;//靜態變數
    final static int C = 10;//常量

    {
        //初始化塊
    }

    static {
        //靜態初始化塊
    }

    public OuterClass() {
        //構造器

    }

    public void fun1() {
        //成員方法

    }

    public static void fun2() {
        //靜態成員方法

    }

    public abstract void fun3();//抽象方法

    class InnerClass {
        //內部類
        
    }

}

成員內部類

package com.ice.test05;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class OuterClass {
    int a = 10;//成員變數
    static int b = 20;//靜態變數

    /**
     * 在外部類中訪問成員內部類:new 內部類名().內部類物件
     */
    //成員方法
    public void fun() {
        System.out.println(new InnerClass().x);
    }

    //成員內部類
    class InnerClass {
        int x = 10;

        //        static int y=20;//內部類中不能存在靜態成員

        /**
         * 在成員內部類中訪問外部類：外部類類名.this.外部類物件
         * this在內部類中表示當前的內部類物件
         */
        public void fun() {
            System.out.println(OuterClass.this.a);
            System.out.println(this.x);
        }
    }
}

靜態內部類

package com.ice.test06;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
//外部類
public class OuterClass {

    //靜態內部類
    public static class InnerClass {
        public static int a = 10;

        public static void fun() {
            System.out.println("statie fun...");
        }
    }

    public void test() {
        System.out.println(InnerClass.a);
    }
}

package com.ice.test006;

import com.ice.test06.OuterClass;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class Test {
    public void m() {
        System.out.println(OuterClass.InnerClass.a);
    }
}

區域內部類

package com.ice.test07;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class OuterClass {
    public int a = 10;

    public void fun() {
        //區域變數
        final int x = 100;
        /**
         * 區域內部類：定義在方法內部或引數位置
         * 作用域只在該方法內有效，不能使用權限修飾符
         */
        class InnerClass {
            public void test() {
                System.out.println(OuterClass.this.a);//訪問外部類成員，通過“外部類名.this.外部物件

                System.out.println(x);//訪問方法的區域變數，但是這個區域變數必須由final修飾
            }
        }
    }
}

匿名內部類

package com.ice.test08;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class Animal {
    public void eat() {
        System.out.println("Animal...");
    }
}

package com.ice.test08;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 * 匿名內部類：
 * 1.在成員變數賦值時創建
 * 2.在方法內部定義并直接使用
 * 3.在方法引數位置創建
 */
//外部類
public class NoNameClass {
    Animal a = null;//宣告參考物件時使用默認值null
    Animal a2 = new Animal();//宣告參考變數時就創建物件

    /**
     * 1.在成員變數賦值時創建
     */
    //宣告參考變數并創建匿名內部類物件 new 類名（）{}--->匿名內部類物件
    Animal a3 = new Animal() {
        @Override
        public void eat() {
            super.eat();
        }
    };

    /**
     * 2.在方法內部定義并直接使用
     */

    public void fun() {
        //匿名內部類--->匿名物件，用完一次就回收
        new Animal() {
        };
        Animal a = new Animal() {
            @Override
            public void eat() {
                System.out.println("匿名內部類的eat方法");
            }
        };
        a.eat();
    }

    /**
     * 3.在方法引數位置創建
     *
     * @param a
     */
    public void m(Animal a) {

    }

    public static void main(String[] args) {
        new NoNameClass().m(new Animal() {//在方法引數位置創建

        });
    }
}

//普通類
public class Animal {
    public void sleep() {

    }
}

//抽象類
public abstract class Computer {

    public abstract void play();
}

//介面
public interface Mouse {
    public abstract void click();
}

package com.ice.test09;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class NoNameClass {
    //普通類實作匿名內部類
    Animal a = new Animal() {
        @Override
        public void sleep() {
            System.out.println("匿名內部類的sleep()方法");
        }
    };
    //抽象類實作匿名內部類：在匿名內部類中必須重寫抽象方法
    Computer c = new Computer() {
        @Override
        public void play() {
            System.out.println("匿名內部類的play()方法");
        }
    };

    //介面實作匿名內部類:在匿名內部類中必須重寫抽象方法
    Mouse m = new Mouse() {
        @Override
        public void click() {

        }
    };
}

使用匿名內部類作為引數傳遞

package com.ice.test10;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
//普通類
public class Animal {
    public void sleep() {
        System.out.println("Animal sleep...");
    }
}

class Dog extends Animal {
    @Override
    public void sleep() {
        System.out.println("Dog sleep");
    }
}

package com.ice.test10;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
//抽象類
public abstract class Computer {
    public abstract void play();
}

class MyComputer extends Computer {
    @Override
    public void play() {
        System.out.println("MyComputer play...");
    }
}

package com.ice.test10;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
//介面
public interface Mouse {
    public abstract void click();
}

class Lenovo implements Mouse {
    @Override
    public void click() {
        System.out.println("Lenovo click...");
    }
}

package com.ice.test10;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class NoNameClass {
    /**
     * 普通內部類作為引數時:可以傳普通類物件、子類物件、匿名內部類物件
     */
    public void m1(Animal a) {
        a.sleep();
    }

    /**
     * 抽象類作為引數時：可以傳遞子類物件，匿名內部類物件
     *
     * @param c
     */
    public void m2(Computer c) {
        c.play();
    }

    /**
     * 引數作為介面時：可以傳遞實作類物件，匿名內部類物件
     *
     * @param m
     */
    public void m3(Mouse m) {
        m.click();
    }
}

package com.ice.test10;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class Test {
    public static void main(String[] args) {
        NoNameClass n = new NoNameClass();

        //呼叫引數為普通類的方法
        n.m1(new Animal());//Animal a=new Animal();
        n.m1(new Dog());//Animal a=new Dog();//向上轉型
        n.m1(new Animal() {//Animal a=匿名內部類物件
            @Override
            public void sleep() {
                System.out.println("普通類實作匿名內部類");
            }
        });

        //呼叫引數為抽象類的方法
        n.m2(new MyComputer());//Computer c=new MyComputer 向上轉型
        n.m2(new Computer() {
            @Override
            public void play() {
                System.out.println("抽象類實作匿名內部類");
            }
        });

        //呼叫引數為介面的方法
        n.m3(new Lenovo());//Mouse m=new Lenove();//向上轉型
        n.m3(new Mouse() {
            @Override
            public void click() {
                System.out.println("介面實作匿名內部類");
            }
        });
    }

}

作業

1、內部類的使用：
（1）定義一個外部類Father，有成員變數name并賦一個初值，
（2）定義一個內部類Child，并定義一個getValue()方法，在方法中呼叫外部類Father的name變數，
（3）定義一個測驗類，在測驗類的main方法中創建Child物件，并呼叫getValue()方法

package com.ice.test11;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class Father {
    private String name = "max";

    class Child {
        public void getValue() {
            System.out.println(Father.this.name);
        }
    }

    public void getValue() {
        Child c = new Child();
        c.getValue();
    }
}

package com.ice.test11;

/**
 * @author lucky_ice
 * 著作權：****
 * 版本：version 1.0
 */
public class Test {
    public static void main(String[] args) {
        Father f = new Father();
        f.getValue();
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/120113.html

標籤：面向對象

上一篇：廣州公司筆/面經

下一篇：需求分析第一章