初入社会的萌新Java选手-----总结Java基础知识1

写在前面的话，本人萌新java选手，写的什么不对的欢迎吐槽！

Java基础知识方面：

1.Java面向对象的三大特性，封装 继承 多态

封装：

先将事物抽象成一个类，再将对象的属性和方法隐藏起来，不允许外界直接访问。例如，用private修饰一些属性，并提供getter/setter方法，仅允许通过调用这些方法来实现对数据的调用   和更改。

为什么用封装：目的是增强数据的安全性，简化编程。

继承：

是指子类通过extends关键字继承父类的属性和方法。不包括被private修饰的属性和方法，且不包括构造方法，但是子类可以通过super()来调用父类的构造方法

java中类有三种：

1.class定义的类类只可以extends一个类或者一个抽象类（必须将抽象类中的方法全部）但是可以extends多个接口

2.abstract class定义的抽象类，其中可以有抽象方法

3.接口只能extends一个接口

为什么用继承：目的是提高代码的重用性。子类继承了父类的属性和方法后，还可以通过重写来提高代码的利用率。

多态：

一是编译时实现多态，二是运行时实现多态

方法的重载 方法的重写

完整的方法构造=修饰符(public)+关键字(final)(可以非常量)+关键字(static)(可以非静态)+关键字(void)(可以有返回值类型定义)+方法名+(参数列表有无均可)+throw异常

重载是指在同一个类（自己+父类）中存在着两个方法名相同，参数却不相同。参数不同：参数个数不同，参数类型不同，参数列表顺序不同

封装和继承较为简单，懒得举例子。

多态的例子，网上有一个特别好的

类定义：

class A ...{  
         public String show(D obj)...{  
                return ("A and D");  
         }   
         public String show(A obj)...{  
                return ("A and A");  
         }   
}   
class B extends A...{  
         public String show(B obj)...{  
                return ("B and B");  
         }  
         public String show(A obj)...{  
                return ("B and A");  
         }   
}  
class C extends B...{}   
class D extends B...{}

问题：

	A a1 = new A();  
        A a2 = new B();  
        B b = new B();  
        C c = new C();   
        D d = new D();   
        System.out.println(a1.show(b));   ①  
        System.out.println(a1.show(c));   ②  
        System.out.println(a1.show(d));   ③  
        System.out.println(a2.show(b));   ④  
        System.out.println(a2.show(c));   ⑤  
        System.out.println(a2.show(d));   ⑥  
        System.out.println(b.show(b));    ⑦  
        System.out.println(b.show(c));    ⑧  
        System.out.println(b.show(d));    ⑨

答案：

①   A and A
②   A and A
③   A and D
④   B and A
⑤   B and A
⑥   A and D
⑦   B and B
⑧   B and B
⑨   A and D

关于上述题目，网上有大神讲解，在此我摘抄一句话

当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。这句话对多态进行了一个概括。其实在继承链中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

按照这个思路，我自己思考。

1.a1.show(b)，由于a1是调用自己，所以第一步A.show(b),A中并没有show(b)这个方法，到第二步super.show(b)，A没有父类，

到第三步A.show((super)b)，即B的父类就是A，A.show(a),A中有这个方法，输出A and A

2.a1.show(c)，根据1直接到第三步,变为a1.show(b)，结果与1相同

3.a1.show(d)，第一步直接调用A中的show(d)方法，输出A and D

4.a2.show(b)，首先看A a2 = new B();，这句表示定义了A类型的a2变量引用了B的对象。第一步就是在B中寻找show(b)方法，找到

后发现A中并没有该方法，到第二步直接过，到第三步B.show((super)b)，即B.show(a)，A中有show(a)方法，且该方法在B中重写，

输出B and A

5.a2.show(c)，第一步B.show(c)，第二步A.show(c)，第三步B.show(b)，同4

6.a2.show(d)，第一步A.show(d)，第二步A.show(d)，输出A and D

7.b.show(b)，输出B and B

8.b.show(c)，第一步B.show(c)，第二步A.show(c)，第三步B.show(b)，同7

8.b.show(d)，第一步B.show(d)，第二步A.show(d)，输出A and D