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