非静态类
两者都是非静态类可以互相访问,内部类访问外部类没有疑问,就像是一个方法(这里只内部类)访问类中的变量一样;但是,外部类的成员也可以访问内部类的内容,但是亲测必须实例了这个内部类才可以使用(具体原因去查大佬们写的博客)。
方法外只能对定义的变量赋值,不可对游离变量赋值(功底弱):

错误示例:
注:突发奇想那一个类里面的方法定义的私有变量类可以访问到吗,然后发现方法里不能加权限作用域。
上代码:
package com.it.demo03;
public class MyTest1 {
    private String  s = "yyy";
     class Inner{
        private String  u = "uuu";
        public Inner(){
        }
        public void gets(){
            System.out.println(s);
        }
    }
    public void getu() {
         Inner inner = new Inner();
        System.out.println(inner.u);
    }
/*
    //方法中内部不不能加权限作用域,方法里面定义的变量是只能方法使用局部变量
    public void virtuainner(){
        private String vin = "vin";
    }
    */
}
class Test2{
    public static void main(String[] args) {
        MyTest1 myTest1 = new MyTest1();
        MyTest1.Inner inner = myTest1.new Inner();
        inner.gets();
        myTest1.getu();
    }
}
静态类:
效果相似:
package com.it.demo03;
public class MyTest2 {
    private static String  s = "yyy";
    static class Inner{
        private static String  u = "uuu";
        public Inner(){
        }
        public static void gets(){
            System.out.println(s);
            s = "us";
        }
    }
    public static void getu() {
//        Inner inner = new Inner();
//        System.out.println(inner.u);
        System.out.println(Inner.u);
    }
}
class Test3{
    public static void main(String[] args) {
        MyTest2.getu();
        MyTest2.Inner.gets();
    }
}
静态内部类实现单例模式:
pacpackage com.it.demo02;
public class SingletonDemo05 {
    private volatile static SingletonDemo05 singletonDemo05 = null;
    public static void getsd(){
        System.out.println("getsd:"+singletonDemo05);
    }
    private SingletonDemo05(){}
    private static class Inner{
        public static SingletonDemo05 getSD(){
            if(singletonDemo05 == null){
                synchronized (SingletonDemo05.class){
                    if (singletonDemo05 == null)
                        singletonDemo05 = new SingletonDemo05();
                }
            }
            return singletonDemo05;
        }
    }
    public static SingletonDemo05 getSingletonDemo05(){
        return Inner.getSD();
    }
}
class Test4{
    public static void main(String[] args) {
        SingletonDemo05.getsd();
        SingletonDemo05 singletonDemo05 = SingletonDemo05.getSingletonDemo05();
        SingletonDemo05 singletonDemo051 = SingletonDemo05.getSingletonDemo05();
        System.out.println(singletonDemo05 == singletonDemo051);
        SingletonDemo05.getsd();
        System.out.println(singletonDemo05.hashCode());
        System.out.println(singletonDemo051.hashCode());
    }
}
 
                   
                   
                   
                   
                            
 
                             
                             本文探讨了Java中内外部类的访问机制,包括非静态内部类与静态内部类的区别,以及如何通过静态内部类实现单例模式。通过代码示例详细解析了外部类与内部类之间的相互访问,以及在不同情况下变量的访问限制。
本文探讨了Java中内外部类的访问机制,包括非静态内部类与静态内部类的区别,以及如何通过静态内部类实现单例模式。通过代码示例详细解析了外部类与内部类之间的相互访问,以及在不同情况下变量的访问限制。
           
       
           
                 
                 
                 
                 
                 
                
               
                 
                 
                 
                 
                
               
                 
                 扫一扫
扫一扫
                     
              
             
                  
 被折叠的  条评论
		 为什么被折叠?
被折叠的  条评论
		 为什么被折叠?
		 
		  到【灌水乐园】发言
到【灌水乐园】发言                                
		 
		 
    
   
    
   
             
            


 
            