内部类和外部类

最新推荐文章于 2024-01-04 16:10:29 发布

Pershings

最新推荐文章于 2024-01-04 16:10:29 发布

阅读量160

点赞数

本文链接：https://blog.csdn.net/Pershinggeng/article/details/116885819

版权

1.默认修饰符,private,protected,public修饰符他们的范围

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

private                   Y


默认修饰符               Y                   Y

protected Y Y Y

public Y Y Y Y

2.方法的形式参数是具体类型,抽象类,接口,实际参数如何传递
           方法的形式参数是具体类型:实际需要传递的该具体类对象
                           抽象类:实际参数需要传递该抽象类的子类对象
                           接口:实际参数需要传递该接口的子实现类对象

方法的返回值是具体类型,抽象类,接口,该方法需要如何返回
           方法返回值类型是引用类型:
                               具体类型:返回的是当前类的具体对象
                               抽象类:返回的是当前抽象类的子类对象
                               接口:返回的是接口的子实现类对象

           Java: 面向接口编程的
               把接口暴露出来 ---- 开发者去针对接口来完成自己的业务功能!

3.接口的成员特点
       成员变量:只能是常量:public static final
       成员方法:只能是抽象方法:public abstract
       没有构造方法

4.带包如何进行编译和运行

           方式1:手动方式
           1)进入java文件所在目录,然后编译 javac java源文件--->类名.class
           2)需要手动方式创建文件夹: package com.qf;
           3)把1)中产生的类名.class 放在qf文件夹下
           4)直接带包运行
                   java com.qf.类名;

           方式2:自动方式
           1)针对带包的java文件直接编译
               javac -d . java源文件----> com
                                               qf
                                                       类名.class
           2)   直接带包运行
                   java com.qf.类名;

                   针对不同包java文件---必须先导包:然后将被导入的类---->先进行编译
                   然后针对当前要执行类--使用自动方式进行编译和运行即可!

5.请阐述你对多态的理解? 应用方面如何使用
       多态:
               继承/重写/父类引用指向子类对象

               任何父类出现的地方,都可以使用子类型 Fu fu = new Zi() ;


               应用方面:
                       接口多态使用居多!(讲集合:List接口---->子类实现类之一:ArrayList)
                                   使用集合作为 "数据库"
                                   模拟用户登录/注册操作
           子类继承父类,在父类中是可以获取子类对象!(反射....)

           class Fu{

               //提供main方法
               // 类名.class属性----->直接获取子类的字节码文件对象:包名.Zi.class (反射技术)
           }

           class Zi extends Fu{
               public void method(){

               }
           }

在Java中,在类中可以定义一个类,内部类
* 在类A中,定义一个类B,
* 类B称为类A的"内部类"
* 类A称为类B的"外部类"
*
* 内部类的成员是可以访问外部类的成员,包括私有!
*
* 外部类的成员方法访问成员内部类的成员方法时候,必须创建内部类对象访问

class Outer{

    public int num = 10 ;
    private int num2 =100 ;

    //定义一个内部类
    class Inner{
        //成员方法
        public void show(){
            System.out.println(num);
            System.out.println(num2);
        }
    }
    //外部类的成员方法
    public void method(){
        //show() ;
        Inner inner = new Inner() ;
        inner.show();
    }
}

//测试类
public class OuterDemo {
    public static void main(String[] args) {
        //创建外部类对象
        Outer outer = new Outer() ;
        outer.method();



    }

}

内部类的分类:
* 成员内部类:
* 在一个类的成员位置中定义的类
* 局部内部类:
* 在一个类的局部位置中定义的类(方法中)

//外部类
class Outer2{

    //成员变量
    private int num = 10 ;
    //成员位置
    //成员内部类
  /*  class Inner2{

    }*/

  //外部类的成员方法
    public void method(){
        //局部位置
        //局部内部类
        class Inner{
               public void show(){
                   System.out.println(num);
               }
        }
    }
}


public class OuterDemo2 {
    public static void main(String[] args) {

    }
}

