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

结束~

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