java基础_day11

一 内部类

1.1 内部类的分类

1：成员内部类
2：静态内部类
3：局部内部类
4：匿名内部类

1.2 成员内部类

概念：
定义在一个类的内部的类.内部类的地位与外部类的成员变量,成员方法平等,内部类也可以看做是外部类的成员,成员之间可以相互调用
​
使用：
外部类的一个成员部分，创建内部类对象时，必须依赖外部类对象。
Outer outer = new Outer();
Inner inner = outer.new Inner();
Inner inner1 = new Outer().new Inner()
​
​
特点：
书写位置：与属性、方法平级别，且没有使用static修饰的类。
访问权限：内部类可以是任意的访问权限。
成员内部类中，不能写静态属性、静态方法。
编译之后生成的字节码文件格式：外部类$内部类.class
实例化对象，需要借助外部类的对象完成。
​
​
实例代码：
class OuterClass {
    public String name;
    public class InnerClass {
    public String name;
    public void show(String name) {
    System.out.println(name); // 访问参数 name
    System.out.println(this.name); // 访问内部类属性name
System.out.println(OuterClass.this.name); // 访问外部类属性name
    }
}
public void test(){
System.out.println("Outer-show");
InnerClass inner = new InnerClass();
inner.show();
    }
}
class Program {
public static void main(String[] args) {
// 实例化外部类对象
OuterClass outer = new OuterClass();
//调用内部类的方法的方式
//第一种:借助于外部类的方法实现
outer.test();
//方式二:借助外部类对象，实例化内部类对象
//引用:外部类.内部类
//构成:外部类对象的引用.new 内部类的构造方法
OuterClass.InnerClass inner = outer.new             InnerClass();
    inner.show();
    }
}
​

1.3 静态内部类

概念：
在类的内部定义，与实例变量、实例方法同级别的，使用static修饰的类。
​
使用：
.不依赖外部类对象，可以直接创建或通过类名访问。
Outer.Inner inner = new Outer.Inner();
​
特点：
书写位置：和类中的属性、方法平级，且使用关键字 static 修饰
静态内部类中，可以写属性、方法、构造方法...
静态内部类中，可以写静态属性、方法
编译之后生成的字节码文件，格式：外部类$内部类.class
对象的实例化，不需要借助外部类对象。
​
 实例代码：
public class OuterClass {
//静态内部类不一定有静态方法,有静态方法的一定是静态内部类
static class InnerClass {
    String name;
public void show(String name) {
    System.out.println(name);
    System.out.println(this.name);
        }
    }
}
class Test {
    public static void main(String[] args) {
// 1. 实例化静态内部类的对象
//构成: new + 外部类名字.内部类的构造方法
    OuterClass.InnerClass innerClass = new          OuterClass.InnerClass();
// 2. 可以通过导包的形式，
// 先导包 import 包.OuterClass.InnerClass
// InnerClass innerClass = new InnerClass();
innerClass.show("aaa");
    }
}
​

1.4 局部类内部类

概念：
定义在外部类的方法中，作用范围和创建对象范围仅限于当前方法。
​
特点：
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
不能使用访问权限修饰符修饰。
书写位置：写在一个类的方法内部，作用域仅限于当前方法。
局部内部类，编译后生成的字节码文件格式：外部类$序号内部类名.class
​
示例代码：
public class Program {
    public static void main(String[] args) {
        Outer1 outer1 = new Outer1();
        outer1.show();
    }
}
class Outer1{
    public void show(){
    System.out.println("Outer-show");
// 定义一个局部变量
// 如果这个局部变量，被包裹在了一个局部代码段中（比如局部内部类、匿名内部
类），此时这个局部变量会被隐式的定义为final
    int height=0;
//局部内部类
// 在一个类的方法中，直接定义一个内部类
class Inner{
    public void run(){
    System.out.println("Inner-run"+height);
    }
}
//创建局部内部类对象
Inner inner = new Inner();
    inner.run();
    }
}
​
​
局部内部类的作用：
通过局部内部类实现了功能的私有化,并对方法内部的代码进行了整理,增强了代码的可读性和可操作性.

