小白Java学习之路（包，内部类，数组）

最新推荐文章于 2022-07-27 14:30:39 发布

一生而已

最新推荐文章于 2022-07-27 14:30:39 发布

阅读量194

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/qq_38114301/article/details/96497597

版权

java基础专栏收录该内容

15 篇文章 6 订阅

订阅专栏

包

文件夹，包没有子父级的关系。

作用

不同的包存储不同.java文件增加了可读性以及后期的维护性

java中是以类为单位的，区分类，包名.类名

包的作用用来区分类

包的使用

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

导包

java.lang包下的所有类都可以直接使用不需要导包

 	如果需要导包：  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:其它类中调用内部类中的属性和方法：
- a：导包包名.外部类.内部类
- b：内部类类型变量名= 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修饰的内部类称之为静态内部类。

a：外部类中如何使用静态内部类的属性以及方法
- 创建对象，调用对象的属性以及方法
b:静态内部类中使用外部类的属性以及方法
- 创建外部类的对象调用对象的属性以及方法
c:其它类中调用内部类中的属性和方法：
- 1:
- a：导包包名.外部类.内部类
- b：内部类类型变量名= new 外部类. 内部类对象()
Inner01 in = new Outer02.Inner01();
- 2:
- 外部类.内部类变量名= 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]
获取数组中的长度：数组变量.length

 		数组的索引 从0开始 到  length-1结束

public class Test01 {
	public static void main(String[] args) {
		
		// 声明一个数组
		int[] arrs;//声明了一个int类型的数组  该数组中只能存放int类型的数据
		
		String[] strs;
		
		// 数组的初始化
		arrs = new int[10];//初始化arrs 当前arrs这个数组可以存放5个int类型的数据
		
		//查看数组中的元素
		System.out.println(arrs[9]);

		// 数组中有一个很重要的属性  长度
		System.out.println(arrs.length);
		
	}
}

数组的声明及初始化

int arrs[];不建议使用

静态：

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);
		}	
	}
}