【黑马程序员】java中-------------内部类

最新推荐文章于 2023-03-13 14:43:36 发布

天下xu

最新推荐文章于 2023-03-13 14:43:36 发布

阅读量647

点赞数

分类专栏： java学习日记

本文链接：https://blog.csdn.net/u011079455/article/details/17070951

版权

java学习日记专栏收录该内容

26 篇文章 0 订阅

订阅专栏

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

一、内部类定义

将一个类定义在另一个类的局部或者成员位置上，该类可以视为内部类

二、定义规则

1.一个内部类的成员不能被static静态修饰，如果要被static修饰，那么这个内部类也要被static修饰。。

2.当一个内部类定义在外部尅的成员位置上时，就可以被成员修饰符所修饰，如：private ；public； static；final。

3.内部类定义在局部时，不可以被成员修饰符修饰，private； public；static，但是可以被final修饰，

局部内部类的成员可以被成员修饰符修饰，（注意：static不可以，如果一旦修饰了，那内部类要被static修饰，但是

局部内部类不能用成员修饰符修饰）

三、内部类的访问规则

1.一个非静态内部类（其中成员不能是静态的），可以直接访问外部类成员。

而外部类访问内部类需要创建内部类对象之后，才可以访问内部类成员

2.一个被private 修饰的内部类（其中成员不能是静态），也可以访问外部类的任何成员

内部类一但被private修饰，外部类是不能无法访问的

注意：之所以内部类可以自己访问外部类中成员，是因为内部类中持有了外部类的一个引用：外部类名.this

3.一个非静态内部类，如果他的外部类静态方法要访问内部类时，就必须创建对象采矿进行访问

格式：Out.Inner in=new Out().new Inner();

练习代码：

package neibulei;

	
public class Out{
	
	    class Inner{	//内部类Inner
	          
	    	int i =5;
	        public  void show()
	        {
	             System.out.println(i);
	        }
	    }
	    //外部类静态方法
	    public static void Method()
		{
			//创建内部类对象
	       Out.Inner  in = new Out().new Inner();
	       in.show();
		}	
}
class MainClass{
	public static void main(String[] args){
		
		Out.Method();//静态方法的调用
		
		
	}
}

4. 外部类访问内部类，必须建立内部类对象

5.当内部类定义在外部类成员位置上，非私有修饰，可以被外部类直接创建对象。

格式：

外部类.内部类变量名=new 外部类（）.new 内部类（）；
Out .Inner in=new Out().new Inner();

6.当内部类被static修饰后，具备static的特性，只能访问外部类的static的成员

7.如果在外部类中的方法中访问static内部类的非static静态成员

练习代码：

package neibulei;

public class MainClass{
	public static void main(String[] args){
		
		new Out().Method();//创建外部类对象调用Method()方法
		
		
	}
}	
 class Out{
	
	   static class Inner{	//static 内部类Inner
	          
	    	int i =5;
	        public  void show()
	        {
	             System.out.println(i);
	        }
	    }
	    //外部类非静态方法
	    public void Method()
		{
			//创建内部类对象
	      Inner in=new Inner();
	       in.show();
		}	
}

8. 如果内部类是static的，而且类中成员也静态的

外部类就可以直接，类名.调用：如：Inner.show（）；

9.在外部其他类中，访问static的内部类和其中的static成员

直接外部类名.内部类名.show（）；调用即可

练习代码：

package neibulei;

public class MainClass{
	public static void main(String[] args){
		
		Out.Method();//创建外部类对象调用Method()方法
		
		
	}
}	
 class Out{
	
	   static class Inner{	//static 内部类Inner
	          
		   static int i =5;	//	static成员
	        public static  void show()//static方法
	        {
	             System.out.println(i);
	        }
	    }
	    //外部类静态方法
	    public  static void Method()
		{
			//直接类名调用
	      Inner.show();
		}	
}

10. 内部类定义在局部时，可以直接访问外部类中成员，而局部内部类要访问

外部类中局部成员只能访问被final修饰的成员变量

练习代码：

package neibulei;

