内部类

内部类可以分为四类：普通内部类、静态内部类、匿名内部类、局部内部类

普通内部类：

public class a {
    class Student{
        
    }
}

内部类可以直接访问外部类的成员，包括私有成员。

外部类要访问内部类的成员必须要建立内部类的对象

 

 局部内部类：定义在某个局部范围中的类，其有效范围只限于方法内部

public class a {
    int outer = 10;
    public void outer(){
        System.out.println("外部类");
    }
    public void aa(){
        class Inner{
            int inner = 120;
            public void inner(){
                System.out.println("内部类");
                System.out.println(outer);
                outer();
            }
        }
        //创建局部内部类对象
        Inner a = new Inner();
        System.out.println(a.inner);
        a.inner();
    }
}

public class aTest {
    public static void main(String[] args) {
        a a = new a();
        a.aa();
    }
}

 

 只需要创建外部类对象，调用所属方法即可访问局部内部类

静态内部类：使用static关键字修饰的成员内部类

public class a {
    static int outer = 10;
    static class Inner{
        int inner = 120;
        public void innerMethod(){
            System.out.println("内部类成员变量"+inner);
            System.out.println("外部类成员变量"+outer);
        }
    }
}
public class aTest {
    /*
    静态内部类
    外部类名.内部类名 对象名 = new 外部类名.内部类名();
     */
    public static void main(String[] args) {
        a.Inner inner = new a.Inner();
        inner.innerMethod();

    }
}

 

 

匿名内部类：

匿名内部类其实就是没有名称的内部类

一个接口的实现类作为方法参数传入，而是直接通过匿名内部类的形式传入一个接口类型参数，在匿名内部类中直接完成方法的实现

public interface Animal {
    public abstract void breach();
}
public class aTest {
    /*
    等号右边是匿名内部类，定义并创建该接口的子类对象
    等号左边是多态赋值，接口类型引用指向子类对象
     */
    public static void main(String[] args) {
       Animal a = new Animal(){

           @Override
           public void breach() {
               System.out.println("aaa");
           }
       };
       a.breach();
    }
}

 

JTable

JTable可以以表格的形式显示数据和编辑数据

JTable这个对象不能存储数据，他只管数据的表现

public class KCBData implements TableModel {
    private String[] title = {"周一","周二","周三","周四","周五","周六","周七"};

    private String[][] data = new String[8][7];

    public KCBData(){
        for (int i = 0; i <data.length; i++) {
            for (int j=0; j<data[i].length; j++) {
                data[i][j] = "";
            }
        }
    }

    @Override
    public int getRowCount() {
        return 8;
    }

    @Override
    public int getColumnCount() {
        return 7;
    }

    @Override
    public String getColumnName(int columnIndex) {
        return title[columnIndex];
    }

    @Override
    public Class<?> getColumnClass(int columnIndex) {
        return String.class;
    }

    @Override
    public boolean isCellEditable(int rowIndex, int columnIndex) {
        return true;
    }

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        return data[rowIndex][columnIndex];
    }

    @Override
    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
        data[rowIndex][columnIndex] = (String)aValue;
    }

    @Override
    public void addTableModelListener(TableModelListener l) {

    }

    @Override
    public void removeTableModelListener(TableModelListener l) {

    }
}

public class KCB {
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        JTable table = new JTable(new KCBData());
        JScrollPane pane = new JScrollPane(table);
        frame.add(pane);
        frame.pack();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

 

搜索

复制

标签：内部,int,void,public,JTable,new,class
来源： https://www.cnblogs.com/pengtianyang/p/16368863.html