內部類

時間  2020-09-26
標籤 部類 简体版
原文   原文鏈接

匿名類

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);
    }
}

執行結果：java

類加載時執行了而且被執行一次
構造器被執行
構造器被執行
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）定義一個外部類Father，有成員變量name並賦一個初值。
（2）定義一個內部類Child，並定義一個getValue()方法，在方法中調用外部類Father的name變量。
（3）定義一個測試類，在測試類的main方法中建立Child對象，並調用getValue()方法dom

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();
    }
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程