Java基础语法实例(2)——实习第二天

来到广州实习的第二天，广州好潮湿，这就是我的感觉，手表里面都开始产生了水雾，这就尴尬了、、、每天不断的雨。好吧，尽管我很喜欢这里的树，但是我以后应该也不会再来广州了，其实也说不准。想起了《谁动了我的奶酪》里面的一句话：生活并不会遵从某个人的愿望发展。改变随时有可能降临,但积极地面对改变却会让你发现更好的奶酪,真的是塞翁失马,焉知非福。 我会依旧乐观地面对！

相关链接：

JAVA中文API文档

JAVA知识点文章

 

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

 结束~

明天开始项目的部署，继续努力~