Java教程
Java-29 泛型 增强for循环 静态导入 可变参数
本文主要是介绍Java-29 泛型 增强for循环 静态导入 可变参数，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
- 泛型：把明确数据类型的工作提前到编译时期，在创建对象的时候明确。这种有点像把类型当作参数进行传递，所以泛型还有另外一种叫法：参数化类型。
- 格式：
<数据类型>
注意：这里的数据类型只能是引用数据类型 - 好处：
1、将运行时期的问题提前到编译时期
2、避免了强制类型转化
3、优化了代码程序，消除不必要的黄色警告线
import java.util.ArrayList;
public class GenericDemo1 {
public static void main(String[] args) {
//JDK1.7之后会自动的进行类型推断
ArrayList<String> strings = new ArrayList<>();
strings.add("hello");
strings.add("world");
// strings.add(1);//报错
//集合遍历
for (String string : strings) {
System.out.println(string);
}
}
}
- 泛型的高级用法：（通配符）
泛型通配符<?>
任意类型，如果没有明确，那么就是Object以及任意的Java类了
//如果泛型里面的类型只用一个的时候，并且明确了数据类型的时候，前后必须要写一致
ArrayList<Object> objects = new ArrayList<Object>();
// ArrayList<Object> objects2 = new ArrayList<Animal>();
// ArrayList<Object> objects2 = new ArrayList<Dog>();
// ArrayList<Object> objects3 = new ArrayList<Cat>();
//泛型通配符<?>
//表示任意类型，如果没有明确，那么就是Object以及任意的Java类
//还没有明确类型
ArrayList<?> objects1 = new ArrayList<Object>();
ArrayList<?> objects2 = new ArrayList<Animal>();
ArrayList<?> objects3 = new ArrayList<Dog>();
ArrayList<?> objects4 = new ArrayList<Cat>();
<? extends E>
向下限定，E及其子类
//<? extends E>
//向下限定，E及其子类
ArrayList<? extends Animal> a1 = new ArrayList<Animal>();
ArrayList<? extends Animal> a2 = new ArrayList<Dog>();
ArrayList<? extends Animal> a3 = new ArrayList<Cat>();
// ArrayList<? extends Animal> a4 = new ArrayList<Object>();
<? super E>
向上限定，E及其父类
//<? super E>
//向上限定，E及其父类
ArrayList<? super Animal> animal1 = new ArrayList<Animal>();
// ArrayList<? super Animal> animal2 = new ArrayList<Dog>();
// ArrayList<? super Animal> animal3 = new ArrayList<Cat>();
ArrayList<? super Animal> animal4 = new ArrayList<Object>();
- 泛型类的使用
public class GenericClass<E> {
private E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
public class GenericDemo3 {
public static void main(String[] args) {
GenericClass<String> stringGenericClass = new GenericClass<>();
stringGenericClass.setName("hello");
System.out.println(stringGenericClass.getName());//hello
// stringGenericClass.setName(12);//编译错误
}
}
- 定义含有泛型的类
/*
泛型方法：将泛型定义方法上
格式：public <泛型类型> 返回类型 方法名(泛型类型 .)
*/
public class GenericDemo4 {
public static void main(String[] args) {
GenericDemo4 genericDemo4 = new GenericDemo4();
genericDemo4.show1(110);
genericDemo4.show1("hello");
genericDemo4.show1(false);
show(112);
show("true");
show('h');
}
//定义一个泛型方法
public <E> void show1(E e){
System.out.println(e);
}
//定义一个含有静态方法的泛型方法
public static <E> void show(E e){
System.out.println(e);
}
}
- 定义泛型接口
- 使用方式一 ：定义接口的实现类，实现接口，指定接口的类型
- 使用方式二：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
/*
把泛型定义在接口上
格式:public interface 接口名<泛型类型1…>
*/
public interface Generic<T> {
public abstract void show(T t);
}
//定义实现接口类
public class GenericClass2<T> implements Generic<T>{
@Override
public void show(T t) {
System.out.println(t);
}
}
/*
泛型接口测试
*/
public class GenericDemo5 {
public static void main(String[] args) {
GenericClass2<String> stringGenericClass2 = new GenericClass2<>();
stringGenericClass2.show("hello");//hello
GenericClass2<Object> objectGenericClass2 = new GenericClass2<>();
objectGenericClass2.show(1);
}
}
- 增强for循环: 用来遍历数组和Collection集合
增强for循环，JDK1.5之后出现
到目前为止，JDK1.5之后出现的特性：泛型、增强for循环、包装类（自动装箱、自动拆箱）
- 格式：
for(元素的数据类型 变量名 : 数组名/Collection集合名称){
使用变量即可，该变量就是元素。
}
- 注意：集合和数组能使用增强for循环的，就使用增强for循环，它也可以消除黄色警告线
public class ForDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = {1,2,3,4,5,6};
// for(int i=0;i<arr.length;i++){
// System.out.println(arr[i]);
// }
System.out.println("+++++++++++++增强for循环遍历数组+++++++++++++");
for (int i : arr) {
System.out.println(i);
}
System.out.println("=====================================");
//创建一个集合对象
ArrayList<String> strings = new ArrayList<String>();
strings.add("hello");
strings.add("world");
strings.add("bigdata");
strings.add("hive");
// for(String string : strings){
// System.out.println(string);
// }
// strings = null;
//NullPointerException
// for (String string : strings) {
// System.out.println(string);
// }
//上面的string是不是从strings集合取出来的，而strings是null
//所以我们在遍历之前加一个判断，判断是不是空
// if(strings != null){
// for (String string : strings) {
// System.out.println(string);
// }
// }
//其实增强for循环就是用来替代迭代器的
//如何验证呢？
//我们之前学迭代器的时候，遇到一个问题：并发修改异常
//ConcurrentModificationException
for(String s : strings){
if("world".equals(s)){
strings.add("flink");
}
}
- 静态导入：
- 格式：import static 包名….类名.方法名;
- 注意事项：
- 方法必须是静态的
- 如果说本类有其他的方法与静态导入的方法重名了，优先使用的是本类中的方法
- 当静态导入的方法重名了，通过增加前缀的方法去调用
public class FunctionDemo {
public static void show(String s){
System.out.println(s);
}
public static int abs(int i){
System.out.println("这是在FunctionDemo中的abs方法");
return i;
}
}
/*
静态导入：
静态导入概述
格式：import static 包名….类名.方法名;
可以直接导入到方法的级别
*/
import static java.lang.Math.abs;
import static com.shujia.java.day18.FunctionDemo.show;
import static com.shujia.java.day18.FunctionDemo.abs;
public class StaticImportDemo {
public static void main(String[] args) {
System.out.println(Math.abs(-100));
//有没有什么办法，不用去写类名，直接写方法名调用即可
// System.out.println(abs(-100));
//有一种办法，可以不用写类名，直接通过使用方法名调用
//静态导入 import static java.lang.Math.abs;
// System.out.println(abs(-200));
//在一个程序种静态导入使用的方式可以和类名直接调用方式共存
show("hello");//这是在本类中的show方法
FunctionDemo.show("world");
//当静态导入的方法重名了，怎么办呢？
//通过增加前缀的方法去调用
// System.out.println(abs(20));
System.out.println(com.shujia.java.day18.FunctionDemo.abs(20));
}
public static void show(String s){
System.out.println("这是在本类中的show方法");
}
}
可变参数：
/*
可变参数概述
定义方法的时候不知道该定义多少个参数
格式
修饰符 返回值类型 方法名(数据类型... 变量名){}
注意：
这里的变量其实是一个数组
如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
*/
public class ArgsDemo {
public static void main(String[] args) {
//求两个数之和
int a = 10;
int b = 20;
sum(a,b);
//求三个数之和
int c = 30;
sum(a,b,c);
//求四个数之和
int d = 40;
sum(a,b,c,d);
//可变参数改进
sum(a,b,c,d,12,32,41,2,13,141,431,31,313,89);
}
public static void sum(int... ints){
int sum =0;
//这里的变量其实是一个数组
for (int anInt : ints) {
sum +=anInt;
}
System.out.println(sum);
}
public static void sum(int i,int j){
System.out.println(i+j);
}
public static void sum(int i,int j,int x){
System.out.println(i+j+x);
}
public static void sum(int i,int j,int x,int y){
System.out.println(i+j+x+y);
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/*
Arrays工具类中的可变参数方法举例：
public static <T> List<T> asList(T... a)：将数组转成集合
1、集合与数组之间的互相转换
2、数组排序
*/
public class ArraysDemo {
public static void main(String[] args) {
//集合--数组
ArrayList<Integer> integers = new ArrayList<Integer>();
integers.add(33);
integers.add(44);
integers.add(11);
integers.add(55);
integers.add(22);
//将集合转成数组
Object[] objects = integers.toArray();
//数组--集合
List<Object> objectList = Arrays.asList(objects);
for (Object o : objectList) {
Integer i = (Integer)o;
System.out.println(i);
}
System.out.println("******************************");
Arrays.sort(objects);
for (Object object : objects) {
System.out.println(object);
}
}
}
这篇关于Java-29 泛型 增强for循环 静态导入 可变参数的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
微服务架构中API版本控制的实践09-28
-
AI给的和自己写的Python代码，都无法改变输入框的内容，替换也不行09-28
-
Sentinel配置限流资料：新手入门教程09-27
-
Sentinel配置限流资料详解09-27
-
Sentinel限流资料：新手入门教程09-27
-
Sentinel限流资料入门详解09-26
-
Springboot框架资料：初学者入门教程09-26
-
Springboot框架资料详解：新手入门教程09-26
-
Springboot企业级开发资料：新手入门指南09-26
-
SpringBoot企业级开发资料新手指南09-26
-
Springboot微服务资料入门教程09-26
-
SpringBoot微服务资料入门指南09-26
-
Springboot项目开发资料：新手入门及初级实战教程09-26
-
Springboot项目开发资料：新手入门教程09-26
-
SpringCloud Alibaba资料入门详解09-26
栏目导航
