5.2

JAVA

内部类

java内部类分为： 非静态内部类、静态内部类、局部内部类、匿名内部类

内部类的共性：

(1)内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。

(2)内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的 。

(3)内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量 。

非静态内部类

当一个类作为另一个类的非静态成员，则这个类就是一个非静态内部类。创建非静态内部类是很容易的，只需要定义一个类让该类作为其他类的非静态成员。

该非静态内部类和成员变量或者成员方法没有区别，同样可以在非静态内部类前面加可以修饰成员的修饰符。

创建非静态内部类的基本语法如下所示：

class OutClass {
    class InClass {
        //内部类成员
    }
    //外部类成员
}

局部内部类的作用范围是和局部变量的作用范围相同的，只在局部中起作用，所以对局部内部类进行访问时，只能在该局部内部类的作用范围内。

静态内部类就是在外部类中扮演一个静态成员的角色。创建静态内部类的形式和创建非静态内部类的形式很相似的，只是需要将该内部类使用static修饰成静态的形式。使用static修饰类，这在正常类中是不可能的

在所有的内部类中最难的就应该是匿名内部类。匿名内部类从名字上看就知道是没有类名的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。使用匿名内部类有个条件，必须承接一个父类或实现一个接口

在外部类中访问内部类:

class OutClass {
    class InClass {    //创建非静态内部类
        int i = 5;    //内部类成员
    }
    public void fun() {    //外部类成员
        InClass in = new InClass();    //创建一个内部类对象
        int i = in.i;        //访问内部类成员
        System.out.println("InClass's var is: " + i);
    }
}
public class javatest { 
    public static void main(String args[ ]) {
         OutClass out = new OutClass();
         out.fun();
   }
}

编译运行结果为:

F:\gz\JAVA\nbl>java javatest
InClass's var is: 5

在main方法中，首先创建一个外部类对象，然后访问外部类的成员方法。在外部类的成员方法中，创建了一个内部类对象，然后使用内部类对象调用内部类的成员变量，从而得到结果。

编译该程序将产生三个class文件，分别是主类、外部类和内部类。内部类产生的class文件的名称为OutClass$InClass.class，在该名称中可以区分该内部类到底是哪一个类的内部类

不但可以在外部类中访问内部类，还可以在外部类外访问内部类。在外部类外访问内部类的基本语法如下所示

OutClass.InClass oi=new OutClass().new InClass();

所以要想创建内部类对象，首先要创建外部类对象，然后以外部类对象为标识来创建内部类对象

在内部类中访问外部类

在内部类中访问外部类，就像所有的同一个类中成员互相访问一样，这样是没有限制的，包括将成员声明为private私有的

class OutClass {
    int i = 8;    //外部类成员变量
    class InClass {    //创建非静态内部类
        int i = 9;
        OutClass oc = new OutClass();
        public void fun() {    //内部类成员
            System.out.println("InClass's var is: " + i);
            System.out.println("OutClass's var is: " + oc.i);
        }
    }
}
public class javatest1 { 
    public static void main(String args[ ]) {
        OutClass oc = new OutClass();    //创建外部类对象
        OutClass.InClass ic = oc.new InClass();    //创建内部类对象
        ic.fun();    //调用内部类中的成员
   }
}

编译运行得到：

F:\gz\JAVA\nbl>java javatest1
InClass's var is: 9
OutClass's var is: 8

在本程序中先定义了一个外部类的成员变量，接着定义了一个内部类的成员变量，这两个成员变量的名称是相同的。而在内部直接访问时，将访问的是内部类的成员变量。要想访问外部类成员变量，就需要首先创建一个外部类对象，然后使用该对象调用外部类成员变量

局部内部类

class OutClass {
    public void fun() {   
        class InClass {    //定义一个局部内部类
            int i = 5;    //局部内部类的成员变量
        }
        InClass ic = new InClass();
        System.out.println("InClass's var is: " + ic.i);
    }
}
public class javatest2 { 
    public static void main(String args[ ]) {
        OutClass oc = new OutClass();
        oc.fun();
   }
}

定义了一个局部内部类，并进行了对该局部内部类的访问。对该内部类进行访问必须在该内部类所在的方法中通过创建内部类对象来进行访问。这是因为这里的内部类是作为局部成员的形式出现的，只能在它所在的方法中进行调用

编译运行后得到：

F:\gz\JAVA\nbl>java javatest2
InClass's var is: 5

局部内部类中访问外部类成员变量

class OutClass {
    int i = 9;    //定义一个外部类的成员变量
    public void fun() {   
        class InClass {    //定义一个局部内部类
            public void Infun() {
                System.out.println("OutClass's var is: " + i);    //访问外部类中的成员变量
            }
        }
        InClass ic = new InClass();    //创建内部类对象
        ic.Infun();    //调用内部类中的成员方法
    }
}
public class javatest3 { 
    public static void main(String args[ ]) {
        OutClass oc = new OutClass();    //创建外部类对象
        oc.fun();    //调用内部类中的成员
   }
}

