package Generic;
import link.Link;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
/**
* 1、JDK5.0后推出的新特性：泛型
* 2、泛型这种语法机制，只在程序编译阶段起作用，只是给编译器参考的（运行阶段泛型没用）
* 3、使用了泛型好处是什么？
* 1、集合中存储的元素类型统一了
* 2、从集合中取出的元素类型是泛型指定的类型，不需要进行大量的“向下转型”
* （但调用子类特有的方法时，还是要向下转型的）
*
* 缺点：
* 导致集合中存储的元素缺乏多样性。
*/
public class Note01 {
public static void main(String[] args) {
//不使用泛型的话
List aa = new ArrayList();
Cat cat = new Cat();
Bird bird = new Bird();
aa.add(cat);
aa.add(bird);
Iterator it = aa.iterator();
while(it.hasNext()) {
//强转的原因是，取出集合中的元素时Object类型的，不是Animal类型的
//这才是标准的，因为你不知道到底是不是Animal类型的，向下面的那个强转其实是不正确的
//当集合中有其他类，如Person类时，就出错了
Object obj = it.next();
if(obj instanceof Animal){
Animal o = (Animal) it.next();
if (o instanceof Cat) {
//向下转型
Cat cat1 = (Cat) o;
cat1.catchmouse();
} else if (o instanceof Bird) {
Bird bird1 = (Bird) o;
bird1.sing();
}
}
// Animal o = (Animal) it.next();
}
//使用泛型
List<Animal> bb = new ArrayList<Animal>();
bb.add(cat);
bb.add(bird);
//表示迭代器迭代的是Animal类型
Iterator<Animal> it2 = bb.iterator();
while(it2.hasNext()){
//使用泛型之后，每一次迭代返回的数据都是Animal类型
//这里不需要强制类型转换了，直接调用，省略了下面三行
/* Object obj = it.next();
if(obj instanceof Animal){
Animal o = (Animal) it.next();*/
Animal a = it2.next();
if(a instanceof Cat){
Cat cat1 = (Cat)a;
cat1.catchmouse();;
}else if(a instanceof Bird){
Bird bird1 = (Bird)a;
bird1.sing();
}
}
}
}
class Animal{
public void move(){
System.out.println("动物在移动");
}
}
class Cat extends Animal{
public void catchmouse(){
System.out.println("猫在抓老鼠");
}
}
class Bird extends Animal{
public void sing(){
System.out.println("鸟儿在唱歌");
}
}
package Generic;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* JDK8之后引入了：自动类型推断机制（又称钻石表达式）
*
*/
public class Test01 {
public static void main(String[] args) {
//ArrayList<这里的类型会自动推断>,JDK8之后的
//钻石表达式，后面JVM自动推断
List<Animal> aa = new ArrayList<>();
aa.add(new Animal());
aa.add(new Cat());
aa.add(new Bird());
Iterator<Animal> it = aa.iterator();
while(it.hasNext()){
Animal animal = it.next();
animal.move();
}
List<String> ss = new ArrayList<>();
ss.add("http://www.12121212.com");
ss.add("http://www.baidu.com");
ss.add("http://www.360.com");
//前面写泛型，后面不用写
Iterator<String> it02 = ss.iterator();
//不用泛型
/* while(it02.hasNext()){
Object obj = it02.next();
if(obj instanceof String){
String ss03 = (String)obj;
System.out.println(ss03.substring(7));
}
}*/
while(it02.hasNext()){
String ss02 = it02.next().substring(11);
System.out.println(ss02);
}
}
}
package Generic;
import link.Link;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*自定义泛型可以吗
* 可以(但是泛型不能以数字开头）,因为是标识符，由数字，英文字母，下划线，美元符号构成
* 不能以数字开头，以及java关键字作为标识符
* java源代码：
* <E> 和 <T>
* E是Element单词首字母
* T是Type的首字母
* 疑问：为什么要使用泛型，好处在哪里？
* 1、可以避免对集合的元素（Object类）进行判断，不需要进行判断强转了，编译时方便了许多，
* 否则，你还得判断是不是Animal类型的，但调用子类特有的方法时，避免不了向下转型
*
*
*/
public class Test02<E>{
public void doSome(E a){
System.out.println(a);
}
public static void main(String[]args){
//这里是String类型的，因为a是String类型的，A就是一个标识符，这样认为是错误的
//Test02<String>因为你在这里定义了tt的泛型是String的
Test02<String> aa = new Test02<>();
aa.doSome("wf");
Test02<Integer> dd = new Test02<>();
dd.doSome(12);
Miao<Object> ee = new Miao<>();
System.out.println(ee.get());
//不用泛型的话，参数是Object类型，可以是字符串，可以是数字，可以是new Object，但不能直接传字母
//用了泛型就固定了，所以有个疑问：用了泛型就固定了，那为啥不用类名啊（String int Animal Object)
//来建立数组啊
//推测是不是用了泛型（集合），可以调集合里的那些方法，从而达到方便的目的
//推测错误，解答：
// Test02相当于List，如果Test02中有它的方法，然后tt就可以调用了，然而
// 这些方法是int,String,中没有的（就相当于集合）
Test02 ff = new Test02();
ff.doSome(new Object());
//为上面的疑惑进行实验
Test02<String> tt = new Test02<>();
List<String> gg = new ArrayList<>();
//这样对比一下，Test02相当于List，如果Test02中有它的方法，然后tt就可以调用了，然而
//这些是int,String,中没有的
tt.doSome("wf");
tt.doSome("we");
tt.doSome("qw");
tt.doSome("ew");
//不是啊，这些泛型是自己定义的，没有实现集合的继承关系的
// Iterator<String> it = tt.
}
}
class Miao<E>{
public E get(){
return null;
}
}
package ForeachTest;
/*
* JDK5.0之后退出的新特性，增强for循环，也叫foreach*/
public class Test {
public static void main(String[] args) {
int[] a = {1,2,4,1,12,334,34,};
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
/* 语法
for (元素类型 变量名 : 数组或集合) {
System.out.println(变量名);
}*/
for(int data : a){
System.out.print(data + " ");
}
//缺点：没有下标，在需要使用下标的循环中，不建议使用foreach
}
}
package ForeachTest;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test02 {
public static void main(String[] args) {
List a = new ArrayList();
a.add(12);
a.add("sdg");
a.add("asf");
a.add(34);
Iterator it = a.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
for (int i = 0; i < a.size(); i++) {
System.out.println(a.get(i));
}
for(Object obj : a){
System.out.print(obj + " ");
}
}
}