标签：语句 sys public art 密码 final 实例 class 安全
内部类分别有成员内部类、局部内部类、匿名内部类、静态内部类，接下来将分别介绍。
public class Demo1 {
innerclass in=new innerclass(); //在成员内部类所在的外类中实例化成员内部类
public void outf() {
in.inf(); //因为in是成员内部类的实例化，所以才可以调用
}
class innerclass{//成员内部类
int y=0;
public innerclass() {//成员内部类的构造方法
}
public void inf() {
System.out.println("内部类方法y="+y);
}
}
public static void main(String[] args) {
Demo1 iDemo1=new Demo1();
iDemo1.outf();
Demo1.innerclass j= iDemo1.new innerclass(); //非外部类位置成员内部类实例化的方法（即首先要实例化一个外部类）
Demo1.innerclass k=new Demo1().new innerclass(); //实例化外部类和构造内部类一起写
j.inf();
}
}
public class Demo2 {
public outinterface action(String x) {//要把这个类返回出去，就需要通过接口，因为内部类在外部作用域中不存在
class innerclass2 implements outinterface{
public innerclass2(String s) {
s = x;
System.out.println(s);
}
}
return new innerclass2("do");
}
public static void main(String[] args) {
Demo2 demo2=new Demo2();
demo2.action("局部内部类");
}
}
interface outinterface{ //专门用来给局部内部类做向上转型的父接口的操作
}
局部内部类只能在所在的方法体作用域内进行实例化，而如果要在所在方法体返回该类，就要通过接口向上转型的操作。（如同上处代码）
2. 作用
在某些情况下，某些业务逻辑需要临时处理，这些业务逻辑只在这里使用又可以封装成一个类的话，而又没必要重新建个文件，所以可以这写一个局部内部类来处理。然后，在我的记忆中，java代理模式中有用到局部内部类，在方法中直接实现接口，返回代理对象，简单而又方便。
静态字段的内部类，和静态方法并列。
public class Demo3 {
static int x=100;
static class innerclass3 {
void action() {
x=1; //x必须是静态字段
}
public static void main(String[] args) {
System.out.println("我是静态内部类");
}
}
}
//代码示例一
public class Demo4 {
public Outinterface2 action() {
//return new innerclass2(); ①
return new Outinterface2() { //②
private int i = 0;
public int getvalue() {
return i;
}
};
}
}
interface Outinterface2 {
}
class innerclass2 implements Outinterface2{//①
private int i = 0;
public int getvalue() {
return i;
}
}
//代码示例二
interface Inner {
public abstract void show();
}
?
class Outer {
public void method(){
new Inner() {
public void show() {
System.out.println("HelloWorld");
}
}.show();
}
}
?
class Test {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
//如果匿名内部类中有多个方法又该如何调用呢？
Inter i = new Inner() { //多态，因为new Inner(){}代表的是接口的子类对象
public void show() {
System.out.println("HelloWorld");
}
};
上述代码①和②的作用是相同的。由此也可以解释一下匿名内部类的作用。
作为一个类的编写者，我们很显然需要对这个类的使用访问者的访问权限做出一定的限制，我们需要将一些我们不愿意让别人看到的操作隐藏起来，如果我们的内部类不想轻易被任何人访问，可以选择使用private修饰内部类，这样我们就无法通过创建对象的方法来访问，想要访问只需要在外部类中定义一个public修饰的方法，间接调用。
public interface Demo {
void show();
}
class Outer {
private class test implements Demo {
public void show() {
System.out.println("密码备份文件");
}
}
public Demo getInner() {
return new test();
}
}
我们之前的学习知道，java是不可以实现多继承的，一次只能继承一个类，我们学习接口的时候，有提到可以用接口来实现多继承的效果，即一个接口有多个实现，但是这里也是有一点弊端的，那就是，一旦实现一个接口就必须实现里面的所有方法，有时候就会出现一些累赘，但是使用内部类可以很好的解决这些问题。
public class Demo1 {
public String name() {
return "BWH_Steven";
}
}
public class Demo2 {
public String email() {
return "xxx.@163.com";
}
}
public class MyDemo {
private class test1 extends Demo1 {
public String name() {
return super.name();
}
}
?
private class test2 extends Demo2 {
public String email() {
return super.email();
}
}
?
public String name() {
return new test1().name();
}
?
public String email() {
return new test2().email();
}
?
public static void main(String args[]) {
MyDemo md = new MyDemo();
System.out.println("我的姓名:" + md.name());
System.out.println("我的邮箱:" + md.email());
}
}
我们编写了两个待继承的类Demo1和Demo2，在MyDemo类中书写了两个内部类，test1和test2两者分别继承了Demo1和Demo2类，这样MyDemo中就间接的实现了多继承。
我们用通俗讲解就是说在Java中，通常就是编写一个接口，然后你来实现这个接口，然后把这个接口的一个对象作以参数的形式传到另一个程序方法中， 然后通过接口调用你的方法，匿名内部类就可以很好的展现了这一种回调功能。
public interface Demo {
void demoMethod();
}
public class MyDemo{
public test(Demo demo){
System.out.println("test method");
}
public static void main(String[] args) {
MyDemo md = new MyDemo();
//这里我们使用匿名内部类的方式将接口对象作为参数传递到test方法中去了
md.test(new Demo){
public void demoMethod(){
System.out.println("具体实现接口")
}
}
}
}
编写一个接口Demo
public interface Demo {
void test();
}
编写一个类 MyDemo
public class MyDemo {
?
public void test() {
System.out.println("父类的test方法");
}
}
两者的方法名字都是test，下面编写一个测试类；
public class DemoTest extends MyDemo implements Demo {
public void test() {
}
}
这样的话我就有点懵了，这样如何区分这个方法是接口的还是继承的，所以我们使用内部类解决这个问题
public class DemoTest extends MyDemo {
?
?
private class inner implements Demo {
public void test() {
System.out.println("接口的test方法");
}
}
public Demo getIn() {
return new inner();
}
public static void main(String[] args) {
//调用接口而来的test()方法
DemoTest dt = new DemoTest();
Demo d = dt.getIn();
d.test();
//调用继承而来的test()方法
dt.test();
}
}
?
//运行结果
接口的test方法
父类的test方法
标签：语句 sys public art 密码 final 实例 class 安全
原文地址：https://www.cnblogs.com/hackerstd/p/12547503.html