public class MainClass{
	public static void main(String[] args){
		
		Out.Method();//外部类名调用Method()方法
		
		
	}
}	
 class Out{
	
	   
	    //外部类静态方法
	    public  static void Method()
		{	
	    	final int x=0;//需要final修饰
	    	 class Inner{	//局部 内部类Inner
		          
	 		    int i =5;	//	成员
	 	        public  void show()//内部类方法
	 	        {
	 	             System.out.println(i);
	 	             //局部内部类方法访问外部类中成员
	 	            System.out.println(x);
	 	        }
	 	        
	 	      } 
	 	     //创建局部内部类对象
	 	        Inner in=new Inner ();
	 	        in.show();
		}	
}

11. 内部类可以直接访问外部类中成员，是因为持有外部类的引用

类名.this.变量名

练习代码：

public class Test5 {

	/**5.在打印语句中如何打印这3个x变量？
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//建立内部类对象，并且调用内部类func()方法
		A.B b=new A().new B();
		b.func();
	}

}
class A {
    int x = 1;
 
   public class B {
        int x = 2;
 
        public void func() {
            int x = 3;
            //此x是打印本方法中的成员
            System.out.println( x );
            //此x是打印内部类的成员变量，因为x有内部类的引用：类名.this.x
            System.out.println( B.this.x );
            //此x是打印外部类的成员变量，因为此x有外部类的引用：外部类名.this.x
            System.out.println( A.this.x );
        }
    }
}

12. 在内部类中，静态访问静态同样符合

四、内部类的使用

1.当描述事物时，事物的内部还有事物，则该事物使用内部类来描述，因为内部类事物要使用外部类中的内容

举例说明：

比方说人这个对象，它的内部还有心脏这个事物。

如果单独定义一个类描述心脏，就不符合现实生活中的规则

2.在接口中，也有一个比较特殊的

它属于接口中的内部接口

//内部接口的形式

interface Map{
	public static interface Entry{
		public abstract Object getKey();
		public abstract Object getValue();
	}
}
//内部类实现内部接口的形式
class HashMap implements Map{
	class haha implements Map.Entry{
		public Object getKey(){}
		public Object getValue(){}
	}
}

五、匿名内部类

1.匿名内部类其实就是内部类的简写格式

2.定义匿名内部类的前提：内部类必须继承一个类或者实现一个接口

注意：可以不继承一个类，仍然可以定义匿名内部类，那么依靠Object类来定义匿名类

因为，他们读书Object的子类

3.匿名类的格式：new 父类名或者接口（）{子类主体}

注意：

a.其实匿名内部类就是一个匿名子类对象，而且这个对象特点比较丰满

b.匿名内部类中定义的方法最好不要超过3个

c.当创建接口或者抽象类的匿名子类对象时，必须覆盖接口或者抽象类中的抽象定义

d.当创建一般类的匿名子类对象时，可以不用全部覆盖方法，覆盖自己需要的即可

联系代码：

package neibulei;

public class MainClass{
	public static void main(String[] args){
		
		Out o=new Out();//建立外部类对象
		o.Method();
		o.show();
		
	}
}
//接口
interface inter{
	public abstract void smoke();
	public abstract void dapai();
}

//一般类
class person{
	public void seelp(){
		System.out.println("疲惫了就睡觉");
	}
	
}
 class Out{
	 	public void show(){
	 		new person(){
	 			//person类匿名子类对象，并且调用seelp()方法
	 			public void seelp(){
	 				System.out.println("即使困了，累了，我们还是要坚持！");
	 			}
	 		}.seelp();
	 	}
	   
	   
	    public void Method()
		{	
	    	
	    	 
	    	inter i=new inter(){	//局部匿名 内部类inter
	    		//覆盖所有抽象方法
	    		public    void smoke(){
		        	 System.out.println("抽烟有害健康！");
		         } 
	    		public  void dapai(){
		        	 System.out.println("赌博不是好的习惯");
		         }
	 		   
	 	        
	 	      } ;
	 	      i.smoke();
	 	      i.dapai();
	 	   
		}	
}

天下xu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【黑马程序员】java中-------------内部类

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------一、内部类定义将一个类定义在另一个类的局部或者成员位置上，该类可以视为内部类二、定义规则1.一个内部类的成员不能被static静态修饰，如果要被static修饰，那么这个内部类也要被static修
复制链接

扫一扫