Java核心技术----类的高级特效

一、Java类包

1、类名冲突

Java中每个接口或类都来自不同的类包，无论是Java API中的类与接口还是自定义的类与接口都需要隶属某一个类包，这个类包包含了一些类和接口。

2、完整的类路径

一个完整的类名需要包名与类名的组合，任何一个类都隶属于一个类包，只要保证同一类包中的类不同名，就可以有效地避免同名类冲突的情况。

列如：Date类，Date有两种包类java.util和java.sql.,需要制定的包类来明确类的方向：

java.util.Date date=new java.util.Date();

java.sql.Date date1=new java.sql.Date();

3、创建类包

定义包类名：

package 包名;

package baolei;

	  
	  public class Demo1{   
	 public static void main(String[] args) {
		System.out.println("Hello");
		
	}
	 
}



/*输出结果：
Hello
 */

4、导入类包

（1）使用import关键字导入包

import 包类；

import com.baolei.*;     //导入baolei类包的所有类

import com.baolei.Demo1;     //导入baolei类包的Demo1类

（2）使用import导入静态成员

import static 静态成员；

import static java.lang.Math.max;     //导入baolei类包的Demo1类

二、final变量

final关键字可用于变量声明，一旦该变量被设定，就不可以再改变该变量的值。

final double PI=3.14;

三、final方法

final的方法不能被重写

将方法定义为final类型可以防止任何子类修改该类的定义与实现方式，同时定义为final的方法执行效率要高于非final方法。（private修饰符：父类的某个方法被设置为private修饰符，子类将无法访问该方法，自然无法覆盖该方法。private修饰符的方法隐式被指定为final类型）

四、final类

定义为final的类不能被继承。

final 类名{}

package bao;

final class Demo1{ 
	int a=3;
	void dit() {
				
			}
	 public static void main(String[] args) {
		 Demo1 f=new Demo1();
		 f.a++;
		System.out.println(f.a);
	
		  }
	 
}



/*输出结果：
4
 */

五、内部类

注：非内部类不能声明private或protected访问类型

1、成员内部类

（1）成员内部类

在一个类中使用内部类可以在内部类中直接存取其所在类的私有成员变量。

public class OuterClass{

         //外部类     

            private class InnerClass{ 

                       //内部类   

                   }

         }

package bao;

public class Demo1{ 
	neibulei i=new neibulei();   //外部类实例化内部类对象引用
	 public void aa() {          //外部类成员方法
		 i.bb();           //外部类调用内部类的成员方法
	 }
	 
	 class neibulei {      //定义内部类
		 neibulei(){      //neibulei内部类的构造方法
			 
		 }
		 public void bb(){     //内部类成员方法
			 
		 }
		 int y=0;       //内部类成员变量
	 }
	 
	 public neibulei dot() {   //外部类方法，返回值引用内部类的引用
		 
	//	 y=4;            //这行代码会报错，外部类不能直接访问内部类成员变量
		 i.y=4;
		 return new neibulei();   //返回内部类的引用
		 
		 
	 }
	 
	 public static void main(String[] args) {
		 Demo1 dem=new Demo1();              //内部类的对象实例化操作必须在外部类或外部类非静态方法中实现。
		 Demo1.neibulei  i= dem.dot();
		 Demo1.neibulei i2=dem.new neibulei();
	}
}

（2）内部类向上转型接口

如果将一个private的内部类向上转型为其父类对象，或者直接向上转型为一个接口，在程序中可以隐藏内部类的具体实现过程。

package bao;

interface jiekou{       //定义一个接口
	public void f();
}
public class Demo1{ 
	public static void main(String[] args) {
		Demo2 out=new Demo2();    //实例化一个Demo2对象
		jiekou jie=out.doit();       //调用doit()方法，返回一个jiekou
		jie.f();          //调用f()方法
		
	}
	
}
class Demo2{
	private class Demob implements jiekou{
		Demob(String s){                //内部类构造方法
			System.out.println(s);
		}
		public void f() {             //实现接口中的f()方法
			System.out.println("访问内部类中的f()方法");
		}
	} 
	public jiekou doit() {               //定义一个方法，返回jiekou接口
		return new Demob("访问内部构造方法");
	}
}



/*输出结果：
访问内部构造方法
访问内部类中的f()方法
 */

（3）this关键字获取内部类与外部类

使用在外部类定义的成员变量与内部类的成员之间名称相同时，可以运用this关键字。

package bao;

public class Demo1{ 
	private int a;
	private class beibulei{
		private int a=9;
		public void doit(int a) {
			a++;              //调用参数a
			this.a++;         //调用内部类的变量a
			Demo1.this.a++;  //调用外部类的变脸a
		}
		
	}
}

2、局部内部类

局部内部类就是在类的方法中定义的内部类，它的作用范围也是在这个方法体内。

package bao;

interface jiekou{       //定义一个接口
	 
}
public class Demo1{ 
	public jiekou doit(final String x) {     //doit()方法参数为final类型
	       class Demo2 implements jiekou{     //在doit()方法中定义一个内部类
	    	   Demo2(String s){                
			   s=x;
		       System.out.println(s);
		}
	}
	      return new Demo2("doit");
}
	}

3、匿名内部类

在编写程序代码时，不一定要给内部类取一个名字，可以直接以对象名来代替。

return new A() {

    ...//内部类体

};

A：对象名

public class Demo1{ 
public Demo2 doit() {         //定义doit()方法
	return new Demo2() {         //声明匿名内部类
		private int i=0;
		public int getValue() {
			return i;
		}
	};
}
	}

4、静态内部类

在内部类前添加修饰符static，这个内部类就变为静态内部类。

package bao;

 
public class Demo1{ 
  int a=100;
  static class aa() {
	  void doitlnner() {              //这行代码报错，静态内部类不可以直接调用外部类的静态变量
		  System.out.println("外部类"+a);     //调用外部类的成员变量a
	  }
  }
	}

5、内部类的继承

内部类也和其他普通类一样可以被继承，但是继承内部类比继承普通类要复杂一些，需要设置专门的语法进行继承。

package bao;

 
public class Demo1 extends ClassA.ClassB{   //继承内部ClassB
	public Demo1(ClassA a) {
	a.super();     //super关键字表示对某个类的父类的引用。
}
	}

class ClassA{ //定义外部类ClassA
	class ClassB{   //定义内部类ClassB
		
	}
}