1.5 匿名内部类

创建方式：

第一种方式：使用已有的子类创建匿名子类对象

使用场景:已经创建好的子类可以多次使用，适用于相同的功能多次使用

第二种方式：直接使用Animal创建匿名子类对象

构成： new 父类的名字/接口的名字+（）+{写当前子类的陈成员}+；
使用场景：只能使用一次，使用完会被当作垃圾回收，适用于每次用作不同功能
​
实例代码：
public class Demo6{
    public static void main(String[] args) {
    Animal animal = new Animal();
//匿名对象
    new Animal().eat();
//匿名子类对象
//第一种方式:使用已有的子类创建匿名子类对象
    new Dog().eat();
//第二种方式:直接使用Animal创建匿名子类对象
//直接创建没有名字的Animal的匿名子类对象
    new Animal(){
@Override
public void eat() {
    System.out.println("匿名子类对象-eat");
}
    }.eat();
        }
}
//研究匿名子类对象
class Animal {
    public void eat() {
    System.out.println("fu-eat");
    }
}
class Dog extends Animal
{
public void eat() {
    System.out.println("zi-eat");
    }
}

1.6 内部类的作用

1：简介实现了继承
2：方便定义
3：只有外部类可以访问创建的内部类的属性和方法，包括私有方法
4：同一个包中的其他的类不可见，有很好的封装性
​
示例代码：
class A{}
class B{}
class X extends A{
    class Y extends B{}
}

二 包装类

2.1 基本数据类型与包装类型

定义：专门将简单数据类型的数据进行封装，形成相应的类
​
基本数据类型 包装类型
byte-------------- Byte
short-------------- Short
int-------------- Integer
long-------------- Long
float-------------- Float
double-------------- Double
char-------------- Character
boolean-------------- Boolean

2.2 装箱拆箱

2.2.1 手动装箱

概念:由基本数据类型，完成相对应的包装类进行转换。
​
作用：为了更好的储存
​
方式1：可以通过每一个包装类的构造方法来完成。 在每一个包装类的构造方法中，都有一个与之对应的基本数据类型作为参数的重载方法。 此时， 直接将需要包装起来的基本数据类型， 写到构造方法的参数中即可完成装箱。
​
Byte n1 = new Byte((byte)1);
Short n2 = new Short((short)2);
Integer n3 = new Integer(3);
Long n4 = new Long(4L);
Float n5 = new Float(3.14f);
Double n6 = new Double(3.14);
Character n7 = new Character('a');
Boolean n8 = new Boolean(false);
​
【推荐使用】方式2： 可以通过包装类的静态方法 valueOf() 完成装箱。 每一个包装类中，都有一个静态方法 valueOf ， 这个方法的参数是包装类型对应的基本数据类型的参数。 直接将需要包装起来的基本数据类型的数据，写到这个方法的参数中， 即可完成对这个基本数据类型数据的装箱。
​
Byte n1 = Byte.valueOf((byte)1);
Short n2 = Short.valueOf((short)2);
Integer n3 = Integer.valueOf(3);
Long n4 = Long.valueOf(4);
Float n5 = Float.valueOf(3.14f);
Double n6 = Double.valueOf(3.14);
Character n7 = Character.valueOf('a');
Boolean n8 = Boolean.valueOf(true);
​
​

2.2.2 手动装箱

概念: 由包装类型， 完成向对应的基本数据类型进行转换。
​
作用: 为了方便进行运算
​
方式： 使用每一个包装类对象的 xxxValue 可以实现。 这里的 xxx 就是需要转型的基本数据类型。 例如， 如果需要转型为int类型， 则直接调用 intValue 即可。
​
Byte i1 = Byte.valueOf((byte) 100);
byte n1 = i1.byteValue();
Short i2 = Short.valueOf((short) 100);
short n2 = i2.shortValue();
Integer i3 = Integer.valueOf(100);
int n3 = i3.intValue();
Long i4 = Long.valueOf(100);
long n4 = i4.longValue();
Float i5 = Float.valueOf(3.14f);
float n5 = i5.floatValue();
Double i6 = Double.valueOf(3.14);
double n6 = i6.doubleValue();
Byte i1 = Byte.valueOf((byte) 100);
byte n1 = i1.byteValue();
Short i2 = Short.valueOf((short) 100);
short n2 = i2.shortValue();
Integer i3 = Integer.valueOf(100);
int n3 = i3.intValue();
Long i4 = Long.valueOf(100);
long n4 = i4.longValue();
Float i5 = Float.valueOf(3.14f);
float n5 = i5.floatValue();
Double i6 = Double.valueOf(3.14);
double n6 = i6.doubleValue();

