10. 面向对象 -- 内部类

于 2017-11-28 18:28:45 发布
阅读量339 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： JavaSE 文章标签： 形式参数和返回值引用类型的问题 权限修饰符 内部类 成员内部类的面试题 匿名内部类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/minkeyto/article/details/78657858
本文深入讲解Java中的形式参数、返回值引用类型、包管理、权限修饰符等关键概念，并介绍了内部类的使用方法及注意事项。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

1:形式参数和返回值引用类型的问题(掌握)

2:包(理解)

3:导包(掌握)

4:权限修饰符(掌握)

5:常见的修饰符(理解)

6:内部类(掌握)

1:形式参数和返回值引用类型的问题(掌握)

(1)形式参数：

              类名：需要该类的对象

              抽象类名：需要该类的子类对象

              接口名：需要该接口的实现类对象

 

abstract class Person {
publicabstract void study();
}
class PersonDemo {
publicvoid method(Person p) {//p; p = new Student(); Person p = new Student(); //多态
        p.study();
}
}
//定义一个具体的学生类
class Student extends Person {
publicvoid study() {
        System.out.println("GoodGood Study,Day Day Up");
}
}
class PersonTest {
publicstatic void main(String[] args) {
        //目前是没有办法的使用的
        //因为抽象类没有对应的具体类
        //那么，我们就应该先定义一个具体类
        //需求：我要使用PersonDemo类中的method()方法
        PersonDemopd = new PersonDemo();
        Personp = new Student();
        pd.method(p);
  }
}

(2)返回值类型：

              类名：返回的是该类的对象

              抽象类名：返回的是该类的子类对象

              接口名：返回的是该接口的实现类的对象

 

abstract class Person {
publicabstract void study();
}
class PersonDemo {
publicPerson getPerson() {
        //Personp = new Student();
        //returnp;
        returnnew Student();
}
}
class Student extends Person {
publicvoid study() {
        System.out.println("GoodGood Study,Day Day Up");
}
}
class PersonTest2 {
publicstatic void main(String[] args) {
        //需求：我要测试Person类中的study()方法
        PersonDemopd = new PersonDemo();
        Personp = pd.getPerson(); //new Student(); Person p = new Student(); 多态
        p.study();
}
}

(3)链式编程

              对象.方法1().方法2().......方法n();

              这种用法：其实在方法1()调用完毕后，应该一个对象；

                           方法2()调用完毕后，应该返回一个对象。

                              方法n()调用完毕后，可能是对象，也可以不是对象。

 

class Student {
publicvoid study() {
        System.out.println("GoodGood Study,Day Day Up");
}
}
class StudentDemo {
publicStudent getStudent() {
        returnnew Student();
}
}
class StudentTest3 {
publicstatic void main(String[] args) {
        //如何调用的呢?
        StudentDemosd = new StudentDemo();
        //Students = sd.getStudent();
        //s.study();
        //大家注意了
        sd.getStudent().study();
}
}

2:包(理解)

       (1)其实就是文件夹

       (2)作用：

                            A:其实就是文件夹

              B:作用

                     a:把相同的类名放到不同的包中

                     b:对类进行分类管理

       举例：

              学生：增加，删除，修改，查询

              老师：增加，删除，修改，查询

              ...

              方案1：按照功能分

                     cn.itcast.add

                            AddStudent

                            AddTeacher

                     cn.itcast.delete

                            DeleteStudent

                            DeleteTeacher

                     cn.itcast.update

                            UpdateStudent

                            UpdateTeacher

                     cn.itcast.find

                            FindStudent

                            FindTeacher

              方案2：按照模块分

                     cn.itcast.teacher

                            AddTeacher

                            DeleteTeacher

                            UpdateTeacher

                            FindTeacher

                     cn.itcast.student

                            AddStudent

                            DeleteStudent

                            UpdateStudent

                            FindStudent

       (3)包的定义(掌握)

              package 包名;

              多级包用.分开。

       (4)注意事项：(掌握)

              A:package语句必须在文件中的第一条有效语句

              B:在一个java文件中，只能有一个package

              C:如果没有package，默认就是无包名

       (5) 带包的编译和运行：

              A:手动式

                     a:编写一个带包的java文件。

                     b:通过javac命令编译该java文件。

                     c:手动创建包名。

                     d:把b步骤的class文件放到c步骤的最底层包

                     e:回到和包根目录在同一目录的地方，然后运行

                            带包运行。

              B:自动式

                     a:编写一个带包的java文件。

                     b:javac编译的时候带上-d即可

                            javac -d .HelloWorld.java

                     c:回到和包根目录在同一目录的地方，然后运行

                            带包运行。

