Java 四种内部类

静态内部类：类中静态类

成员内部类：类中非静态类

局部内部类：类中方法中有名字的类

匿名内部类：类中方法中无名的类

 

引言：在Java中通常情况下，一个类中会有属性和方法，但还可以包含内部类，内部类可以在类中还可以在方法中。

 

　　1.  在类中的内部类：

　　　　1)  静态内部类：在类中的静态类，静态内部类中的方法只能访问外部类中的静态成员变量，非静态变量不能访问，

　　　　　　创建静态内部类的对象可以通过“外部类.内部类名（）”完成。

　　　　参见：com.oop.ch14.StaticInnerTest

package com.oop.ch14;

/**
 * 练习”静态内部类“的创建和使用
 *
 */
public class StaticInnerTest {
    public static void main(String[] args) {
        //创建静态内部类的对象来调用其中的方法
        StaticInner.Inner inner = new StaticInner.Inner();
        inner.view();
    }
}

/**
 * 外部类：其中包含了内部类（静态内部类）
 *
 */
class StaticInner{
    static String name = "张三";
    Integer age = 20;
    
    /**
     * 定义一个内部类：其中有一个方法，方法中会访问外部类的属性
     */
    static class Inner{
        public void view() {
            //在静态内部类中只能访问外部类中静态的成员变量name；非静态的age无法访问。
            //System.out.println("age:" + age);
            System.out.println("name:" + name);
        }
    }
}

　　　　2)  成员内部类：在类中的非静态类，成员内部类中的方法能访问外部类中的静态成员变量和非静态变量，

　　　　　　创建成员内部类的对象可以通过先创建外部类的对象，再通过“外部类的对象.new 成员内部类名（）”完成。

　　　　参见：com.oop.ch14.MemberInnerTest

package com.oop.ch14;

/**
 * 练习”成员内部类“的创建和使用
 * 成员内部类中的方法能访问外部类中的静态成员变量和非静态变量，
 * 创建成员内部类的对象可以通过：
 * 先创建外部类的对象，
 * 再通过“外部类的对象.new 成员内部类名（）”完成。
 *
 */
public class MemberInnerTest {
    public static void main(String[] args) {
        //创建外部类的对象
        MemberInner memberInner = new MemberInner();
        //创建成员内部类的对象来调用其中的方法
        MemberInner.Inner inner =  memberInner.new Inner();
        inner.view();
    }
}

/**
 * 外部类：其中包含了内部类（成员内部类）
 *
 */
class MemberInner{
    static String name = "张三";
    Integer age = 20;
    
    /**
     * 定义一个内部类：其中有一个方法，方法中会访问外部类的属性
     */
    public class Inner{
        public void view() {
            /**
             * 成员内部类中的方法能访问外部类中的静态成员变量和非静态变量
             */
            System.out.println("age:" + age);
            System.out.println("name:" + name);
        }
    }
}

　　2.  在方法中的内部类：

　　　　1)  局部内部类：在方法中，该类有名称，在局部内部类中，可以定义方法，可以访问外部类的成员变量，

　　　　　　在外部类的方法中可以直接创建内部类的对象并调用内部类的方法。

　　　　　　在测试类中只需要创建外部类的对象就可以调用外部类的方法，同时也就调用了内部类的方法。

　　　　参见：com.oop.ch14.PartInnerTest

package com.oop.ch14;

import com.oop.ch14.StaticInner.Inner;

/**
 * 练习使用”局部内部类“
 *
 */
public class PartInnerTest {
    public static void main(String[] args) {
        //创建外部类的对象，调用外部类的方法，会自动调用内部类的方法
        PartInner partInner = new PartInner();
        partInner.view();
    }
}

class PartInner{
    //外部类的成员变量
    String name = "外部类的成员变量";
    Integer age = 18 ;
    /**
     * 外部类的方法
     */
    public void view() {
        //声明为final，放置多次调用后被修改
        final String name = "内部类的成员变量";
        System.out.println("外部类的view()的局部变量name的值：" + name);
        /**
         * 局部内部类
         *局部内部类：在方法中，该类有名称，在局部内部类中，可以定义方法，可以访问外部类的成员变量，
         *在外部类的方法中可以直接创建内部类的对象并调用内部类的方法。
         *在测试类中只需要创建外部类的对象就可以调用外部类的方法，同时也就调用了内部类的方法。
         */
        class Inner{
            public void innerView() {
                System.out.println("外部类方法中Inner内部类的方法innerView()输出的name:" + name);
            }
        }
        
        Inner inner = new Inner();
        inner.innerView();
    }
    
}

　　　　2)  匿名内部类：在方法中，该类没有名称，但是它可以继承某个父类或实现某些接口，

　　　　　　同时也可以实现父类或接口中的方法，从而达到想实现的任务。

　　　　参见：com.oop.ch14.CardLayoutTest.main(String[])

　　　　　　javax.swing.AbstractButton.addActionListener(ActionListener)

package com.oop.ch14;


import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;


/**
 *练习使用卡片布局管理器 
 *
 *将组件元素放置在同一个位置，通过“事件”触发切换。
 */
public class CardLayoutTest  {
    static CardLayout cardLayout =  new CardLayout();
    static JPanel jp_images = new JPanel(cardLayout);
    
    public static void main(String[] args) {
        JFrame jFrame = new JFrame("卡片布局管理器");
        //1、定义需要的组件元素：面板、按钮
        JPanel jp_image1,jp_image2,jp_image3;
        jp_image1 = new JPanel();
        jp_image2 = new JPanel();
        jp_image3 = new JPanel();
        //设置图片面板的背景，模拟在卡片上放置一张图片
        jp_image1.setBackground(Color.RED);
        jp_image2.setBackground(Color.GREEN);
        jp_image3.setBackground(Color.BLUE);
        //创建放置卡片的面板，同时将卡片布局管理器传入其中
        //jp_images = new JPanel(cardLayout);
        //将放置了图片的子面板放置到jp_iamges中
        jp_images.add(jp_image1);
        jp_images.add(jp_image2);
        jp_images.add(jp_image3);
        //定义jp_button面板放置按钮
        JPanel jp_button;
        jp_button = new JPanel();
        //准备两个按钮
        JButton jb_pre,jb_next;
        jb_pre = new JButton("上一张");
        jb_next = new JButton("下一张");
        //将按钮放置到面板中
        jp_button.add(jb_pre,BorderLayout.WEST);
        jp_button.add(jb_next,BorderLayout.EAST);
        
        //2、将已经包含了组件元素的两个面板放置到窗体中
        jFrame.add(jp_images);
        jFrame.add(jp_button, BorderLayout.SOUTH);
        
        
        //3、设置JFrame窗体的一些参数
        //设置在关闭窗体时默认要执行的操作，通常时退出程序本身
        jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //设置窗体起始位置、宽高
        jFrame.setBounds(200, 150, 400, 300);
        //设置窗体可见性
        jFrame.setVisible(true);
        
        /**
         * 4、给上一张、下一张两个按钮添加点击事件
         * 具体实施时需要通过”匿名内部类“来完成
         * “匿名内部类”是一个方法中的一个类
         * 但它没有名字，他要实现ActionListener接口，并实现其中的监听方法
         */
        jb_pre.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                cardLayout.previous(jp_images);
            }
            
        });
        
        jb_next.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                cardLayout.next(jp_images);
            }
            
        });
        
    }
    
/*
    //如果实现ActionListener接口可以用实现方法的方式做
    @Override
    public void actionPerformed(ActionEvent e) {
        
        
    }*/
}