2.3 字符串与基本数据类型转换

2.3.1 基本数据类型转型字符串类型

方式1: 可以利用字符串拼接运算符完成。 当加号两端有任意一方是字符串的时候， 此时都会自动的把另一方也转成字符串， 完成字符串的拼接。 所以， 当需要把一个基本数据类型的数据转成字符串的时候， 只需要在另一端拼接上一个空的字符串即可。
int a = 10;
String str = a + "";
​
【推荐使用】方式2： 使用字符串的静态方法 valueOf 完成。
String str = String.valueOf(10);
​
方式3： 借助包装类的实例方法 toString 方法。
​
String str = Integer.valueOf(10).toString();
​
方式4： 借助包装类的静态方法 toString 方法。
​
String str = Integer.toString(10);
​

2.3.2 字符串类型转型基本数据类型

方式1: 使用包装类的静态方法 valueOf 方法
​
Integer num = Integer.valueOf("123");
​
方式2： 使用包装类的静态方法 parseXXX 方法。 这里的XXX就是要转换的基本数据类型。
int number = Integer.parseInt("123");

三 常用类

3.1 常用类SimpleDateFormat

概念
是一个用来格式化时间的类。 使用这个类， 一般有两种操作：
将一个 Date 对象， 转成指定格式的时间字符串。
将一个指定格式的时间字符串， 转成 Date 对象。
​
常用的时间格式：
​
占位符 描述
y 表示年。 常用 yyyy 表示长年分。 yy 表示短年份。
M 表示月。 常用 MM 表示两位占位， 如果月份不够两位， 往前补零。
d 表示日。 常用 dd 表示两位占位， 如果日期不够两位， 往前补零。
H 表示时， 24小时制。 常用 HH 表示两位占位， 如果时不够两位， 往前补零。
h 表示时， 12小时制。 常用 hh 表示两位占位， 如果时不够两位， 往前补零。
m 表示分。 常用 mm 表示两位占位， 如果分不够两位， 往前补零。
s 表示秒。 常用 ss 表示两位占位， 如果秒不够两位， 往前补零。
S 表示毫秒。 常用 SSS 表示三位占位， 如果毫秒不够三位， 往前补零。
​
​
常用方法：
​
方法 参数 描述
SimpleDateFormat String 通过一个指定的时间格式， 实例化一个对象。
format Date 将一个Date对象转成指定格式的字符串。
parse String
将一个指定格式的时间字符串，解析成一个Date对
象。
​

3.2 常用类Date

概念：
是一个用来描述时间、日期的类。 在 java.util 包中！！！

3.2.1 比较Date和Data类

Date:日期类
Data:数据类,装的是二进制的数据
​
java.util.date 对应的是java的日期类型,包括年月日 时分秒
java.sql.date 对应的是数据库的日期类型 ,只包括 年月日
如果需要数据类型转换,从java.sql.date转成java.util.date是自动类型转换,反之是强制
类型转换

3.3 常用类Random

概念：
是一个专门负责产生随机数的类。 在Java中， Random类在 java.util 包中。 在使用之前，
需要先导包。
​
方法      参数          描述
Random       无  通过将系统时间作为随机数种子， 实例化一个Random对象
Random      int     通过一个指定的随机数种子，实例化一个Random对象
nextInt     int  生成一个 [0, bounds) 范围内的整型随机数
nextInt     无 生成一个int范围内的随机数
nextFloat   无    生成一个 [0, 1) 范围内的float类型的随机数
nextDouble  无 生成一个 [0, 1) 范围的double类型的随机数
nextBoolean 无 随机生成一个boolean数值
​