本节内容为昨天未讲完的内容
本节知识大纲：
day10—知识点.png
包：
什么是包：
就是一个文件夹且包没有父子关系
包的作用：
不同的包存储不同的.java文件，增加了可读性以及后期的维护性，java中是以类为单位的，区分类：包名.类名。
包的使用：
使用package 包名 一定要注意 package语句在整个.java文件的第一行
导包流程：
1:java.lang包下的所有类都可以直接使用，不需要导包
2：如果需要导包： import 所需类的全限定名
3:在类声明之前 声明包之后
4：import java.util.*;
5:import 导包 同名类只能通过import导入一次
6：如何导入同名类： a：import导入
b：创建对象时 使用全限定名 java.sql.Date sqlD = new java.sql.Date(123456L);
7：jdk1.7之后可以使用静态导入 import static java.lang.Math.PI; 导入指定的属性 import static
内部类
什么是内部类：定义在类里面的类称之为内部类
1:生成的字节码文件的文件名称 内部类-> 外部类$内部类
内部类分类：
普通内部类
静态内部类
成员内部类
匿名内部类
普通内部类：
a：外部类中如何使用内部类的属性以及方法
在外部类中创建内部类对象 调用内部类功能、属性
b:内部类中使用外部类的属性以及方法
可以直接使用
c:其它类中调用内部类中的属性和方法：
1:
a：导包 包名.外部类.内部类
b：内部类类型 变量名= new 外部类对象().new 内部类对象
Inner01 in = new Outer01().new Inner01();
2:
外部类.内部类 变量名= new 外部类对象().new 内部类对象
Outer01.Inner01 in = new Outer01().new Inner01();
public class Test01 {
public static void main(String[] args) {
//创建外部类对象
Outer01 o = new Outer01();
o.method();
//创建inner对象
//Inner01 in = new Outer01().new Inner01();
Outer01.Inner01 in = new Outer01().new Inner01();
in.fun();
}
}
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() {
System.out.println(num);
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) {
//创建对象
Inner02 inner = new Outer02.Inner02();
inner.fun();
Outer02.fun();
}
}
class Outer02{
int num;
public Outer02() {
}
public void method() {
new Inner02().fun();
System.out.println("Method Outer");
}
static class Inner02{
static int num = 10;
public Inner02() {
}
public void fun() {
int a = new Outer02().num;
System.out.println("Outer num:"+a);
System.out.println("Inner fun");
}
}
public static void fun() {
new Outer02().method();
}
}
成员内部类：
和静态内部类非常相似，都是定义在一个类中的成员位置，与静态内部类唯一的区别是，成员内部类没有static修饰。或者也可以这么理解：我们知道一个类有成员变量、有成员方法，那么这些成员定义在类中的哪个位置，那么成员内部类也就定义在哪个位置。
匿名内部类：
就是没有名称的类没有名称，也就是其他地方就不能引用，不能实例化，只用一次，当然也就不能有构造器。 new Comparator() {
public int compare(Object o1,Object o2) {
return 1;
}
};
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;
}
};
}
}
两种比较的接口：
内部比较器
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();
}
}
}
数组
什么是数组： 一组数 （数据） 的集合
官方定义： 在内存中通过连续的存储单元存储相同数据类型的有序集合
如何定义数组： [] 代表数组出现了
数据类型[] 变量名;
如何初始化数组：
变量名 = 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);
}
}
增强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);
}
}
}
