Java基础语法实例(2)—

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

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

相关链接：

JAVA中文API文档

JAVA知识点文章

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

结束~

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