成员内部类:
* 在一个类的成员位置中定义的类
*
* 需求:测试类中直接访问成员内部类的成员方法:
*
* 访问的方式:
* 外部类名.内部类名对象名 = 外部类对象.内部类对象;
*
* 前提条件:这个成员内部类---是一个非静态的成员内部类!
*

//外部类
 class Outer3{
        //成员变量
    private int num = 100 ;

    private static int num2 = 20 ;


    //定义成员内部类
    class Inner3{
        //成员方法
        public void show(){
            System.out.println(num);
            System.out.println(num2);
        }
    }
}
//测试类
public class OuterDemo3 {
    public static void main(String[] args) {
        //要访问成员内部类Inner3里面的show方法

        //    外部类名.内部类名 对象名  = 外部类对象.内部类对象;
        Outer3.Inner3 oi = new Outer3().new Inner3() ;
        oi.show() ;
    }
}

关于成员内部类的修饰符

成员内部类可以被private修饰---保证数据的安全性:让外界不能new 来访问!

成员内部类也可以被static修饰:
* 它里面的成员访问外部类的成员特点:此时外部类的成员必须都是静态的
*
* 外界类中要访问静态的成员内部类的成员方法:
* 需要将静态的成员内部类---->看成是外部类的静态成员
* 外部类名.内部类名对象名 = new 外部类名.内部类名() ;
*
* 非静态的成员内部类中,不能存在静态的成员---"冲突了"

class Outer4{

        //一个非静态的变量
    private int num = 20 ;
    //一个静态变量
    public static int num2 = 30 ;

    //成员内部类----->加入static修饰
    static class Inner4{


        //定义一个非静态的成员方法
        public void show(){
           // System.out.println(num);
            System.out.println(num2);
        }

        //定义一个静态的成员方法show2
        public static void show2(){
          //  System.out.println(num);
            System.out.println(num2);
        }
    }
}
//测试类
public class OuterDemo4 {
    public static void main(String[] args) {
            //需求:要访问静态的成员内部类中的show,show2方法?
        //外部类名.内部类名 对象名  = 外部类对象.内部类对象;
       // Outer4.Inner4 oi = new Outer4().new Inner4() ;

        //外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
        Outer4.Inner4 oi = new Outer4.Inner4() ;
        oi.show() ;
        oi.show2() ;

        System.out.println("----------------------------");
        //show2()方法的另一种方式:类名访问: 静态的方法
        //把静态的成员内部类----> 就是外部类的静态成员
        Outer4.Inner4.show2() ;

    }
}

局部内部类:在外部类的成员方法中定义的类,(非静态的)
* 直接可以访问外部类的包括私有
*
*
* 局部内部类访问局部变量的时候:
* 此时局部变量已经是常量了:被final修饰
* jdk7以前:如果局部变量不显示的添加final关键字,编译报错!
* jdk8版本,对当前局部内部类访问局部变量---此时变量在内存中已经优化为final了,不需要显示添加这个关键字!
*
*
* 为什么局部变量:是一个常量呢?
* 当前外部类对象调用外部类的成员方法时候,num2随着method的方法调用而存在
*
* 随着method调用完毕,应该消失掉了;但是局部内部类的成员方法还在使用这个num2,所以
* JVM进行了优化,JDK8以后这个变量自动回加入final定义,所以这个必须是一个常量,那么内部类才能使用它!

//定义一个外部类
class Outer5{

    private int num = 20 ;

    public void method(){
        //局部变量
        int num2 = 50 ;// 常量  --->jdk8以后 :局部内部类访问这个局部变量,可以不书写final,隐藏的!

        //局部内部类
        class Inner5{
            public void show(){
                System.out.println(num);//Outer5.this.num:外部类的this限定
                System.out.println(num2); //常驻内存--"常量池中"
            }
        }

        Inner5 inner5 = new Inner5() ;
        inner5.show();
    }
}

public class OuterDemo5 {
    public static void main(String[] args) {

        //访问Inner5中的show
        //创建外部类对象.调用method
        Outer5 outer5 = new Outer5() ;
        outer5.method();
    }
}