零基础学java——（包，内部类，数组（一））

包

作用：
    不同的包存储不同.java文件 增加了可读性以及后期的维护性
    java中是以类为单位的，区分类，包名.类名
    包的作用用来区分类

包的使用

使用package 包名 一定要注意 package语句在整个.java文件的第一行。

导包

	如果需要导包：  import 所需类的全限定名 
	在类声明之前  声明包之后
	import java.util.*; 
	import 导包 同名类只能通过import导入一次
如何导入同名包:
	import导入
jdk1.7之后 可以使用静态导入:
	import static java.lang.Math.PI; 导入指定的属性
	import static java.lang.Math.*;导入所有静态内容

import java.util.Scanner;
import static java.lang.Math.PI;
public class Test01 {
	public static void main(String[] args) {		
		// () 方法  方法名
		// System.out 对象 
		// System 是个类
		// out 是个静态的对象
		System.out.println("hello world");
		Scanner input = new Scanner(System.in);		
		// 创建一个时间对象
		Date d = new Date();
		//创建一个时间对象  sql
		java.sql.Date sqlD = new java.sql.Date(123456L);
		System.out.println(PI);
		//System.out.println(abs(-1234));
	}
}

内部类

定义在类里面的类称之为内部类，生成的字节码文件的文件名称 内部类-> 外部类$内部类

普通内部类

a：外部类中如何使用内部类的属性以及方法
    在外部类中创建内部类对象 调用内部类功能、属性
b:内部类中使用外部类的属性以及方法
    可以直接使用
c:其它类中调用内部类中的属性和方法：
    导包 包名.外部类.内部类
    内部类类型 变量名= new 外部类对象().new 内部类对象
    Inner01 in = new Outer01().new Inner01();
    外部类.内部类 变量名= new 外部类对象().new 内部类对象
    Outer01.Inner01 in = new Outer01().new Inner01();

public class Test01 {
	public static void main(String[] args) {
		//创建外部类对象
		Outer01 out = new Outer01();
		out.method();
		// 创建inner对象
		Outer01.Inner01 in = new Outer01().new Inner01();		
		int num = new Outer01().num;		
	}
}
class Outer01{
	
	int num;
	public Outer01(){		
	}
	public void method() {
		// 使用内部类中的属性
		Inner01 in = new Inner01();
		in.fun();
		System.out.println("outer method");
	}
	
	/* private */ class Inner01 {
		public Inner01() {
			
		}
		public void fun() {
			/*
			 * Outer01 out = new Outer01(); out.method();
			 */
			method();
			System.out.println("Inner fun");
		}
	}
	
	class Inner02{
		public Inner02() {
			
		}
		public void fun1() {
			//fun();
			System.out.println("Inner fun");
		}
	}
	
}

静态内部类

通过static修饰的内部类称之为静态内部类。
外部类中如何使用静态内部类的属性以及方法:
	创建对象，调用对象的属性以及方法
静态内部类中使用外部类的属性以及方法:
	创建外部类的对象 调用对象的属性以及方法
其它类中调用内部类中的属性和方法：
	导包 包名.外部类.内部类
	内部类类型 变量名= new 外部类. 内部类对象()
	Inner01 in = new Outer02.Inner01();
	外部类.内部类 变量名= new 外部类. 内部类对象()
	Outer01.Inner01 in =new Outer02.Inner01();

public class Test02 {
	public static void main(String[] args) {
		
		// 创建对象
		Inner01 inner = new Outer02.Inner01();
		inner.fun();
		
	}
}
class Outer02{
	
	int num;
	public Outer02(){
		
	}
	public void method() {
		new Inner01().fun();
		System.out.println("outer2 method"+Inner01.num);
	}
	
	static class Inner01 {
		static int num = 10;
		public Inner01() {
			
		}
		public void fun() {
			//new Outer02().method();
			System.out.println("Inner fun");
		}
	}
	
	public static void fun() {
		new Outer02().method();
	}
}

用静态内部类实现单例

编写静态内部类完成单例模式创建
	线程安全问题： 天然线程安全
	延迟加载： 能做到延迟加载

public class Single {
	
	static class SingleHolder{
		private static Single single = new Single();
	}
	
	private Single() {
		
	}
	
	public static Single getInstance() {
		return SingleHolder.single;
	}
	
	public static void add() {
		
	}

	public static void main(String[] args) {
		/*
		 * Single s1 = getInstance(); Single s2 = getInstance(); System.out.println(s1);
		 * System.out.println(s2);
		 */
		Single.add();
		Single s1 = getInstance();
	}
}

局部内部类

定义在方法中的类 只能当前方法使用，一定程度减少内存开销 但是复用性是及其低的。

public class Test03 {
	public static void main(String[] args) {
		
	}
	public static void info() {
		class Inner{
		
		}
	}
}

匿名内部类

/*
 * 
 *  		匿名内部类 
 *  
 *  两种比较的接口：
 *   		内部比较器
 *   			java.lang.Compareable  比较大小
 *      	外部比较器
 *  			java.util.Comparator 
 *  
 *  
 * 			
 */
