public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
// 把泛型删掉后默认为Object类
list.add("abc");
list.add("def");
// list.add("def");
// 已经明确了类型,在使用迭代器的时候,迭代器也同样知道遍历元素的具体类型
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
String str = iterator.next();
// 使用iterator控制元素后 在这里可以直接获取String类型
System.out.println(str.length());
}
// System.out.println(list);
}
修饰符 class 类名<代表泛型的变量>{
}
public class MyGenericClass <MVP>{
// 没有MVP类型,在这里代表未知的一种 数据类型
// 未来传递什么就是什么类型
private MVP mvp;
public MVP getMvp() {
return mvp;
}
public void setMvp(MVP mvp) {
this.mvp = mvp;
}
}
public class TestGenericDemo {
public static void main(String[] args) {
// 创建一个泛型为String的类
MyGenericClass<String> mine = new MyGenericClass<>();
// 不写默认为Object类
// MyGenericClass mine1 = new MyGenericClass<>();
mine.setMvp("哈登");
// 传入什么类型就是什么类型
String mvp = mine.getMvp();
System.out.println(mvp);
MyGenericClass<Integer> mine2 = new MyGenericClass<>();
mine2.setMvp(13);
Integer mine2Mvp = mine2.getMvp();
System.out.println(mine2Mvp);
}
}
修饰符<代表泛型的变量> 返回值类型 方法名 (参数列表)}{
}
public class MyGenericMethod {
public<MVP> void show(MVP mvp){
System.out.println(mvp.getClass());
}
public <MVP> MVP show2(MVP mvp){
return mvp;
}
}
public class TestGenericMethod {
public static void main(String[] args) {
MyGenericMethod mgm = new MyGenericMethod();
// 在调用方法时,确定泛型的类型
mgm.show("罗斯");
mgm.show("德里克");
mgm.show(123);
}
}
修饰符 interface 接口名<泛型>{
}
package com.company.day15.myGeneric;
public interface MyGenericInterface <E>{
public abstract void add(E e);
public abstract E get(E e);
}
public class MyGenericImpL implements MyGenericInterface<String> {
@Override
public void add(String s) {
}
@Override
public String get(String s) {
return null;
}
}
public class MyGenericImpl2<E> implements MyGenericInterface<E> {
@Override
public void add(E e) {
}
@Override
public E getE() {
return null;
}
}
public class TestGenericDemo2 {
public static void main(String[] args) {
MyGenericImpl2<String> impl2 = new MyGenericImpl2<>();
ArrayList<Object> list = new ArrayList<>();
impl2.add("hehe");
}
}
public class TestGenericDemo03 {
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<>();
Collection<String> list2 = new ArrayList<>();
getElement(list1);
getElement(list2);
}
public static void getElement(Collection<?> coll){
// <?> 可以接收任意类型
}
}
在Java中 泛型可以指定一个泛型的上限和下限
格式:
类型名称 <? extends 类> 对象名称
意义:
只能接收该类型及其子类
格式:
类型名称 <? super 类> 对象名称
意义:
只能接收该类型及其父类
public class TestGenericDemo04 {
public static void main(String[] args) {
// 已知object类、String类、Number类、Integer类、其中Number类是Integer的父类
Collection<Integer> list1 = new ArrayList<>();
Collection<String> list2 = new ArrayList<>();
Collection<Number> list3 = new ArrayList<>();
Collection<Object> list4 = new ArrayList<>();
getElement01(list1); // Integer是Number的子类 所以可以使用
// getElement01(list2); String不是Number的子类 报错
getElement01(list3);
// getElement01(list4); Object是Number父类 报错
// getElement02(list1); 下限以下
getElement02(list3); // 本类 可以使用
}
public static void getElement01(Collection<? extends Number> coll){
// 泛型的上限 此时必须是Number类型或者子类
}
public static void getElement02(Collection<? super Number> coll){
// 泛型的下限 此时必须是Number类型或者父类
}
}
指的是程序在执行过程中,出现的非正常的情况,最终会导致JVM的非正常停止 在Java中异常本身是一个类,产生异常就是创建异常对象并且抛出一个异常对象。Java处理异常的方式是中断处理。
异常不是语法错误,语法错误是无法通过编译
异常的根类是java.lang.Throwable,有两个子类 Java.lang.Error 和 Java.lang.Exception 平时说的异常是java.lang.Exception
public void printStackTrace() {
printStackTrace(System.err);
}
public String getMessage() {
return detailMessage;
}
public class Demo01 {
public static void main(String[] args) {
int[] arr = {1,2,3};
System.out.println(arr[3]);
}
}
throw new 异常类名(参数);
public class Demo02 {
public static void main(String[] args) {
int[] arr = {1,2,3};
int index = 4;
int element = getElement(arr, index);
System.out.println(element);
}
public static int getElement(int[]arr,int index){
// 判断
if (index < 0 || index > arr.length - 1){
throw new ArrayIndexOutOfBoundsException("数组越界了,兄弟");
}
return arr[index];
}
}
修饰符 <代表泛型的变量> 返回值类型 方法名(参数列表)throws 异常类
public class Demo3 {
public static void main(String[] args) throws ParseException {
String s = "1994-01-1";
timeFormat(s);
}
public static void timeFormat(String str) throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM");
Date date = sdf.parse(str);
System.out.println(date);
}
}
如果异常出现会立刻终止程序,所以我们得处理异常
try catch的方式就是捕获异常
try 编写可能会出现异常的代码
catch异常的捕获处理
try catch不能单独使用 必须连用
格式:
try{
// 编写可能会出现异常的地方
}catch(异常类型){
// 处理异常的代码
// 记录日志,打印异常信息,继续抛出异常
}
public class Demo04 {
public static void main(String[] args) {
try {
read("xiaomiMi.txt");
}catch (Exception e) {
// try中抛出什么异常,在括号里就捕获什么异常
e.printStackTrace();
System.out.println("---------------------------");
System.out.println(e);
// 打印异常详细信息
}
System.out.println("end");
}
public static void read(String path) throws FileNotFoundException {
if (!path.equals("xiaomimi.txt")){
throw new FileNotFoundException("你的文件怎么消失了呢");
}
}
}
finally 有一些特定的代码,无论是否发生异常都会执行,另外异常会引发程序跳转,导致有些语句执行不到,而finally就解决了这个问题
finally不能单独使用
public class Demo04 {
public static void main(String[] args) {
try {
read("xiaomiMi.txt");
}catch (Exception e) {
// try中抛出什么异常,在括号里就捕获什么异常
e.printStackTrace();
System.out.println("---------------------------");
System.out.println(e);
// 打印异常详细信息
}finally {
System.out.println("不管try和catch执行什么了,我这里都会执行");
System.out.println("我是接盘侠");
}
System.out.println("end");
}
public static void read(String path) throws FileNotFoundException {
if (!path.equals("xiaomimi.txt")){
throw new FileNotFoundException("你的文件怎么消失了呢");
}
}
}
使JDK1.8 版本的新特性 lambda省去面向对象的条条框框,格式由三部分组成
标准格式:
(参数类型 参数名)->{
//代码语句 System.out.println("lambda的饭好了");
}
public class Demo02 {
public static void main(String[] args) {
// 格式: (参数类型 参数名称)-> {代码语句}
invoke(()->{
System.out.println("lambda的饭好了");
});
}
public static void invoke(Cook cook){
cook.makeFood();
}
}
小括号代表Cook接口的makeFood方法 参数为空,大括号代表方法体
需求 使用数组存储多个Person对象,对数组中的Person对象使用Arrays的sort方法通过年龄排序
代码分析
public class Demo06 {
public static void main(String[] args) {
Person[] array = {
new Person("貂蝉",23),
new Person("妲己",26),
new Person("西施",25),
new Person("杨玉环",29),
};
Arrays.sort(array,(Person a,Person b)->{
return a.getAge()-b.getAge();
});
for (Person person:array
) {
System.out.println(person);
}
}
}
public interface Caculator {
int cacu(int a,int b);
}
public class Demo08 {
public static void main(String[] args) {
// 使用lambda表达式调用测试
invokeCacu(5,6,(a,b) -> a + b);
}
public static void invokeCacu(int a,int b,Caculator caculator){
int result = caculator.cacu(a,b);
System.out.println("结果是" + result);
}
}
本文地址:https://blog.csdn.net/weixin_45288697/article/details/107681958
如对本文有疑问, 点击进行留言回复!!
如何在IDEA中对 hashCode()和 equals() 利用快捷键快速进行方法重写
springboot集成普罗米修斯(Prometheus)的方法
Tomcat启动springboot项目war包报错:启动子级时出错的问题
如何利用Spring的@Import扩展点与spring进行无缝整合
网友评论