标签：抽象 student == i+1 引用 遵从 iterator gen last
来到广州实习的第二天，广州好潮湿，这就是我的感觉，手表里面都开始产生了水雾，这就尴尬了、、、每天不断的雨。好吧，尽管我很喜欢这里的树，但是我以后应该也不会再来广州了，其实也说不准。想起了《谁动了我的奶酪》里面的一句话：生活并不会遵从某个人的愿望发展。改变随时有可能降临,但积极地面对改变却会让你发现更好的奶酪,真的是塞翁失马,焉知非福。 我会依旧乐观地面对！
相关链接：
Java面向对象，继承，多态，接口，abstract类，instanceof运算符，集合类（Map，Set，List）
实例一：继承
ExtendsDemo.java
1 package com.lanou.two; 2 3 //创建一个Person类作为父类，定义一些相同的属性和行为 4 //创建两个子类Employ，Student 5 class Person5{ 6 String name; 7 private String gender ="girl"; 8 public String getGender() { 9 return gender; 10 } 11 public void setGender(String gender) { 12 this.gender = gender; 13 } 14 15 int age; 16 public void eat() { 17 System.out.println("eating..."); 18 } 19 public void sleep() { 20 System.out.println("sleeping..."); 21 } 22 public void sayHello() { 23 System.out.println("Hi..."); 24 } 25 26 public Person5(String name,int age) { 27 this.name=name; 28 this.age =age; 29 } 30 } 31 32 class Employe extends Person5 { 33 34 public Employe(String name, int age) { 35 super(name, age); 36 // TODO Auto-generated constructor stub 37 } 38 public void sayHello() { 39 System.out.println("Hi... worker"); 40 } 41 public void work() { 42 System.out.println("working..."); 43 } 44 } 45 46 class Student extends Person5{ 47 48 public Student(String name, int age) { 49 super(name, age); 50 // TODO Auto-generated constructor stub 51 } 52 public void sayHello() { 53 System.out.println("Hi...Student"); 54 } 55 public void study() { 56 System.out.println("studying..."); 57 } 58 } 59 /* 60 * private 修饰的不能被继承访问，子类可以用set,get方法进行访问,在父类里面生成相应属性的set,get方法 61 * 62 * 继承：提高代码的复用性，避免重复代码出现 63 * 64 * Java不支持多继承，多继承需要使用接口 65 * 66 * */ 67 68 public class ExtendsDemo { 69 public static void main(String[] args) { 70 Student student = new Student("Alice",22); 71 System.out.println(student.getGender()); 72 student.sayHello(); 73 student.study(); 74 75 } 76 77 }
实例二：Abstract
1 package com.lanou.two; 2 3 public class AbstractDemo { 4 5 public static void main(String[] args) { 6 Wolf wolf = new Wolf(); 7 wolf.bark(); 8 wolf.sleep(); 9 } 10 } 11 12 abstract class Quanke{ 13 /** 14 * 没有方法体的方法叫做抽象方法 15 * 抽象方法所在类也必须抽象，即抽象类 16 * 关键字abstract, 不能和 private,static,final一起定义 17 * 抽象类不能被实例化，必须由子类覆盖所有抽象方法才能实例化 18 * 在抽象类中可以定义非抽象方法 19 */ 20 abstract public void bark(); 21 public void sleep() { 22 System.out.println("sleeping..."); 23 } 24 } 25 26 /** 27 *当一个类继承自一个抽象类的时候，必须要覆盖这个抽象类的所有抽象方法 28 *否则这个这个子类还是抽象类 29 */ 30 class Wolf extends Quanke{ 31 32 @Override 33 public void bark() { 34 System.out.println("ao...wu..."); 35 } 36 37 }
练习：
1 package com.lanou.two; 2 3 public class Test1 { 4 Programmer p = new Programmer(); 5 } 6 7 8 abstract class person1{ 9 public String name; 10 public int ID; 11 public int money; 12 13 abstract public void work(); 14 15 } 16 17 class Programmer extends person1{ 18 19 public void work() { 20 System.out.println("programming"); 21 } 22 23 } 24 25 class Manager extends person1{ 26 public int bonus; 27 28 @Override 29 public void work() { 30 System.out.println("management"); 31 32 } 33 34 }
实例三：多态
1 package com.lanou.two; 2 3 public class PolymorphsDemo { 4 public static void main(String[] args) { 5 Dog dog = new Dog(); 6 Cat cat = new Cat(); 7 // dog.eat(); 8 // cat.eat(); 9 runEat(dog); 10 runEat(cat); 11 //在向下转型之前进行类型判断防止抛出异常 12 if(cat instanceof Animal){ 13 System.out.println("C is Animal~"); 14 } 15 } 16 static public void runEat(Animal an){ 17 an.eat(); 18 } 19 } 20 21 /* 22 * 不同的对象执行会有不同的结果 23 * 父类的引用指向子类对象，会自动向上转型，转型后该对象将丢失特有的内容 24 * 在向下转型过程中，如果类型不匹配，会抛出异常 25 */ 26 27 abstract class Animal{ 28 abstract public void eat(); 29 //将父类作为返回值类型时，可返回 30 public Animal get() { 31 return new Cat(); 32 }; 33 } 34 35 class Dog extends Animal{ 36 37 @Override 38 public void eat() { 39 System.out.println("Dogs like eating bones"); 40 } 41 42 } 43 class Cat extends Animal{ 44 45 @Override 46 public void eat() { 47 System.out.println("Cats like eating fish"); 48 } 49 50 }
实例四：
1 package com.lanou.two; 2 3 public class InterfaceDemo { 4 //想使用接口，又不想创建新的类，使用匿名内部类创建时实现方法即可 5 myInterface in = new ImplememtDemo(){ 6 public void Hello() { 7 System.out.println("Hi~匿名内部类"); 8 9 } 10 }; 11 } 12 /** 13 * 定义接口使用interface关键字 14 * 接口也不能实例化，需要子类实现所有方法才能实例化 15 * 只能定义常量和抽象方法，可以看作一种特殊的抽象类 16 * 在接口中定义的成员变量会自动加上public static final 17 * 接口中不允许存在非抽象方法，编译器会自动加上abstract 18 * 接口是可以继承的，可以多继承 19 */ 20 21 interface myInterface{ 22 public static final int a =100; 23 public void Hello(); 24 } 25 26 interface Inter2{ 27 public void Hello(); 28 } 29 30 class ImplememtDemo implements myInterface,Inter2{ 31 32 @Override 33 public void Hello() { 34 System.out.println("Hi~"); 35 } 36 }
练习：
1 package com.lanou.two; 2 3 public class Test2 { 4 5 /** 6 * @param args 7 */ 8 public static void main(String[] args) { 9 PC pc = new PC(); 10 pc.start(); 11 pc.stop(); 12 } 13 } 14 class PC{ 15 public void start() { 16 System.out.println("Computer start~"); 17 } 18 public void stop() { 19 System.out.println("Computer stop~"); 20 } 21 private void addDevice(USB u) { 22 u.open(); 23 u.close(); 24 } 25 } 26 27 interface USB { 28 public void open(); 29 public void close(); 30 } 31 32 class Mouse implements USB{ 33 34 @Override 35 public void open() { 36 System.out.println("The Mouse has opened."); 37 } 38 39 @Override 40 public void close() { 41 System.out.println("The Mouse has closed."); 42 } 43 44 }
实例五：
1 package com.lanou.two; 2 3 import java.util.ArrayList; 4 import java.util.Iterator; 5 import java.util.ListIterator; 6 7 public class ArrayListDemo { 8 9 /** 10 * 在拿到一个框架时，先去看看顶层中的内容 11 * 然后再去找底层的类来使用 12 * 13 * ArrayList的特点： 14 * 1.可以存储重复对象； 15 * 2.存储顺序和取出顺序一致； 16 * 3.长度可变；元素在内存中地址连续，导致查询很快；添加和删除的速度就会变慢 17 */ 18 @SuppressWarnings({ "unchecked", "rawtypes" }) 19 public static void main(String[] args) { 20 ArrayList arrayList = new ArrayList(); 21 //添加数据 基础数据类型在存储到集合中时会自动包装 22 int i; 23 Integer a=50; 24 arrayList.add(1); 25 arrayList.add(5); 26 arrayList.add(0, 100); 27 arrayList.add(1, a); 28 System.out.println(arrayList); 29 30 for(i=0;i<arrayList.size();i++){ 31 System.out.print(arrayList.subList(i, i+1)+" "); 32 } 33 System.out.println("First"); 34 //获取对象，可以使用get 35 for(i=0;i<arrayList.size();i++){ 36 System.out.print(arrayList.get(i)+" "); 37 } 38 System.out.println("Second"); 39 //获取对象,迭代器 每一个集合类都提供了获取迭代器 40 Iterator<Integer> it = arrayList.iterator(); 41 while (it.hasNext()) { 42 //在迭代中不能对集合进行修改 43 Integer t = it.next(); 44 System.out.print(t+" "); 45 } 46 System.out.println("Third"); 47 48 //如果需要在迭代过程中修改集合，需要用ListIterator 49 ListIterator<Integer> listit =arrayList.listIterator(); 50 while (listit.hasNext()) { 51 listit.add(33); 52 listit.next(); 53 } 54 System.out.println(arrayList); 55 56 //删除元素，0表示索引 57 arrayList.remove(0); 58 //100已经被封装，不能当作值删除 59 //arrayList.remove(100); 60 arrayList.remove(new Integer(50)); 61 System.out.println(arrayList); 62 63 //删除集合的所有元素，取差集 arraylist.removeAll(); 64 //取交集retainAll(); 65 66 } 67 }
个人感觉，学习集合类的话，可以对API进行熟悉了解，包括Java源代码这些。网址：JavaAPI
实例六：
1 package com.lanou.two; 2 3 import java.util.Iterator; 4 import java.util.LinkedList; 5 6 public class LinkedListDemo { 7 8 /** 9 * linkedList的特点： 10 * 1.可以存储重复的元素 11 * 2.存储顺序与取出顺序一致 12 * 3.可以存储空值 13 * 4.可以实现队列和堆栈 14 */ 15 public static void main(String[] args) { 16 LinkedList<String> linked = new LinkedList<String>(); 17 //添加元素 18 linked.add("Alice"); 19 linked.add(0,"Bob"); 20 linked.addFirst("cindy"); 21 linked.addLast("Grace"); 22 linked.offer("Jim"); 23 linked.offerFirst("Kim"); 24 linked.offer("Mary"); 25 26 System.out.println(linked); 27 28 Iterator<String> it = linked.iterator(); 29 while (it.hasNext()) { 30 //在迭代中不能对集合进行修改 31 String t = it.next(); 32 System.out.print(t+" "); 33 } 34 System.out.println(); 35 //删除元素 36 linked.remove(); 37 System.out.println(linked); 38 39 } 40 41 }
实例七：
1 package com.lanou.two; 2 3 import java.util.HashSet; 4 import java.util.Iterator; 5 6 public class HashSetDemo { 7 8 /** 9 * HashSet中的元素存储顺序和取出顺序可能不同，可能相同 10 * 查找，添加速度快 11 * 不能存储重复元素 12 * 当我们存储自定义对象时需要重写hashCode()和equals() 13 */ 14 public static void main(String[] args) { 15 HashSet<String> set = new HashSet<String>(); 16 set.add("AAAA"); 17 set.add("BBBB"); 18 set.add("CCCC"); 19 set.add("DDDD"); 20 21 Iterator<String> it = set.iterator(); 22 while (it.hasNext()) { 23 //在迭代中不能对集合进行修改 24 String t = it.next(); 25 System.out.print(t+" "); 26 } 27 28 } 29 30 }
练习：
1 package com.lanou.two; 2 3 import java.util.HashSet; 4 import java.util.Set; 5 6 public class Test3 { 7 8 /** 9 * @param args 10 */ 11 public static void main(String[] args) { 12 HashSet<People> set = new HashSet<People>(); 13 set.add(new People("Alice",22)); 14 set.add(new People("Alice",21)); 15 set.add(new People("Bob",22)); 16 System.out.println(set); 17 } 18 } 19 20 class People{ 21 String name; 22 int age; 23 24 @Override 25 public int hashCode() { 26 final int prime = 31; 27 int result = 1; 28 result = prime * result + age; 29 result = prime * result + ((name == null) ? 0 : name.hashCode()); 30 return result; 31 } 32 @Override 33 public boolean equals(Object obj) { 34 if (this == obj) 35 return true; 36 if (obj == null) 37 return false; 38 if (getClass() != obj.getClass()) 39 return false; 40 People other = (People) obj; 41 if (age != other.age) 42 return false; 43 if (name == null) { 44 if (other.name != null) 45 return false; 46 } else if (!name.equals(other.name)) 47 return false; 48 return true; 49 } 50 public People(String name,int age) { 51 super(); 52 this.name=name; 53 this.age=age; 54 } 55 @Override 56 public String toString() { 57 return "name:"+name+" age:"+age; 58 } 59 60 }
Tip：
当发现项目中有什么小错误，然后自己又察觉不出来的话，可以试下如下操作：
找到Project
结束~
明天开始项目的部署，继续努力~
标签：抽象 student == i+1 引用 遵从 iterator gen last
原文地址：http://www.cnblogs.com/zxcjj/p/7056016.html
