Java 面向对象基础 以及进阶知识 总结

Controlling Access to Members of a Class.

private: 仅仅可以在自己的类中使用

public: 哪里都可以用

protected: package-private 就是在同一个包下都可以使用，并且在别的包下继承他的子类中也可以使用。

no-modifier: package-private 只能在同一个包下使用( 对于同一包下 与protected 相同)。在别的包不行。

Overriding 重写和 Overloadding 重载

Overriding: 是用于子类与父类之间，除了函数体变化外其他的全部不变。且子类overriding的access controller 不能高于父类。

Overloadding: 是对于同类中，方法之间。 参数列表必须改变，返回类型可以改变或不改变。

Polymorphism 多态

大体上可以理解为

ParentClass obj = new ChindClass(); //A

ChildClass obj2 = new ChildClass(); //B

ChildClass obj3 = new ParentClass(); //C 错误例子

交给大家一个窍门，为什么会有这个设定。对于A, 我们声明了ParentClass那么我们就相当于在内存中给ParentClass中的变量和方法分别开了房间, 当我们new 的时候，就比如实际来了人 来了ChildClass, 因为ChildClass中的变量 和 方法数量一定是 大于或者等于ParentClass中的，所以我们之前开的房间都住满了，那么酒店很开心，订了多少住了多少。 对于C中， 我们预定了ChildClass中的变量和方法的房间，但是实际来的人是ParentClass，数量明显小于ChildParent中的人，那么订的住不满，酒店就很生气，给你报了错。

overriding and overloadding 是多态的重要体现形式。

Abstract Class 抽象类

abstract class 能含有或者不含有 abstract函数, abstract 函数必须用 abstract 关键字来修饰。

只要一个类含有一个abstract 函数那么就必须对这个类使用abstract 关键字来修饰。相同的在它的子类中。

Interface 接口

接口就是比abstract 类更极端的东西。它里面的所有方法必须都是 abstract 方法, 不能含有instance field, 对于所有的constant 比如int等必须是 static 和 final的。

implement 它的必须是 实现所有的abstract方法就和abstract 一样了。

Java Advanced Knowledge

Generic Class

很简单通过下面的例子很明显。比如arraylist或者hashmap中都是generic的。

1. 
   
2. package Generic;
4. //generic class
5. public class GenericMethodTest< A,Z > {
6. //generic variable
7. public A a;
9. public void setA( A a) {
10. this.a = a;
11. }
13. //generic methods
14. public A getA () {
15. return this.a;
16. }
17. public void printArray ( Z[] inArray) {
18. for ( Z temp : inArray) {
19. System.out.println(temp);
20. }
21. }
23. public static < B > void printArray_2 (B[] inArray) {
24. for (B temp : inArray) {
25. System.out.println(temp);
26. }
27. }
29. }

1. 
   
2. package Implement;
4. import Generic.GenericMethodTest;
6. public class a{
8. public static void main (String[] args) {
9. GenericMethodTest<Integer,String> gm = new GenericMethodTest<Integer,String>() ;
10. gm.setA(10);
11. String[] ss = {"aaa", "bbb", "ccc"};
12. Double [] bb = {1.0, 2.0, 3.0};
13. gm.printArray(ss);
14. gm.printArray_2(ss);
15. gm.printArray_2(bb);
16. }
18. }

Serialize 串行化

串行化简单来讲就是转变存在的 实例化的对象 转化成 byte数组的 一种技术或者过程。它有很多好处，请看。

http://stackoverflow.com/questions/2232759/what-is-the-purpose-of-serialization-in-java

简单的串行化，可以根据下面的代码来学习下。

注意： 对于一些我们不想串行化的 区域 我们可以使用关键字 transient 来修饰。

1. 
   
2. package Serialize;
4. import java.io.*;
6. public class Employee implements Serializable{
7. public String name;
8. public String address;
9. public transient int SSN;
10. public int number;
12. public void mailCheck (){
13. System.out.println("Mailing a check to "+ name + " " + address);
14. }
16. }

1. 
   
2. package Serialize;
4. import java.io.*;
6. public class SerializeDemo {
8. public static void main (String[] args) {
9. Employee e = new Employee();
10. e.name = "Reyan df";
11. e.address = "New York, ManhaThan";
12. e.SSN = 1234433224;
13. e.number = 101;
15. try {
16. FileOutputStream fileOut =
17. new FileOutputStream ("/Users/huazhe/Desktop/demo.ser");
18. ObjectOutputStream out = new ObjectOutputStream (fileOut);
19. out.writeObject(e);
20. out.close();
21. fileOut.close();
22. System.out.println("Serialization done...");
23. } catch (IOException i){
24. System.out.println(i);
25. }
27. }
28. }
30. package Serialize;
32. import java.io.*;
34. public class DeserializaDemo {
35. public static void main (String[] args) {
36. Employee e = null;
38. try {
39. FileInputStream fileIn = new FileInputStream("/Users/huazhe/Desktop/demo.ser");
40. ObjectInputStream in = new ObjectInputStream (fileIn);
41. e = (Employee) in.readObject();
42. in.close();
43. fileIn.close();
45. } catch (IOException i) {
46. System.out.println(i);
47. } catch (ClassNotFoundException c) {
48. System.out.println(c);
49. }
50. System.out.println("Name: " + e.name);
51. System.out.println("Address: " + e.address);
52. System.out.println("SSN: " + e.SSN);
53. System.out.println("Number: " + e.number);
56. }
58. }

multithreading 多线程

用的不多，用的时候再看。谢谢。

有问题欢迎指出。