“黑马程序员”java面向对象基础_内部类

时间:2022-10-01 00:48:13

——-  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();
}
}

——-  android培训 java培训 、期待与您交流! ———