定义了一个局部内部类，在该局部内部类中定义了一个方法来访问外部类的成员变量

编译运行后得到:

F:\gz\JAVA\nbl>java javatest3
OutClass's var is: 9

在局部内部类中访问外部类的局部变量

和访问外部类的成员变量不同，在局部内部类中访问外部类中和局部内部类在同一局部的局部变量是不能够直接访问的

静态内部类

前面已经学习了非静态内部类，接下来就来学习什么是静态内部类。静态内部类就是在外部类中扮演一个静态成员的角色。创建静态内部类的形式和创建非静态内部类的形式很相似的，只是需要将该内部类使用static修饰成静态的形式。使用static修饰类，这在正常类中是不可能的。

语法格式如下:

class OutClass {
    static class InClass {
        //内部类成员
    }
    //外部类成员
}

在外部类中访问静态内部类和在外部类中访问非静态内部类一样的，只需要从成员间访问的角度就可以考虑到这一点

class OutClass {
    static class InClass {    //创建静态内部类
        int i = 5;    //内部类成员
    }
    public void OutFun() {    //外部类成员
        InClass ic = new InClass();    //创建一个内部类对象
        int ii = ic.i;    //访问内部类成员
        System.out.println("static InClass's var is: " + ii);
    }
}
public class javatest4 { 
    public static void main(String args[ ]) {
        OutClass oc = new OutClass();    //创建外部类对象
        oc.OutFun();    //调用内部类中的成员
   }
}

编译运行后得到：

F:\gz\JAVA\nbl>java javatest4
static InClass's var is: 5

在外部类中访问静态内部类和访问非静态内部类是相同的，但是在外部类中访问静态内部类和非静态内部类就不再相同。

因为静态内部类是外部类的静态成员，静态成员是不需要外部类对象而存在的，所以在外部类外，对静态内部类进行访问时是不需要创建外部类对象的

匿名内部类

在所有的内部类中最难的就应该是匿名内部类。匿名内部类从名字上看就知道是没有类名的内部类。

正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写

但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

创建匿名内部类的语法如下:

new InFather() {
    //匿名内部类
};

在创建匿名内部类的语法中，InFather是匿名内部类继承的父类的类名，使用new同时创建了匿名内部类的对象

abstract class Person {
    public abstract void eat();
}
 
class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}
public class test {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

编译运行结果如下:

F:\gz\JAVA\nbl>java test
eat something

上面是不使用匿名内部类来实现抽象方法，下面试试使用匿名内部类的基本实现

abstract class Person {
    public abstract void eat();
}
public class test1 {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

编译运行后得到:

F:\gz\JAVA\nbl>java test1
eat something

可以看到，我们直接将抽象类Person中的方法在大括号中实现了，这样便可以省略一个类的书写，并且匿名内部类还能用于接口上

在接口上使用匿名内部类

interface Person {
    public void eat();
}
public class test2 {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

运行结果:

F:\gz\JAVA\nbl>java test2
eat something

只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现

Thread类的匿名内部类实现

public class test3 {
    public static void main(String[] args) {
        Thread t = new Thread() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        t.start();
    }
}

运行结果:

F:\gz\JAVA\nbl>java test3
1 2 3 4 5

LINUX

系统性能监控命令

建立文件——cat

本意用来串接文件或显示文件的内容，但是若从标准输入接收数据并将其结果定向到一个新的文件中，则可以建立新的文件

cat 命令在编辑新的文件时只能从键盘接收数据，不能灵活地对文件的内容进行编辑，

显示所有在系统中注册的分区：cat /proc/partitions    命令中/proc/partitions 即为存放系统注册分区的文件

可以看出本系统中注册分区一共有5个区域，分别是：sda    sda1   sda2    dm-0   dm-1

查看当前系统的文件系统

cat /etc/fstab

监测文件/proc/interrupts' 的变化: watch -n1 'cat /proc/interrupts'

命令中 'cat /proc/interrupts' 即是查看文件的内容

由于文件/proc/interrupts 是随时间变化的，执行 watch -n1 即可把文件的变化显示出来

可以看出该文件的内容主要是 CPU 中断的相关信息

搜索文件中字符串——grep

可以使用正则表达式｛正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表通常被用来检索、替换那些符合某个模式(规则)的文本。｝搜索文本，并把匹配的行打印出来

grep 一般用于对其他命令的输出结果进行过滤以及查找特定字符串或者匹配一定模式的字符串在文件中的位置

显示系统可见的内存总量

grep MemTotal /proc/meminfo

该命令的针对性很强，即显示系统可见的内存总量

显示CPU信息

grep "model name" /proc/cpuinfo

命令中 model name  表示在输出信息中要显示 model name

/proc/cpuinfo 是存储了 CPU信息的文件

显示指定进程的信息，ps -ef 显示所有进程的简单信息，如果只想查看其中的某个进程或某些进程，则可以借助grep对输出结果进行过滤，如下假设只显示sshd 进程的情况

ps -ef | grep sshd