3:导包(掌握)

       (1)我们多次使用一个带包的类，非常的麻烦，这个时候，Java就提供了一个关键字import。

       (2)格式：

              import 包名...类名;

              另一种：       import 包名...*;(不建议)

       (3)package,import,class的顺序

              package > import > class

面试题：

         package,import,class有没有顺序关系?

         有。

         package > import >class

         Package:只能有一个

         import:可以有多个

         class:可以有多个，以后建议是一个

4:权限修饰符(掌握)

       (1)权限修饰符

                                   本类       同一个包下    不同包下的子类    不同包下的无关类

              private           Y

              默认               Y                   Y

              protected      Y                   Y                   Y

              public            Y                   Y                   Y                          Y

       (2)这四种权限修饰符在任意时刻只能出现一种。

              public class Demo {}           

 

5:常见的修饰符(理解)

       (1)分类：

              权限修饰符：private,   默认,      protected,       public

              状态修饰符：static,      final

              抽象修饰符：abstract

       (2)常见的类及其组成的修饰

              类：

                     权限修饰符：默认,public

状态修饰符：final

抽象修饰符：abstract

                     常用的：public

              成员变量：

                     权限修饰符：private,   默认,      protected,       public,

状态修饰符：static,      final

                     常用的：private

              构造方法：

                     状态修饰符：private,   默认,      protected,       public

                     常用的：public

              成员方法：

                     权限修饰符：private,   默认,      protected,       public

状态修饰符：static,      final

抽象修饰符：abstract

                     常用的：public

       (3)另外比较常见的：

              public static final int X = 10;

              public static void show() {}

              public final void show() {}

              public abstract void show();

6:内部类(掌握)

      (1)把类定义在另一个类的内部，该类就被称为内部类。

              举例：把类B定义在类A中，类B就被称为内部类。

      (2)内部类的访问规则

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

              B:外部类要想访问内部类成员，必须创建对象

 

class Outer {
   private int num = 10;
   class Inner {
          public void show() {
                 System.out.println(num);
          }
   }
   public void method() {
          //找不到符号
          //show();
  
          Inner i = new Inner();
          i.show();
   }
}
class InnerClassDemo {
   public static void main(String[] args) {
  
   }
}

      (3)内部类位置

              成员位置:在成员位置定义的类，被称为成员内部类。  

              局部位置:在局部位置定义的类，被称为局部内部类。

 

class Outer {
       privateint num = 10;
       //成员位置
       /*
       classInner {
       }
       */
       publicvoid method() {
              //局部位置
              classInner {
              }
       }
}
class InnerClassDemo2 {
       publicstatic void main(String[] args) {
       }
}

      (4)成员内部类

      A:private为了数据的安全性

 

class Body {
               privateclass Heart {
                      publicvoid operator() {
                             System.out.println("心脏搭桥");
                      }
               }
               publicvoid method() {
                      if(如果你是外科医生) {
                             Hearth = new Heart();
                             h.operator();
                      }
               }
        }
        //按照我们刚才的讲解，来使用一下
        Body.Heartbh = new Body().new Heart();
        bh.operator();
        //加了private后，就不能被访问了，那么，怎么玩呢?
        Bodyb =  new Body();
        b.method();

     B:static为了访问的方便性

注意：静态内部类访问的外部类数据必须用静态修饰。

成员内部类不是静态的：

                     外部类名.内部类名对象名 = new 外部类名().new 内部类名();

 

class Outer {
privateint num = 10;
classInner {
        publicvoid show() {
               System.out.println(num);
        }
}
}
class InnerClassDemo3 {
publicstatic void main(String[] args) {
       //需求：我要访问Inner类的show()方法
        //Inneri = new Inner();
        //i.show();
        //格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
        Outer.Inneroi = new Outer().new Inner();
        oi.show();
}
}

成员内部类是静态的：

                     外部类名.内部类名对象名 = new 外部类名.内部类名();

 

class Outer {
privateint num = 10;
privatestatic int num2 = 100;
//内部类用静态修饰是因为内部类可以看出是外部类的成员
publicstatic class Inner {
        publicvoid show() {
               //System.out.println(num);
               System.out.println(num2);
        }
        publicstatic void show2() {
               //System.out.println(num);
               System.out.println(num2);
        }           
}
}
class InnerClassDemo4 {
publicstatic void main(String[] args) {
        //使用内部类
        //限定的新静态类
        //Outer.Inneroi = new Outer().new Inner();
        //oi.show();
        //oi.show2();
        //成员内部类被静态修饰后的访问方式是:
        //格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inneroi = new Outer.Inner();
        oi.show();
        oi.show2();
       
        //show2()的另一种调用方式
        Outer.Inner.show2();
}
}

