Java学习之路（基础三）

函数的返回

• 基本类型：包括int, byte，float，short int，long int, double, char, string等数据类型.
• 引用类型：class/interface数据类型，本质上是需要一个具体的子类/实现类对象，返回的是对应的子类/实现类对象.
• 特殊使用：链式编程会将返回的对象再调用函数，且返回的数据类型任然是具体对象,故而可以一直调用.
  form:object.methodone().methodtwo().methodtree()…

包的使用

• 是为了方便管理程序文件的需要而进行的分包管理，本质上是不同文件存放在不同的包下，常用的有：按照模块分/按照具体功能分，实际使用中是模块为主，功能为辅。

• 导包格式：import package, class文件中位于第一行，若class文件为包下文件，则在本包头文件之下，也就说：

包文件 > 导包 > main函数。

• DOS下，带包格式的class文件的编译/运行，需要添加-d参数。具体格式为：

 javac -d . class.java	,注意不同的包下需要先编译资源包文件，若资源包不在同一文件下需要导包处理.

• 但是使用JDK工具会省事很多，直接点击编译运行即可。

权限修饰符-

修饰符	本类	同包	不同包下子类	不同包下无关类
private	Y	NULL	NULL	NULL
默 认	Y	Y	NULL	NULL
protected	Y	Y	Y	NULL
public	Y	Y	Y	Y

• 权限修饰符是对权限的描述，使用时候不能多个同时使用。

修饰符

• 权限修饰符：如上.

private：私有.
缺省修饰符：不写出其他三种，系统内置.
protected：子类使用父类特有。
public：公有。

• 状态修饰符：static,final.
• 抽象修饰符：abstract.
• 类修饰符：
  • 类：public，系统缺省，final(不允许继承)，abstract.
  • 成员变量：private，系统缺省，protected，public，static，final.
  • 构造方法：public，protected，系统缺省，private.
  • 成员方法：public，protected，系统缺省，private，abstract,final,static.

内部类

• 描述：类定义中某类的之间，某类为外部，定义的为内部类。
• 访问规则：
  • 内部类可以直接访问外部类的所有数据，包括由private修饰的。
  • 外部想访问内部类的数据，需要创建对象。，通过对象去调用。
• 成员内部类：
  • 与外部内成员同层级定义的内部类。
  • 可由private/static修饰，前者为了私有化，提高安全性，后者是方便调用。
  • static修饰的内部类，调用外部类的static数据，是可行的，创建对象格式：
    outClass.inClass objectName = new outClass.inClass();.
  • 不用static修饰的内部类，调用外部类的static则报错,创建对象格式：
    outClass.inClass objectName = new outClass.new inClass();.
• 局部内部类：
  • 定义在外部类方法之中的内部类。
  • 局部内部类访问局部变量，局部变量必须加final修饰。
• 代码举例：

/*for example*/
package JavaPackage;
class OutClass{
	/*静态成员变量*/
	private  static int num = 50;
	/*成员方法*/
	public void methodPrivate(){
		PrivateInClass in = new PrivateInClass();
		in.TestPrivateInClass();
	}
	/*成员方法*/
	public void method() {
		InClass in = new InClass();
		in.TestInClass();
	}
	/*私有内部类*/
	private class PrivateInClass{
		public void TestPrivateInClass(){
			System.out.println("测试私有的内部类.");
		}
	}
	/*公有内部类*/
	public class InClass{
		public void TestInClass(){
			System.out.println("测试的内部类.");
		}
	}
	/* 静态的内部类
	 * static不能修饰类，因为静态无法被初始化。但是可以修饰内部类...
	 * 被static修饰的内部类是无法调用非静态的外部成员变量，报错。
	*/
	public static class StaticInClass{
		public  void StaticTestInClass(){
			System.out.println("静态的成员变量，静态的内部类  " + num);
		}
		public static void StaticMethodInClass(){
			System.out.println("静态的成员变量，静态的内部类  " + num);
		}
	}	
}

public class OutIner {
	public static void main(String[] args) {
		// 内部类调用方法.
		OutClass ouPri = new OutClass();
		ouPri.methodPrivate();
		System.out.println("------------");
		// 私有化的内部类调用方法.
		OutClass.InClass out = new OutClass().new InClass();
		out.TestInClass();
		System.out.println("------------");
		/*
		 * 静态内部类.
		 * 限定的新静态类->报错。
		 */
		//OutClass.StaticInClass outStatic = new OutClass().new StaticInClass();
		//outStatic.StaticTestInClass();
		/*访问办法
		 * out.in object = new out.in();
		 *warning :The static method StaticTestInClass() from the type OutClass.StaticInClass should be accessed in a static way.
		 */
		OutClass.StaticInClass OutStaticIn = new OutClass.StaticInClass();
		OutStaticIn.StaticTestInClass();
		/*若下行运行在StaticTestInClass函数，函数修饰static则：*/
		//warning :The static method StaticTestInClass() from the type OutClass.StaticInClass should be accessed in a static way.
		OutStaticIn.StaticTestInClass();
		/*TestExpretion method*/
		OutClass.StaticInClass.StaticMethodInClass();
		
	}
}

• 匿名内部类
• 编程中对内部类使用的简化形式,创建一次，使用一次，保证数据的最快回收.
• 前提：需要重写的类和接口.
  Form:

new classname/interface(){
	重写方法;
}

• 两种实现方式

/*for example*/
interface Function{
	public abstract void TestCc();
}
	...main body...

	/*method First,只可以使用一次函数.*/
	new Function(){
		pubic void TestCc(){
			System.out.println("this is the first TestCc");
		}.TestCc();
	}

	/*method Second*/
	Function fc = new Function(){
		pubic void TestCc(){
			System.out.println("this is the second TestCc");
		}
		fc.Testcc();	
	}

• 匿名内部类–实际运用

/* for example*/
inter Function{
	public abstract void TestCc();
}
class FuntionTest{
	public void Test(Function fc){
		fc.TestCc();
	}
}
class JutiClass implements Function{
	public void TestCc(){
		System.out.println("具体化后的测试.");
	}
}
class MainBody{
	public static void main(string[] args){
	//调用Test去显示“具体化后的测试.”
	FunctionTest FT = new FunctionTest();
	Function JL = new JutiClass();
	FT.Test(JL);
	}
	/*实现方式2*/
	FunctionTest FT = new FunctionTest();
	FT.Test(new Funtion(){
		public void TestCc(){
			System.out.println("具体化后的测试.");
		}
	});	
}

• 还原Coding

	/*需求目标，补全代码，控制台输出 "hello world"*/
	interface inter{
		public abstract void show();
	}
	class Outer{
		//补全部分
		//补全部分如下:
		public static inter method(){
			return new inter(){
				public void show(){
					System.out.println("hello world");
				}
			};
		}
	}
	class mainbody{
		public static void main(String[] args){
			Outer.method().show();
		}
	}
	```