public class Test01 {
	public static void main(String[] args) {
		
		//比较两个字符串的大小
		String str1 = "d";// String  char[] value = {'a','b','c','d'}
		String str2 = "aaaaaa";// char[] value = {'a','b','c','e'}
		
		//String中已经重写了comparTo方法 所以可以直接进行比较
		if(str1.compareTo(str2)>0) {
			System.out.println(str1);
		}else if(str1.compareTo(str2)==0) {
			System.out.println("相等");
		}else {
			System.out.println(str2);
		}
		
		//创建比较器对象
		MyCom m = new MyCom();
		int num = m.compare(str1, str2);
		if(num>0) {
			System.out.println(str1);
		}else if(num==0) {
			System.out.println("相等");
		}else {
			System.out.println(str2);
		}		
	}
}

class MyCom implements Comparator{

	@Override
	public int compare(Object o1, Object o2) {
		String str1 = (String)o1;
		String str2 = (String)o2;
		return str1.length()-str2.length();
	}
	
}

package com.mage.inner;

import java.util.Comparator;
import java.util.List;

/**
 *  		通过匿名内部类可以产生一个接口/抽象了的 实现类对象/子类对象
 * @author wawjy
 *
 */
public class Test02 {
	public static void main(String[] args) {
		
		//对于字符串按照字符串越短 越大
		Comparator com = new Comparator() {
			@Override
			public int compare(Object o1, Object o2) {
				String str1 = (String)o1;
				String str2 = (String)o2;
				return -(str1.length()-str2.length());
			}
		};
		
		String str1 = "d";// String  char[] value = {'a','b','c','d'}
		String str2 = "aaaaaa";// char[] value = {'a','b','c','e'}
		
		System.out.println(com.compare(str1, str2));
		new Comparator() {
			@Override
			public int compare(Object o1, Object o2) {
				/*
				 * String str1 = (String)o1; String str2 = (String)o2; return
				 * -(str1.length()-str2.length());
				 */
				return 1;
			}
		}.compare(str1, str2);
		//jdk 1.8之后 lambda表达式
		Comparator com1 = (x,y)-> 1;
		System.out.println(com1.compare(str1, str2));
		/* Comparator com2 = */
		new Comparator() {
			public int compare(Object o1,Object o2) {
				return 1;
			}
		};
		
		Comparator com3 = new Comparator() {
			public int compare(Object o1,Object o2) {
				return 1;
			}
		};
	}
}

数组

数组基本概念

什么是数组： 一组数 （数据） 的集合
官方定义： 在内存中 通过连续的存储单元 存储相同数据类型的 有序集合
数组的定义
    [] 代表数组出现了
    数据类型[] 变量名;
数组的初始化
    变量名 = new 数据类型[数组的长度];
    arrs = new int[10]
获取数组元素
    数组变量[索引]
    索引从0开始 到 长度-1 结束
    假设长度为10；那么根据索引获取元素 数组变量[0] - 数组变量[9]

数组的声明及初始化

静态：
    new 数据类型[]{元素1,元素2,元素3,…}
    {元素1,元素2,元素3,…};
    不能确定数组中存储的元素的
动态：
	初始只指定数组的长度 然后通过索引一次填充具体的值。
打印数组对象：
    [Ljava.lang.String;@15db9742
    [ 代表数组对象
    java.lang.String 数据类型

public class Test02 {
	public static void main(String[] args) {
		//声明
		String[] strs;
		//初始化
		strs = new String[5];
		
		
		//数组的初始化  
		// 静态初始化  在创建数组时  已经确定数组中每个元素是什么
		int[] arrs = new int[] {1,12,123};//   声明数组时通过{} 将所有元素添加到数组在中
		
		//arrs重新赋值
		arrs = new int[10];
	
		
		// 静态初始化 
		int[] ars = {1,11,111};// 声明一个长度是3 的int类型的数组 存储元素1 11  111 
		ars = new int[3];
		System.out.println(ars);
		
		//声明一个数组
		String[] ss = new String[5];
		//通过索引一次给数组中的元素填充值
		ss[0] = "嘿嘿";
		ss[1] = "哈哈";
		ss[2] = "呵呵";
		ss[3] = "xixi";
		
		System.out.println(ss);
		
		
		int[] ins = new int[10];
		System.out.println(ins.length);
		ins = new int[20];
		System.out.println(ins.length);
		
	}
}

数组的赋值与遍历

/*
 *  0 1
 *  1 3
 *  2 5
 *  3 7
 *  n 2n+1
 *  
 *  增强for循环 只是用来获取元素的   迭代器
 *  	for(数据类型 变量名:取出数据的变量){
 *  	}
 *  	
 *  
 *  
 */
public class Test03 {
	public static void main(String[] args) {
		//  往数组中添加元素  1 3 5 7  。。。。。99奇数
		//1：声明一个数组
		int[] arrs = new int[50];
		
		//通过循环一次填充值
		for(int i = 0;i<arrs.length;i++) {
			arrs[i] = 2*i+1;
		}
		
		System.out.println("循环打印每个索引上的值");
		System.out.println("打印第一个位置上的元素："+arrs[0]);
		for(int i = 0;i<arrs.length;i++) {
			System.out.print(arrs[i]+"\t");
		}
		
		System.out.println("jdk1.5之后 推出了增强for循环");
		
		for(int arr:arrs) {
			System.out.println(arr);
		}	
	}
}