概述
JDK5之后推出了一个新的特性:增强型for循环.
也称为"新循环".语法:
for(元素类型 变量名 : 集合或数组){
...
}
注意:新循环只用来遍历集合或数组,不取代传统for循环的工作.
新循环语法是编译器认可,而非虚拟机.编译器会将新循环遍历数组改为普通的 for循环遍历.
public class NewForDemo {
public static void main(String[] args) {
String[] array = {"one","two","three","four","five"};
for(int i=0;i<array.length;i++){
String str = array[i];
System.out.println(str);
}
/*
新循环语法是编译器认可,而非虚拟机.编译器会将新循环遍历数组改为普通的
for循环遍历.
*/
for(String str : array){
System.out.println(str);
}
Collection c = new ArrayList();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
System.out.println(c);
for(Object o : c){
System.out.println((String)o);
}
}
}泛型,JDK5出现时出现的另一个特性 泛型也称为参数化类型,允许我们在使用一个类时去指定该类中某个属性,方法参数,方法返回值的类型.这样可以大大的提高代码的灵活度. 泛型在集合中被广泛使用,用来在使用一个集合是指定该集合的元素类型. 如果不指定,默认为Object类型.
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class NewForDemo {
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
c.add("一");
c.add("二");
c.add("三");
c.add("四");
c.add("五");
Iterator<String> it = c.iterator();
while(it.hasNext()){
String o = it.next();
System.out.println(o);
}
/*
新循环遍历集合会改成迭代器遍历.
*/
for(String o : c){
System.out.println(o);
}
}
}一、泛型概述 泛型：是JDK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查。 泛型的格式：<数据类型>; 注意：泛型只能支持引用数据类型。（int错误，Integer正确） 集合体系的全部接口和实现类都是支持泛型的使用的。 泛型的好处：统一数据类型。 把运行时期的问题提前到了编译期间，避免了强制类型转换可能出现的异常， 因为编译阶段类型就能确定下来。 泛型可以在很多地方进行定义 类后面——>泛型类；方法申明上——>泛型方法；接口后面——>泛型接口
import java.util.ArrayList;
import java.util.List;
public class GenericityDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Java");
list.add("java");
//list.add(123);//类型被统一不匹配
List list1 = new ArrayList();//List<Object> list1 = new ArrayList<>();
list1.add("Java");
list1.add(123);
list1.add(23.4);
list1.add(false);
for(Object o : list1){
String ele = (String)o;
System.out.println(ele);
}//强转类型报错
//解决方案：String ele = o + "";
}
}（1）、泛型类的概述
定义类时同时定义了泛型的类就是泛型类。
泛型类的格式：修饰符 class 类名<泛型变量>{ }
eg. public class MyArrayList<T>{ }
此处泛型变量T可以随便写为任意标识，常见的如E、T、K、V等。
作用：编译阶段可以指定数据类型，类似于集合的作用。
把出现泛型变量的地方全部替换成传输的真实数据类型。
编译阶段约定操作的数据的类型，类似于集合的作用。
public class Test {
//模拟ArrayList集合自定义一个集合MyArrayList集合,完成添加和删除功能的泛型设计即可。
public static void main(String[] args) {
//需求：模拟ArrayList定义一个MyArrayList,关注泛型设计
MyArrayList<String> list= new MyArrayList<>();
list.add("Java");
list.add("java");
list.add("Mysql");
list.remove("Mysql");
System.out.println(list);
MyArrayList<Integer> list1 = new MyArrayList<>();
list1.add(52);
list1.add(99);
list1.add(53);
list1.remove(53);
System.out.println(list1);
}
}
class MyArrayList<E>{//装饰模式，类套类
private ArrayList lists = new ArrayList();
public void add(E e){
lists.add(e);
}
public void remove(E e){
lists.remove(e);
}
@Override
public String toString() {
return lists.toString();
}
}（2）、泛型方法的概述
定义方法时同时定义了泛型的方法就是泛型方法。
泛型方法的格式：修饰符 <泛型变量> 方法返回值 方法名称(形参列表){}
eg.public <T> void show(T t){ }
作用：方法中可以使用泛型接收一切实际类型的参数，方法更具备通用性。
方法中可以使用泛型接收一切实际类型的参数，方法更具备通用性
原理：把出现泛型变量的地方全部替换成传输的真实数据类型。
public class GenericDemo {
//给你任何一个类型的数组，都能返回它的内容。也就是实现Arrays.toString(数组)的功能！
public static void main(String[] args) {
String[] name = {"小明","小强","小英"};
printArray(name);
Integer[] age = {23,34,45};
printArray(age);
Integer[] age1 = getage(age);
}
public static <T> T[] getage(T[] arr){//返回值定义类型
return arr;
}
public static <T> void printArray(T[] arr){
if(arr != null){
StringBuilder sb = new StringBuilder("[");
for (int i = 0; i < arr.length; i++) {
sb.append(arr[i]).append(i == arr.length-1 ? "":",");
}
sb.append("]");
System.out.println(arr);
}else{
System.out.println(arr);
}
}
}泛型接口的概述
使用了泛型定义的接口就是泛型接口。
泛型接口的格式：修饰符 interface 接口名称<泛型变量>{}
eg.public interface Data<E>{ }
作用：泛型接口可以让实现类选择当前功能需要操作的数据类型
泛型接口可以约束实现类，实现类可以在实现接口的时候传入自己操作的数据类型这样重写的方法都将是针对于该类型的操作。
原理：实现类可以在实现接口的时候传入自己操作的数据类型，这样重写的方法都将是针对于该类型的操作。
public interface Data<T> {
//教务系统，提供一个接口可约束一定要完成数据（学生，老师）的增删改查操作
void add(T s);
void delete(int id);
void update(T e);
T queryById(int id);
}
public class Teacher{
}
public class Student{
}
public class TeacherData implements Data<Teacher>{
@Override
public void add(Teacher s) {
}
@Override
public void delete(int id) {
}
@Override
public void update(Teacher e) {
}
@Override
public Teacher queryById(int id) {
return null;
}
}
public class StudentData implements Data<Student>{
@Override
public void add(Student s) {
}
@Override
public void delete(int id) {
}
@Override
public void update(Student e) {
}
@Override
public Student queryById(int id) {
return null;
}
}
泛型通配符：？
? 可以在“使用泛型”的时候代表一切类型。
E T K V 是在定义泛型的时候使用的。
泛型的上下限：? extends Car: ?必须是Car或者其子类 泛型上限
? super Car ： ?必须是Car或者其父类 泛型下限
import java.util.ArrayList;
public class GenericDemo1 {
public static void main(String[] args) {
ArrayList<BMW> bmw = new ArrayList<>();
bmw.add(new BMW());
bmw.add(new BMW());
bmw.add(new BMW());
go(bmw);
ArrayList<BEMZ> bemz = new ArrayList<>();
bemz.add(new BEMZ());
bemz.add(new BEMZ());
bemz.add(new BEMZ());
go(bemz);
}
public static void go(ArrayList<? extends Car> cars){
//不定义上限，dog也能定义
//使用通配符，在使用泛型代表任何类型
}
}
class BMW extends Car{
}
class BEMZ extends Car{
}
class Car{
}二、枚举
枚举是Java中的一种特殊类型
1.枚举的作用："是为了做信息的标志和信息的分类"。
enum Season{
SPRING , SUMMER , AUTUMN , WINTER;
}
//反编译后的特性
Compiled from "Season.java"public final class Season extends java.lang.Enum<Season> {
public static final Season SPRING = new Season();
public static final Season SUMMER = new Season();
public static final Season AUTUMN = new Season();
public static final Season WINTER = new Season();
public static Season[] values();
public static Season valueOf(java.lang.String);
}
2.枚举的特性
- 枚举类都是继承了枚举类型：java.lang.Enum
- 枚举都是最终类，不可以被继承。
- 构造器都是私有的，枚举对外不能创建对象。
- 枚举类的第一行默认都是罗列枚举对象的名称的。
- 枚举类相当于是多例模式。
3.枚举的使用
Season.SPRING//枚举名称.枚举实例类名称
使用优点：代码可读性好，入参约束严谨，代码优雅，是最好的信息分类技术！建议使用!
最后
以上就是快乐方盒为你收集整理的java知识点碎片的全部内容，希望文章能够帮你解决java知识点碎片所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复