Java第九章

1.1类名冲突

//相同的类名放在不同的类包中，就解决了不同功能类名冲突的问题
//同一个包中类相互访问，可以不指定包名
//同一个包中的类不必放在同一个位置

1.2创建包

//Java包命名全部使用小写字母
package 拍;
public class Math {
	public static void main(String args[]){
    	System.out.println("不是Java.lang.Math类，二是拍.Math类");
	}
}

1.3.1导入包

//在指定包后加上*，表示可以在程序中使用包中的所有类
//当使用import指定了一个包中所有的类时，并不会指定这个包中子包的类，若用还要再次单独引用
package 拍.*;   //指定拍包中所有的类在程序中都可以使用
import 拍.Math   //指定包中Math类在程序中可以使用

1.3.2导入静态变量

package 拍;
import static java.lang.Math.max;  //导入静态成员方法
import static java.lang.System.out;  //导入静态成员变量
public class new2 {
	public static void main(String[] args){
    	//在主方法中，可以直接使用这些敬爱成员
    	out.println("1和4较大的值为："+max(1,4));
	}
}

1.4 final变量

//final做变量声明，变量一旦被设定，不可以改变值，必须在声明时就给赋初值
package 拍;
import static java.lang.System.out;  //导入静态成员变量
import java.util.Random;
class Test{
	int i=0;
}
public class FinalData {
	static Random rand=new Random();
	private final int VALUE_1=9;  //声明一个final常量
	private static final int VALUE_2=10;  //声明一个final、static常量
	private final Test test=new Test();  //声明一个final引用
	private final int a[]={1,2,3,4,5,6};  //声明定义一个final数组
	private final int i4=rand.nextInt(20);
	private static final int i5=rand.nextInt(20);
	public String toString(){
    	return i4+" "+i5+" ";
	}
public static void main(String[] args){
    FinalData data=new FinalData();
    data.test=new Test();
    //可以对指定的为final的引用中的成员变量赋值
    //但不可以将定义为final的引用指向其它引用
    data.value2++;
    //不能改变定义为final的常量值
    data.test2=new Test();   //可以将没有定义为final的引用指向其他引用
    for (int i=0;i<data.a.length;i++){
        a[i]=9;
        //不能对定义为final的数组赋值
    }
    out.println(data);
    out.println(data2);
    out.println(new FinalData());
    out.println(data);
}
}

1.5 final方法

//定义为final方法不能被重写，将方法定义为final类型可防止与子类通过修改该类的定义与实现方式；若是一个父类的某个方法被设置为private修饰符，子类无法访问该方法

1.6final类

//定义为final的类不能被继承，语法如下；若是将某个类设置为final类，则类中的所有方法将被设置为final形式，但是final类中的成员变量可以被定义为final或是非final形式
final 类名{}
package 拍;

final class FinalClass {
	int a=3;
	void doit(){
	}
	public static void main(String args[]){
    	FinalClass f=new FinalClass();
    	f.a++;
    	System.out.println(f.a);    //输出结果是4
	}
}

1.7 内部类·

//在一个文件中定义俩个类，且一个类在另一个内部，在内部的称为内部类，内部类可以分为：成员内部类、局部内部类、匿名类

1.7.1成员内部类

//内部类可以随意使用外部类的成员方法以及成员变量
//内部类的实例一定要绑定在外部类的实例上，如果从外部类中初始化一个内部类对象，那么内部类对象就会绑定在外部类对象上。
public class Out{      //外部类
       private class Inner{    //内部类
      }
}
//举例
package 拍;

import javax.sql.rowset.serial.SerialStruct;

public class OuterClass {
	innerclass in=new innerclass();   //在外部类实例化内部类对象的引用
	public void ouf(){
    	in.inf();  //在外部类方法中调用内部类方法
	}
	class innerclass{
    	innerclass(){   //内部类构造方法

    	}
    	public void inf(){  //内部类成员方法

    	}
    	int y=0;     //定义内部成员变量
	}
    public innerclass doit(){  //外部类方法，返回值为内部类引用
    	//y=4;    //外部类不可以直接访问内部类成员变量
    	int y=4;
    	return new innerclass();   //返回内部类引用
	}
	public static void main(String args[]){
    	OuterClass out=new OuterClass();
    	//内部咧的对象实例化造作必须在外部类或是外部类的静态方法中实现
    	OuterClass.innerclass in=out.doit();
    	OuterClass.innerclass in2=out.new innerclass();
	}
}

1.8内部类向上转型为接口

//在项目中创建类，并定义接口，使内部类实现这个接口，最后使doit()方法返回值类型为该接口
	package 拍;
interface OutInterface{    //定义一个接口
	public void f();
}
public class InterfaceInner {
	public static void main(String args[]){
    	//调用doit()方法，返回一个OutInterface接口
    	OutInterface outinter=out.doit();
    	outinter.f();     //调用f()方法

	}
}
class OuterClass2{
	//定义一个内部类实现OutInterface接口
	private class InnerClass implements OutInterface{
    	InnerClass(String s){    //内部类构造方法
            System.out.println(s);
    	}
    	public void f(){    //实现接口中的f()方法
        	System.out.println("访问内部类中的f()方法");
        }
	}
	public OutInterface doit(){   //定义一个方法，返回值为OutInterface类型的接口
    	return new InnerClass("访问内部类构造方法");
	}
}

//this获取内部类和外部类的引用
package 拍;
//使用this关键字获取内部类与外部类的引用
//若是外部类定义的成员变量与内部类的成员变量相同，可以使用this关键字
public class InterfaceInner {
	private int x;
	private class InnerClass{
    	private int x=9;
    	public void doit(int x){
        	x++;     //调用的是形参x
        	this.x;     //调用内部类变量x
        	InterfaceInner.this.x++;     //调用外部类变量x
    	}
	}
}