——- android培训 、 java培训 、期待与您交流！ ———
内部类:
什么是内部类?
内部类,其实就是将一个类定义在另一个类的里面,对里面那个类我们就称其为内部类(嵌套类,内置类)
内部类的划分:
1-成员内部类:定义在外部类的成员区域里,与成员变量,成员函数同级;
如:
class Outer{
int num;
void show(){ }
class Innter{ }
}
成员内部类特点:
a.可以被private,protected所修饰,而*类只能有public,和默认类修饰符
b.不能脱离外部类而使用,成员内部类依赖于外部类而存在,因为在该外部类以外创建该内部类要如下:
Outer.Inner in = new Outer.Inner(); //创建内部类的对象.
c.内部类对象可以访问外部类对象的任意成员,包括private所修饰的.
d.不能与外部类同名
c.不能有静态的成员.
2-静态内部类:在普通内部类前加static,与普通内部类的主要区别是:只能访问外部类的静态成员
如:
class Outer{
static int num;
void show(){ }
static class Innter{ } //要想访问外部类的num,其必须为static修饰
}
静态内部类的特点:
a.可以被private,protected所修饰,而*类只能有public,和默认类修饰符
b.不能脱离外部类而使用,成员内部类依赖于外部类而存在,因为在该外部类以外创建该内部类要如下:
Outer.Inner in = new Outer.Inner(); //创建内部类的对象.
c.可以访问外部类对象的任意成员,包括private所修饰的.
d.可以拥有非静态成员
e.只能访问外部类的静态成员
3-局部内部类:定义在方法体里面的类.
如:
class Outer{
static int num;
void show(){
class Innter{ }
}
}
局部内部类的特点:
a.有其有限的作用域,超出该作用于则无法使用
b.
可以访问外部类对象的任意成员,包括private所修饰的.
c.只能访问该方法体内被final修饰的常量.
定义在方法体中的变量会随着方法的退出而消亡,通过定义其为final变量，可以扩展其生命期.
d.
定义在代码块中的内部类只能使用在该block中定义的final变量
4-
匿名内部类:在某些情况下，我们只需要内部类的一个对象,而不需要该类的名字;前提:匿名内部类必须继承或实现一个外部类或接口,匿名内部类其实就是一个匿名子类对象
格式: new 父类 of 接口 {子类内容;}
如:
abstract class Demo {
abstract void show();
}
public void method(){
//以下相当于new Inner().show();
new Demo(){ //匿名内部类
void show(){
System.out.println("show---");
}
}.show();
}
匿名内部类的特点:
a.匿名内部类的实例化;意思就是说:创建一个实现(或继承)了
Demo类的对象
b:(保留以后补充);
匿名内部类通常使用的场景:
当函数参数shiite接口类型时,而且接口中的方法不超过三个,可以用匿名内部类和实际参数进行传递
内部类一般用于类的设计上
在分析事物时,发现该事物描述中还有事物,而且这个事物还在访问被描述事物的内容中,这时,就是还有的事物定义成内部类来描述
*如果内部类是静态的,那么它就是一个顶层类,简单来说就类似于一个外部类
实例一:
package notesforinnerclass;
//import innerclassdemo.Demo;
abstract class Demo {
abstract void show();
}
public class NotesForInnerClass {
public static void main(String[] args) {
Outer ou = new Outer();
ou.show();
ou.engine();
ou.send();
ou.method();
}
}
class Outer{
int num=1;
void show(){
System.out.println("这里是***外部类***中的show方法");
}
// class Outer{ //不能与外部类同名
//
// }
class Innter01{ //成员内部类
void show(){
System.out.println("这里是***成员内部类***Innter01中show方法");
}
}
static class Innter02{ //静态内部类
void show(){
System.out.println("这里是***静态内部类***Innter02中show方法");
}
}
void send(){
@SuppressWarnings("unused")
int a=1;
final int b=2;
@SuppressWarnings("unused")
class Innter03{ //局部内部类
void show(){
// a++; //不能访问非final修饰的方法成员
num++;
System.out.println("这里是send方法中的***局部内部类***Innter03的show方法不能访问方法中成员变量,只能访问方法中被final修饰的常量"+"num="+num+" b="+b);
}
}
Innter03 innt03 = new Innter03();
innt03.show();
}
public void method(){
//以下相当于new Inner().show();
new Demo(){ //匿名内部类
void show(){
System.out.println("这是***匿名内部类***中的show方法");;
}
}.show();
}
void engine() {
Innter01 innt01 = new Innter01();
innt01.show();
Innter02 innt02 = new Innter02();
innt02.show();
}
}
实例二:
package innerclassdemo;
class Outer {
int num = 7;
static class Inner {
void show(){
System.out.println("Inner show");
}
}
public void method(){
Inner in = new Inner();
in.show();
}
}
public class InnerClassDemo {
public static void main(String[] args) {
Outer ou = new Outer(); //创建外部类的对象
ou.method(); //调用method方法,该方法中创建了其内部类的对象
Outer.Inner in = new Outer.Inner(); //创建内部类的对象.
in.show();
}
}
实例三:
package innerclassdemo;
class Outer1 {
int num = 3;
class Inner { //局部内部类
int num = 4;
void show() {
int num = 5;
System.out.println(Outer1.this.num);
System.out.println(this.num);
System.out.println(num);
}
}
void method() {
new Inner().show();
}
}
public class InnerClassDemo2 {
public static void main(String[] args) {
Outer1 ou = new Outer1();
ou.method();
}
}
实例四:
package innerclassdemo;
import innerclassdemo.Outer.Inner;
/
* 内部类可以存放在局部位置上
/
class Outer3 {
int num = 3;
void method(){
final int x = 9;
class Inner {
void show(){
System.out.println("show..." + x);
}
}
Inner in = new Inner();
in.show();
}
}
public class InnerClassDemo3 {
public static void main(String[] args) {
new Outer3().method();
}
}
实例五:
package innerclassdemo;
//匿名内部类
abstract class Demo {
abstract void show();
}
class Outer4 {
int num = 4;
public void method(){
//以下相当于new Inner().show();
new Demo(){ //匿名内部类
void show(){
System.out.println("show---" + num);
}
}.show();
}
}
public class InnerClassDemo4 {
public static void main(String[] args) {
new Outer4().method();
}
}
实例六:
package innerclassdemo;
interface Inter {
void show1();
void show2();
}
//匿名内部类
public class InnerClassDemo5 {
public static void main(String[] args) {
System.out.println("Hello World");
show(new Inter() { //匿名内部类 .Inter 是接口 有两个方法 show1 ,show2
@Override
public void show1() {
System.out.println("inter show1");
}
@Override
public void show2() {
System.out.println("inter show2------");
}
});
}
public static void show(Inter in) { //接收inter类型的值
in.show1();
in.show2();
}
}
实例七:
package innerclassdemo;
//匿名内部类
class Outer6{
void method(){
new Object(){
public void show() {
System.out.println("show run111");
}
}.show();
// Object obj = new Object(){
// public void show() {
// System.out.println("show run222");
// }
// };
// obj.show(); //不能编译运行,因为匿名内部这个
// //子类被向上转型为了Object类型
// 这样就不能再使用子类的特有方法了
//
}
}
public class InnerClassDemo6 {
public static void main(String[] args) {
new Outer6().method();
}
}