(5)成员内部类的面试题(填空)

注意：    1:内部类和外部类没有继承关系。

              2:通过外部类名限定this对象

                     Outer.this

              30,20,10

 

class Outer {
    public int num = 10;
    class Inner {
           public int num = 20;
           public void show() {
                  int num = 30;
                  System.out.println(num);
                  System.out.println(this.num);
                  //System.out.println(newOuter().num);
                  System.out.println(Outer.this.num);
           }
    }
}
class InnerClassTest {
    public static voidmain(String[] args) {
           Outer.Inner oi = newOuter().new Inner();
           oi.show();
    }    
}

(6)局部内部类

局部内部类

            A:可以直接访问外部类的成员

            B:在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

面试题：局部内部类访问局部变量的注意事项?

              A:局部内部类访问局部变量必须加final修饰。

              B:为什么呢?

                     因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。

                     所以，堆内存还是用该变量，而该变量已经没有了。

                     为了让该值还存在，就加final修饰。

                     通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。

 

class Outer {
    privateint num  = 10;
    publicvoid method() {
           //intnum2 = 20;
           //finalint num2 = 20;
           classInner {
                  publicvoid show() {
                         System.out.println(num);
                         //从内部类中访问本地变量num2; 需要被声明为最终类型
                         System.out.println(num2);//20
                  }
           }
           //System.out.println(num2);
           Inneri = new Inner();
           i.show();
    }
}
class InnerClassDemo5 {
    publicstatic void main(String[] args) {
           Outero = new Outer();
           o.method();
    }
}

(7)匿名内部类(掌握)

              A:是局部内部类的简化形式

              B:前提：存在一个类或者接口

              C:格式:

                     new类名或者接口名() {

                            重写方法;

                     }

              D:本质：

                     其实是继承该类或者实现接口的子类匿名对象

 

interface Inter {
     publicabstract void show();
     publicabstract void show2();
}
class Outer {
     publicvoid method() {
            //一个方法的时候
            /*
            newInter() {
                   publicvoid show() {
                          System.out.println("show");
                   }
            }.show();
            */
            //二个方法的时候
            /*
            newInter() {
                   publicvoid show() {
                          System.out.println("show");
                   }
                   publicvoid show2() {
                          System.out.println("show2");
                   }
            }.show();
           
            newInter() {
                   publicvoid show() {
                          System.out.println("show");
                   }
                   publicvoid show2() {
                          System.out.println("show2");
                   }
            }.show2();
            */
            //如果我是很多个方法，就很麻烦了
            //那么，我们有没有改进的方案呢?
            Interi = new Inter() { //多态
                   publicvoid show() {
                          System.out.println("show");
                   }
                   publicvoid show2() {
                          System.out.println("show2");
                   }
            };
            i.show();
            i.show2();
     }
}
class InnerClassDemo6 {
     publicstatic void main(String[] args) {
            Outero = new Outer();
            o.method();           // show    show2
     }
}

(8)匿名内部类在开发中的使用

              我们在开发的时候，会看到抽象类，或者接口作为参数。

              而这个时候，我们知道实际需要的是一个子类对象。

              如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

 

              interface Person {
                     public abstract voidstudy();
              }
              class PersonDemo {
                     public void method(Personp) {
                            p.study();
                     }
              }
              class PersonTest {
                     public static voidmain(String[] args) {
                            PersonDemo pd = newPersonDemo();
                            pd.method(newPerson() {
                                   public voidstudy() {
                                          System.out.println("好好学习，天天向上");
                                   }
                            });
                     }
              }

 

(9)匿名内部类的面试题(补齐代码)

 

                     interface Inter { void show(); }
                     classOuter { //补齐代码 }
                     classOuterDemo {
                            publicstatic void main(String[] args) {
                                     Outer.method().show();
                              }
                     }
                     要求在控制台输出”HelloWorld”
 
interface Inter {
     voidshow();
     //publicabstract
}
class Outer {
     //补齐代码
     publicstatic Inter method() {
            //子类对象 -- 子类匿名对象
            returnnew Inter() {
                   public void show() {
                          System.out.println("HelloWorld");
                   }
            };
     }
}
class OuterDemo {
     publicstatic void main(String[] args) {
            Outer.method().show();
            /*
                   1:Outer.method()可以看出method()应该是Outer中的一个静态方法。
                   2:Outer.method().show()可以看出method()方法的返回值是一个对象。
又由于接口Inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。
            */
     }
}

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

靈熙雲

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值