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

结束~

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

转载于:https://www.cnblogs.com/zxcjj/p/7056016.html

Java基础语法实例(2)——实习第二天相关推荐

java基础语法实例教程_Java 基础语法
一个 Java 程序可以认为是一系列对象的集合,而这些对象通过调用彼此的方法来协同工作面向对象中的一些概念下表列出了面向对象编程中的一些概念名词说明对象对象是类的一个实例,有状态和行为 ...
文字竖排列，Java基础语法实例之我的名字
有文本如下,需要竖排版: <现实>我的爱人(我的鸟的本名)</现实> <现实>冰龙战士纯属虚构.如论真相,看我没有.如果真是如此,大可洋河一跃.</现实> ...
使用java实现面向对象编程第二章_java面向对象编程——第二章 java基础语法
第二章 java基础语法 1.java关键字 abstract boolean break byte case catch char class const continue default do d ...
JavaSE入门0基础笔记第二章Java基础语法
JavaSE入门0基础笔记第二章Java基础语法 1.运算符 1.1算术运算符 1.1.1运算符和表达式 1.1.2 算术运算符 1.1.3字符的"+"操作 1.1.4 字符串中 ...
Java基础语法初学者了解
Java语言的特点简单的面向对象语言跨平台与解释执行可以做到一次编译,到处执行. (Java跨平台,Java虚拟机不跨平台) 在具体的机器运行环境中,由Java虚拟机对字节码进行解释执行.通过定 ...
JAVA学习（三）：Java基础语法（变量、常量、数据类型、运算符与数据类型转换）...
Java基础语法(变量.常量.数据类型.运算符与数据类型转换) 1.变量 Java中.用户能够通过指定数据类型和标识符来声明变量.其基本的语法为: DataType identifier; 或 Dat ...
Java基础语法知识你真的都会吗？
第一阶段 JAVA基础知识第二章 Java基础语法知识在我们开始讲解程序之前,命名规范是我们不得不提的一个话题,虽说命名本应该是自由的,但是仍然有一定的"潜规则",通过你对命名 ...
【JAVA学习】1、零基础入门Java 基础语法:概念、规则、格式
[JAVA学习]1.零基础入门Java 基础语法前言 JAVA开发环境选择 Java 基础概念 Java 标识符 Java修饰符基础代码模板框架命名规则基础规则后端开发规则代码格式前言 ...
01.Java基础语法
目录 01.Java基础语法一,环境搭建 1,Java体系与特点 2,Java跨平台原理 2.1 Java虚拟机(JVM) 2.2 垃圾回收器(GC) 2.3 Java SE组成概念图 2.4 JD ...
Java基础语法（一）——初识Java
文章目录一.Java语言概述 1.Java是什么 2.Java 的流行性 3.Java 的特性 (1) 简单性 (2)面向对象 (3) 分布式(微服务) (4) 健壮性 (5) 安全性 (6) 可移 ...

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

Java基础语法实例(2)——实习第二天相关推荐

最新文章

热门文章