新乡网站建设公司,seo厂商,天津市建设网,厦门网上房地产网官方网站文章目录 1、this关键字2、泛型2.1 泛型介绍2.2 泛型分类定义2.2.1 泛型类2.2.2 泛型方法2.2.3 泛型接口 2.3 泛型通配符 3、可变参数4、日志4.1 使用步骤4.2 日志级别4.3 配置文件 5、类加载器5.1 类加载器5.2 类加载的完整过程5.2.1 类加载时机5.2.2 类加载过程 5.3 类加载的… 文章目录 1、this关键字2、泛型2.1 泛型介绍2.2 泛型分类定义2.2.1 泛型类2.2.2 泛型方法2.2.3 泛型接口 2.3 泛型通配符 3、可变参数4、日志4.1 使用步骤4.2 日志级别4.3 配置文件 5、类加载器5.1 类加载器5.2 类加载的完整过程5.2.1 类加载时机5.2.2 类加载过程 5.3 类加载的分类5.4 双亲委派模型5.5 ClassLoader 中的两个方法 6、注解6.1 注释和注解的区别6.2 如何使用注解6.3 Java中已经存在的注解6.4 自定义注解6.5 特殊属性6.6 元注解6.7 模拟JUnit自带的Test注解 7、内部类7.1 概述7.1.1 什么是内部类7.1.2 什么时候使用内部类 7.2 内部类的分类7.3 成员内部类7.4 成员内部类的细节7.5 成员内部类面试题7.6 成员内部类内存图7.7 静态内部类7.8 局部内部类7.9 匿名内部类7.9.1 匿名内部类概述7.9.2 匿名内部类格式7.9.3 什么时候使用匿名内部类7.9.4 匿名内部类简单使用7.9.5 匿名内部类作参数 1、this关键字
this关键字常见用法和含义
1引用当前对象的成员变量当类的成员变量与方法的参数或局部变量同名时使用 this 关键字可以明确地指示要引用的是成员变量。例如
public class Person {private String name;public void setName(String name) {this.name name;}
}在上面的例子中this.name 引用了类的成员变量 name而 name 是方法的参数。这样可以区分变量名避免歧义。 局部变量方法内 成员变量方法外 this的作用区分局部变量和成员变量 this的本质代表方法调用者的地址值 如果不使用this关键字则变量遵循就近原则即谁离得近就使用谁的值。 2在构造方法中调用其他构造方法在一个类的构造方法中可以使用 this 关键字来调用同一个类的其他构造方法。这样可以避免代码重复。例如
public class Person {private String name;private int age;public Person() {this(John Doe, 30); // 调用另一个构造方法}public Person(String name, int age) {this.name name;this.age age;}
}在上面的例子中无参构造方法 Person() 使用 this(John Doe, 30) 调用有参构造方法 Person(String name, int age)。
3返回当前对象在方法中可以使用 this 关键字来返回当前对象的引用这在实现方法链式调用时很常见。例如
public class Person {private String name;private int age;public Person setName(String name) {this.name name;return this;}public Person setAge(int age) {this.age age;return this;}
}当在一个方法中使用 return this; 语句时它表示将当前对象作为方法的返回值返回。在上面的代码中setName() 和 setAge() 方法都返回 Person 对象以便允许方法的连续调用。使用这种方法可以以一种链式的方式设置对象的属性如
Person person new Person().setName(John).setAge(30);2、泛型
2.1 泛型介绍
泛型是JDK5中引入的特性它提供了编译时类型安全检测机制
1泛型的好处
把运行时期的问题提前到了编译期间避免了强制类型转换
2泛型的定义格式
类型指定一种类型的格式尖括号里面可以任意书写,一般只写一个字母。例如 类型1,类型2…指定多种类型的格式多种类型之间用逗号隔开。例如E,T K,V
3泛型的作用
如果我们没有给集合指定类型默认认为所有的数据类型都是Object类型此时可以往集合添加任意的数据类型。这样带来一个坏处我们在获取数据的时候无法使用他的特有行为。
此时推出了泛型可以在添加数据的时候就把类型进行统一而且我们在获取数据的时候也省的强转了非常的方便。
4注意事项
泛型中不能写基本数据类型指定泛型的具体类型后传递数据时可以传入该类类型或者其子类类型如果不写泛型类型默认是Object迭代器的泛型和集合的泛型要保持一致Java中的泛型是伪泛型编译为字节码文件后会当做Object处理泛型的擦除
2.2 泛型分类定义
2.2.1 泛型类
1泛型类在类名后面定义泛型创建该类对象的时候确定类型。
修饰符 class 类名类型{
}public class ArrayListE{
}2代码示例
定义泛型类
public class MyArrayListE {// 指定集合默认初始化的长度为10Object[] obj new Object[10];int size;/*** E : 表示是不确定的类型。该类型在类名后面已经定义过了。* e形参的名字变量名*/public boolean add(E e){obj[size] e;size;return true;}public E get(int index){return (E)obj[index];}Overridepublic String toString() {return Arrays.toString(obj);}
}泛型类测试
public class GenericsDemo02 {public static void main(String[] args) {MyArrayListString list new MyArrayList();list.add(aaa);list.add(bbb);list.add(ccc);System.out.println(list.size);System.out.println(list);MyArrayListInteger list2 new MyArrayList();list2.add(123);list2.add(456);list2.add(789);int i list2.get(0);System.out.println(i);System.out.println(list2);}
}2.2.2 泛型方法
1泛型方法在修饰符后面定义方法调用该方法的时候确定类型。
修饰符类型 返回值类型 方法名(类型变量名){
}publicT void show(T t){
}public staticT void show(T t){
}2代码示例
泛型方法
public class ListUtil {private ListUtil(){}/*** 泛型方法* 类中定义一个静态方法addAll用来添加多个集合的元素。* 参数一集合* 参数二~最后要添加的元素*/public staticE void addAll(ArrayListE list, E e1, E e2, E e3, E e4){list.add(e1);list.add(e2);list.add(e3);list.add(e4);}/* public staticE void addAll2(ArrayListE list, E...e){for (E element : e) {list.add(element);}}*/
}泛型方法测试
public class GenericsDemo03 {public static void main(String[] args) {ArrayListString list1 new ArrayList();ListUtil.addAll(list1, aaa, bbb, ccc, ddd);System.out.println(list1);ArrayListInteger list2 new ArrayList();ListUtil.addAll(list2,1,2,3,4);System.out.println(list2);}
}2.2.3 泛型接口
1泛型接口在接口名后面定义泛型实现类确定类型实现类延续泛型。
定义
修饰符 interface 接口名类型{
}public interface ListE{
}使用
// 实现类给出具体的类型
public class MyList implements ListString {
}
// 实现类延续泛型创建实现类对象时再确定类型
public class MyList2E implements ListE {
}2代码示例
实现类实现类延续泛型创建实现类对象时再确定类型
public class MyArrayList3E implements ListE {Overridepublic int size() {return 0;}Overridepublic boolean isEmpty() {return false;}Overridepublic boolean contains(Object o) {return false;}Overridepublic IteratorE iterator() {return null;}Overridepublic Object[] toArray() {return new Object[0];}Overridepublic T T[] toArray(T[] a) {return null;}Overridepublic boolean add(E e) {return false;}Overridepublic boolean remove(Object o) {return false;}Overridepublic boolean containsAll(Collection? c) {return false;}Overridepublic boolean addAll(Collection? extends E c) {return false;}Overridepublic boolean addAll(int index, Collection? extends E c) {return false;}Overridepublic boolean removeAll(Collection? c) {return false;}Overridepublic boolean retainAll(Collection? c) {return false;}Overridepublic void clear() {}Overridepublic E get(int index) {return null;}Overridepublic E set(int index, E element) {return null;}Overridepublic void add(int index, E element) {}Overridepublic E remove(int index) {return null;}Overridepublic int indexOf(Object o) {return 0;}Overridepublic int lastIndexOf(Object o) {return 0;}Overridepublic ListIteratorE listIterator() {return null;}Overridepublic ListIteratorE listIterator(int index) {return null;}Overridepublic ListE subList(int fromIndex, int toIndex) {return null;}
}实现类实现类给出具体的类型
public class MyArrayList2 implements ListString {Overridepublic int size() {return 0;}Overridepublic boolean isEmpty() {return false;}Overridepublic boolean contains(Object o) {return false;}Overridepublic IteratorString iterator() {return null;}Overridepublic Object[] toArray() {return new Object[0];}Overridepublic T T[] toArray(T[] a) {return null;}Overridepublic boolean add(String s) {return false;}Overridepublic boolean remove(Object o) {return false;}Overridepublic boolean containsAll(Collection? c) {return false;}Overridepublic boolean addAll(Collection? extends String c) {return false;}Overridepublic boolean addAll(int index, Collection? extends String c) {return false;}Overridepublic boolean removeAll(Collection? c) {return false;}Overridepublic boolean retainAll(Collection? c) {return false;}Overridepublic void clear() {}Overridepublic String get(int index) {return null;}Overridepublic String set(int index, String element) {return null;}Overridepublic void add(int index, String element) {}Overridepublic String remove(int index) {return null;}Overridepublic int indexOf(Object o) {return 0;}Overridepublic int lastIndexOf(Object o) {return 0;}Overridepublic ListIteratorString listIterator() {return null;}Overridepublic ListIteratorString listIterator(int index) {return null;}Overridepublic ListString subList(int fromIndex, int toIndex) {return null;}
}实现类对象
public class GenericsDemo04 {public static void main(String[] args) {/*** 泛型接口的两种使用方式* 1.实现类给出具体的类型* 2.实现类延续泛型创建实现类对象时再确定类型*/// 实现类给出具体的类型MyArrayList2 list new MyArrayList2();// 实现类延续泛型创建实现类对象时再确定类型MyArrayList3String list2 new MyArrayList3();MyArrayList3Integer list3 new MyArrayList3();// 之后的操作和操作普通list类似只不过实现类中还没实现具体的方法}
}2.3 泛型通配符
需求定义一个方法方法的参数类型为不确定类型但是希望只能传递Ye Fu Zi类型的数据不能传递Student类型的数据
1仅使用泛型不使用泛型通配符时
泛型里面写的是什么类型那么只能传递什么类型的数据。而如果泛型方法设置为类型为T时就又可以接受任意的数据类型不符合要求。
2使用泛型通配符可以解决这个需求 ? 不仅可以表示不确定的类型还可以进行类型的限定? extends E: 表示可以传递E或者E所有的子类类型? super E表示可以传递E或者E所有的父类类型3泛型通配符应用场景
如果我们在定义类、方法、接口的时候如果类型不确定就可以定义泛型类、泛型方法、泛型接口。如果类型不确定但是能知道以后只能传递某个继承体系中的就可以泛型的通配符 泛型的通配符。
关键点可以限定类型的范围。
4代码示例
public class GenericsDemo06 {public static void main(String[] args) {//创建集合的对象ArrayListYe list1 new ArrayList();ArrayListFu list2 new ArrayList();ArrayListZi list3 new ArrayList();ArrayListStudent list4 new ArrayList();method(list1);method(list2);//method(list3); // 报错//method(list4); // 报错}// 可以传递Fu及Fu的所有父类类型public static void method(ArrayList? super Fu list) {}
}class Ye {
}class Fu extends Ye {
}class Zi extends Fu {
}class Student{}3、可变参数
格式
属性类型...名字
int...args可变参数底层就是一个数组在方法的形参中最多只能写一个可变参数在方法的形参当中如果出了可变参数以外还有其他的形参那么可变参数要写在最后
public class ArgsDemo3 {public static void main(String[] args) {int sum getSum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);System.out.println(sum);}public static int getSum(int...args){int sum 0;for (int i : args) {sum sum i;}return sum;}
}4、日志
4.1 使用步骤 把第三方的代码导入到当前的项目当中 新建lib文件夹把jar粘贴到lib文件夹当中全选后右键点击选择add as library 检测导入成功导入成功后jar包可以展开。在项目重构界面可以看到导入的内容 把配置文件粘贴到src文件夹下 在代码中获取日志对象 调用方法打印日志
4.2 日志级别
TRACE, DEBUG, INFO, WARN, ERROR还有两个特殊的
ALL输出所有日志OFF关闭所有日志
日志级别从小到大的关系TRACE DEBUG INFO WARN ERROR
4.3 配置文件
?xml version1.0 encodingUTF-8?
configuration!--CONSOLE 表示当前的日志信息是可以输出到控制台的。--appender nameCONSOLE classch.qos.logback.core.ConsoleAppender!--输出流对象 默认 System.out 改为 System.err--targetSystem.out/targetencoder!--格式化输出%d表示日期%thread表示线程名%-5level级别从左显示5个字符宽度%msg日志消息%n是换行符--pattern%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %c [%thread] : %msg%n/pattern/encoder/appender!-- File是输出的方向通向文件的 --appender nameFILE classch.qos.logback.core.rolling.RollingFileAppenderencoderpattern%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n/patterncharsetutf-8/charset/encoder!--日志输出路径--fileC:/code/itheima-data.log/file!--指定日志文件拆分和压缩规则--rollingPolicyclassch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy!--通过指定压缩文件名称来确定分割文件方式--fileNamePatternC:/code/itheima-data2-%d{yyyy-MMdd}.log%i.gz/fileNamePattern!--文件拆分大小--maxFileSize1MB/maxFileSize/rollingPolicy/appender!--level:用来设置打印级别大小写无关TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF 默认debugroot可以包含零个或多个appender-ref元素标识这个输出位置将会被本日志级别控制。--root levelinfoappender-ref refCONSOLE/appender-ref refFILE //root
/configuration5、类加载器
5.1 类加载器
作用负责将.class文件存储的物理文件加载在到内存中 5.2 类加载的完整过程
5.2.1 类加载时机
简单理解字节码文件什么时候会被加载到内存中
有以下的几种情况
创建类的实例对象调用类的类方法访问类或者接口的类变量或者为该类变量赋值使用反射方式来强制创建某个类或接口对应的java.lang.Class对象初始化某个类的子类直接使用java.exe命令来运行某个主类
总结而言用到了就加载不用不加载
5.2.2 类加载过程
1加载
通过包名 类名获取这个类准备用流进行传输在这个类加载到内存中加载完毕创建一个class对象 2链接 验证 确保Class文件字节流中包含的信息符合当前虚拟机的要求并且不会危害虚拟机自身安全 (文件中的信息是否符合虚拟机规范有没有安全隐患) 准备 负责为类的类变量被static修饰的变量分配内存并设置默认初始化值 (初始化静态变量) 解析 将类的二进制数据流中的符号引用替换为直接引用 (本类中如果用到了其他类此时就需要找到对应的类) 3初始化
根据程序员通过程序制定的主观计划去初始化类变量和其他资源
(静态变量赋值以及初始化其他资源) 当一个类被使用的时候才会加载到内存类加载的过程: 加载、验证、准备、解析、初始化 5.3 类加载的分类
1分类
Bootstrap class loader虚拟机的内置类加载器通常表示为null 并且没有父nullPlatform class loader平台类加载器负责加载JDK中一些特殊的模块System class loader系统类加载器负责加载用户类路径上所指定的类库
2类加载器的继承关系
System的父加载器为PlatformPlatform的父加载器为Bootstrap
3代码演示
public class ClassLoaderDemo1 {public static void main(String[] args) {//获取系统类加载器ClassLoader systemClassLoader ClassLoader.getSystemClassLoader();//获取系统类加载器的父加载器 --- 平台类加载器ClassLoader classLoader1 systemClassLoader.getParent();//获取平台类加载器的父加载器 --- 启动类加载器ClassLoader classLoader2 classLoader1.getParent();System.out.println(系统类加载器 systemClassLoader);System.out.println(平台类加载器 classLoader1);System.out.println(启动类加载器 classLoader2);}
}5.4 双亲委派模型
1介绍
如果一个类加载器收到了类加载请求它并不会自己先去加载而是把这个请求委托给父类的加载器去执行如果父类加载器还存在其父类加载器则进一步向上委托依次递归请求最终将到达顶层的启动类加载器如果父类加载器可以完成类加载任务就成功返回倘若父类加载器无法完成此加载任务子加载器才会尝试自己去加载这就是双亲委派模式 5.5 ClassLoader 中的两个方法
1方法介绍
方法名说明public static ClassLoader getSystemClassLoader()获取系统类加载器public InputStream getResourceAsStream(String name)加载某一个资源文件
2示例代码
public class ClassLoaderDemo2 {public static void main(String[] args) throws IOException {//static ClassLoader getSystemClassLoader() 获取系统类加载器//InputStream getResourceAsStream(String name) 加载某一个资源文件//获取系统类加载器ClassLoader systemClassLoader ClassLoader.getSystemClassLoader();//利用加载器去加载一个指定的文件//参数文件的路径放在src的根目录下默认去那里加载//返回值字节流。InputStream is systemClassLoader.getResourceAsStream(prop.properties);Properties prop new Properties();prop.load(is);System.out.println(prop);is.close();}
}6、注解
6.1 注释和注解的区别
共同点都可以对程序进行解释说明。
不同点
注释是给程序员看的。只在Java中有效。在class文件中不存在注释的。当编译之后会进行注释擦除。注解是给虚拟机看的。当虚拟机看到注解之后就知道要做什么事情了。
6.2 如何使用注解
举例子类重写父类方法的时候在重写的方法上面写Override。当虚拟机看到Override的时候就知道下面的方法是重写的父类的。检查语法如果语法正确编译正常如果语法错误就会报错。
6.3 Java中已经存在的注解
Override表示方法的重写 Deprecated表示修饰的方法已过时 SuppressWarnings(“all”)压制警告
除此之外还需要掌握第三方框架中提供的注解比如在Junit中
Test 表示运行测试方法 Before 表示在Test之前运行进行数据的初始化 After 表示在Test之后运行进行数据的还原
6.4 自定义注解
自定义注解单独存在是没有什么意义的一般会跟反射结合起来使用会用发射去解析注解。
关于注解的解析一般是在框架的底层已经写好了。
6.5 特殊属性
value当注解中只有“一个属性“并且属性名是“value“使用注解时可以省略value属性名。
//注解的定义
public interface Anno2 {public String value();public int age() default 23;
}//注解的使用
Anno2(123)
public class AnnoDemo2 {Anno2(123)public void method(){}
}6.6 元注解
元注解可以写在注解上面的注解如
Target 指定注解能在哪里使用Retention 可以理解为保留时间(生命周期)
1Target
作用用来标识注解使用的位置如果没有使用该注解标识则自定义的注解可以使用在任意位置。
可使用的值定义在ElementType枚举类中常用值如下
TYPE类接口FIELD, 成员变量METHOD, 成员方法PARAMETER, 方法参数CONSTRUCTOR, 构造方法LOCAL_VARIABLE, 局部变量
2Retention
作用用来标识注解的生命周期(有效范围)
可使用的值定义在RetentionPolicy枚举类中常用值如下
SOURCE注解只作用在源码阶段生成的字节码文件中不存在CLASS注解作用在源码阶段字节码文件阶段运行阶段不存在默认值RUNTIME注解作用在源码阶段字节码文件阶段运行阶段
6.7 模拟JUnit自带的Test注解
Target(ElementType.METHOD)
Retention(RetentionPolicy.RUNTIME)
public interface MyTest {
}public class MyTestMethod {MyTestpublic void method1(){System.out.println(method1);}public void method2(){System.out.println(method2);}MyTestpublic void method3(){System.out.println(method3);}
}public class MyTestDemo {public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException {//1,获取class对象Class clazz Class.forName(com.itheima.test2.MyTestMethod);//获取对象Object o clazz.newInstance();//2.获取所有方法Method[] methods clazz.getDeclaredMethods();for (Method method : methods) {//method依次表示类里面的每一个方法method.setAccessible(true);//判断当前方法有没有MyTest注解if(method.isAnnotationPresent(MyTest.class)){method.invoke(o);}}}
}7、内部类
7.1 概述
7.1.1 什么是内部类
将一个类A定义在另一个类B里面里面的那个类A就称为内部类B则称为外部类。可以把内部类理解成寄生外部类理解成宿主。
7.1.2 什么时候使用内部类
一个事物内部还有一个独立的事物内部的事物脱离外部的事物无法独立使用
人里面有一颗心脏。汽车内部有一个发动机。为了实现更好的封装性。
7.2 内部类的分类
按定义的位置来分
1成员内部内类定义在了成员位置 (类中方法外称为成员位置无static修饰的内部类) 2静态内部类类定义在了成员位置 (类中方法外称为成员位置有static修饰的内部类) 3局部内部类类定义在方法内 4匿名内部类没有名字的内部类可以在方法中也可以在类中方法外。
7.3 成员内部类
1成员内部类特点
无static修饰的内部类属于外部类对象的。宿主外部类对象。
2内部类的使用格式 外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类3获取成员内部类对象的两种方式
方式一外部直接创建成员内部类的对象
外部类.内部类 变量 new 外部类.new 内部类;方式二在外部类中定义一个方法提供内部类的对象
4代码演示
方式一
public class Test {public static void main(String[] args) {// 宿主外部类对象。// Outer out new Outer();// 创建内部类对象。Outer.Inner oi new Outer().new Inner();oi.method();}
}class Outer {// 成员内部类属于外部类对象的。// 拓展成员内部类不能定义静态成员。public class Inner{// 这里面的东西与类是完全一样的。public void method(){System.out.println(内部类中的方法被调用了);}}
}方式二
public class Outer {String name;private class Inner{static int a 10;}public Inner getInstance(){return new Inner();}
}public class Test {public static void main(String[] args) {Outer o new Outer();System.out.println(o.getInstance());}
}7.4 成员内部类的细节
编写成员内部类的注意点
成员内部类可以被一些修饰符所修饰比如 private默认protectedpublicstatic等在成员内部类里面JDK16之前不能定义静态变量JDK16开始才可以定义静态变量。创建内部类对象时对象中有一个隐含的Outer.this记录外部类对象的地址值。
详解
内部类被private修饰外界无法直接获取内部类的对象只能通过3.3节中的方式二获取内部类的对象被其他权限修饰符修饰的内部类一般用3.3节中的方式一直接获取内部类的对象内部类被static修饰是成员内部类中的特殊情况叫做静态内部类下面单独学习。内部类如果想要访问外部类的成员变量外部类的变量必须用final修饰JDK8以前必须手动写finalJDK8之后不需要手动写JDK默认加上。
7.5 成员内部类面试题
请在?处填写相应的代码以达到输出的内容 内部类访问外部类对象的格式是外部类名.this public class Test {public static void main(String[] args) {Outer.inner oi new Outer().new inner();oi.method();}
}class Outer { // 外部类private int a 30;// 在成员位置定义一个类class inner {private int a 20;public void method() {int a 10;System.out.println(???); // 10 答案aSystem.out.println(???); // 20 答案this.aSystem.out.println(???); // 30 答案Outer.this.a}}
}7.6 成员内部类内存图 7.7 静态内部类
1静态内部类特点
静态内部类是一种特殊的成员内部类。有static修饰属于外部类本身的。静态内部类与其他类的用法完全一样。只是访问的时候需要加上外部类.内部类。静态内部类可以直接访问外部类的静态成员。静态内部类不可以直接访问外部类的非静态成员如果要访问需要创建外部类的对象。静态内部类中没有隐含的Outer.this。
2内部类的使用格式
外部类.内部类3静态内部类对象的创建格式
外部类.内部类 变量 new 外部类.内部类构造器;4调用方法的格式
调用非静态方法的格式先创建对象用对象调用调用静态方法的格式外部类名.内部类名.方法名();
5代码示例
// 外部类Outer01
class Outer01{private static String sc_name 黑马程序;// 内部类: Inner01public static class Inner01{// 这里面的东西与类是完全一样的。private String name;public Inner01(String name) {this.name name;}public void showName(){System.out.println(this.name);// 拓展:静态内部类可以直接访问外部类的静态成员。System.out.println(sc_name);}}
}public class InnerClassDemo01 {public static void main(String[] args) {// 创建静态内部类对象。// 外部类.内部类 变量 new 外部类.内部类构造器;Outer01.Inner01 in new Outer01.Inner01(张三);in.showName();}
}7.8 局部内部类
局部内部类定义在方法中的类。
定义格式
class 外部类名 {数据类型 变量名;修饰符 返回值类型 方法名(参数列表) {// …class 内部类 {// 成员变量// 成员方法}}
}7.9 匿名内部类
7.9.1 匿名内部类概述
匿名内部类是内部类的简化写法是一个隐含了名字的内部类。
匿名内部类必须继承一个父类或者实现一个父接口。
匿名内部类的特点
1定义一个没有名字的内部类 2这个类实现了父类或者父类接口 3匿名内部类会创建这个没有名字的类的对象
7.9.2 匿名内部类格式
new 类名或者接口名() {重写方法;
};new 父类名或者接口名(){// 方法重写Override public void method() {// 执行语句}
};包含了 继承或者实现关系 方法重写 创建对象
所以从语法上来讲这个整体其实是匿名内部类对象。
7.9.3 什么时候使用匿名内部类
如果希望定义一个只要使用一次的类就可考虑使用匿名内部类。匿名内部类的本质作用是为了简化代码。
之前使用接口时似乎得做如下几步操作
定义子类重写接口中的方法创建子类对象调用重写后的方法
interface Swim {public abstract void swimming();
}// 1. 定义接口的实现类
class Student implements Swim {// 2. 重写抽象方法Overridepublic void swimming() {System.out.println(狗刨式...);}
}public class Test {public static void main(String[] args) {// 3. 创建实现类对象Student s new Student();// 4. 调用方法s.swimming();}
}而最终的目的只是为了调用方法所以可以使用匿名内部类把以上四步合成一步。
7.9.4 匿名内部类简单使用
以接口为例匿名内部类的使用代码如下
interface Swim {public abstract void swimming();
}public class Demo07 {public static void main(String[] args) {// 使用匿名内部类new Swim() {Overridepublic void swimming() {System.out.println(自由泳...);}}.swimming();// 接口 变量 new 实现类(); // 多态走子类的重写方法Swim s2 new Swim() {Overridepublic void swimming() {System.out.println(蛙泳...);}};s2.swimming();}
}7.9.5 匿名内部类作参数
通常在方法的形式参数是接口或者抽象类时也可以将匿名内部类作为参数传递。
举例一
interface Swim {public abstract void swimming();
}public class Demo07 {public static void main(String[] args) {// 方法1// 匿名内部类使用场景:作为方法参数传递Swim s new Swim() {Overridepublic void swimming() {System.out.println(蝶泳...);}};// 传入匿名内部类goSwimming(s);// 方法2一步到位goSwimming(new Swim() {public void swimming() {System.out.println(蛙泳...);}});}// 定义一个方法方法的形式参数是一个接口public static void goSwimming(Swim s) {s.swimming();}
}举例二
interface MyInterface {void myMethod();
}class MyClass {void processInterface(MyInterface myInterface) {myInterface.myMethod();}
}public class Main {public static void main(String[] args) {MyClass myClass new MyClass();// 通过匿名内部类实现接口并传递给方法myClass.processInterface(new MyInterface() {Overridepublic void myMethod() {System.out.println(Implementation of myMethod in anonymous inner class);}});}
}
