大数据之路week01--day02我实在时被继承super这些东西搞的头疼，今天来好好整理如下。

这一周的第一天的内容是面向对象的封装，以及对方法的调用。实在时无法单独拿出来单说，就结合这一节一块儿说了。

我实在是被继承中的super用法给弄的有点晕，程序老是不能按照我想的那样，不是说结果，而是实现过程，很明显复杂，后来进行推敲后，原来是个人理解出了差错。

先把前对象的的内容补补

在开始面向对象以前，咱们先来了解一下，Java的内存分配：（在以前我也说过，只是简单的提到）

Java把内存划分为4个部分 1. 代码区 一、栈区 三、堆区 四、静态区域
一、栈区（stacksegment）—由编译器自动分配释放,存放函数的参数值，局部变量的值等，具体方法执行结束以后，系统自动释放JVM内存资源
二、堆区（heapsegment）—通常由程序员分配释放，存放由new建立的对象和数组，jvm不定时查看这个对象，若是没有引用指向这个对象就回收
三、静态区（datasegment）—存放全局变量，静态变量和字符串常量，不释放
四、代码区（codesegment）—存放程序中方法的二进制代码，并且是多个对象共享一个代码空间区域

 

 

 

1、面向对象的三大特性：

　　封装、继承、多态。

一、封装

　　在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。

 

　　封装能够被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

 

　　要访问该类的代码和数据，必须经过严格的接口控制。

 

　　封装最主要的功能在于咱们能修改本身的实现代码，而不用修改那些调用咱们代码的程序片断。

 

　　适当的封装可让程式码更容易理解与维护，也增强了程式码的安全性。

1.1 封装的优势

• 1. 良好的封装可以减小耦合。

• 2. 类内部的结构能够自由修改。

• 3. 能够对成员变量进行更精确的控制。

• 4. 隐藏信息，实现细节。

1.2 实现Java封装的步骤

　1. 修改属性的可见性来限制对属性的访问（通常限制为private），例如：

　　  1 public class Person { private String name; private int age; } 

　　这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其余类都访问不了，如此就对信息进行了隐藏。

　2. 对每一个值属性提供对外的公共方法访问，也就是建立一对赋取值方法，用于对私有属性的访问，例如：

    

 1 public class Person{
 2  private String name;
 3  private int age; ​ 
 4 public int getAge(){
 5  return age;
 6 } ​ 
 7 public String getName(){
 8  return name; 
 9 } ​ 
10 public void setAge(int age){ 
11 this.age = age; 
12 } ​ 
13 public void setName(String name){ 
14 this.name = name; 
15 } 
16 }

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

1.3 this

this指针：（实际上，每一个非static方法中都隐含这一个this指针指向当前正在调用该方法的对象。）

1.4 static

static(静态的):

一、若是在一个属性的前面加上static ，那么这个属性就不是某一个对象的了，而是N个对象共用的了。在静态区存放，不释放。
static属性变量是属于类自己的，没有对象咱们仍然能够经过类名的方式进行访问该类内部的static属性。(static方法也能够)
注意：类能够直接调用，实例化出来的对象固然也能够进行调用。
理解：模型均可以，模型造的对象固然能够。

二、加上static的确是属于类自己的，可是要去访问它必须控制符是非私有的，若是控制符是私有的，则不能直接经过类名进行访问！！
理解：private static void a(){} private static int i;都是不能够直接经过类名进行访问，由于前面的控制符是private

三、非静态的方法能够访问静态成员，反之不能够。非私有的静态成员才能经过类名直接调用。
理解：静态的方法和静态的变量属于类自己，不是静态的方法必须经过对象进行调用，在实例化对象的同时也包含了静态的方法，固然能够。反之不能够。

下面，咱们用实例来理解static的做用：

实例1：实现一个类只容许有一个对象

 1 package com.wyh.Iterator;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月10日 上午10:18:07
 6 * 该程序证实:
 7 *   实现一个类只容许实例化一个对象
 8 */
 9 
10 class A2{
11     public int i = 2;
12     
13     private static A2 aa = new A2();
14     
15     private A2() {
16         
17     }
18     
19     public static A2 getA2() {
20         return aa;
21     }
22 }
23 
24 public class static03 {
25     public static void main(String[] args) {
26         A2 aa1 = A2.getA2();
27         A2 aa2 = A2.getA2();
28         aa1.i = 90;
29         System.out.println("aa2:"+aa2.i);//说明aa1和aa2是同一个对象
30         
31         if(aa1 == aa2) {
32             System.out.println("说明aa1和aa2是同一个对象");
33         }else {
34             System.out.println("说明aa1和aa2不是同一个对象");
35         }
36     }
37 
38 }

实例2：一个类不管实例化多少对象，其中一个变量只有一个。

 1  package com.wyh.Iterator;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月10日 上午9:32:57
 6 */
 7 public class static01 {
 8     private static int i;
 9     
10     public static01() {
11         i = i+1;
12     }
13     
14 //    static void add() {
15 //        i = i+1;
16 //    }
17 //    
18     
19     public static void main(String[] args) {
20         static01 s1 = new static01();
21 //        s1.add();
22         static01 s2 = new static01();
23 //        s2.add();
24         static01 s3 = new static01();
25 //        s3.add();
26         static01 s4 = new static01();
27 //        s4.add();
28         static01 s5 = new static01();
29 //        s5.add();
30         System.out.println("总共实例化了:"+i+"个对象");
31     }
32 
33 }

二、继承

什么是继承？在咱们的后面实际操做过程当中，不少时候，许多的对象拥有一些重复的操做，并且，这些对象都是同一种现实属性的派生。例如，咱们的男人和女人都是人类，那么人类就是男人，女人的父类，男人和女人继承了人类这个父类，称之为子类。

    一、继承，咱们用extends来表示：好比刚刚说的男人继承了人类这个类   public class woman extends human{}

    二、提到了继承父类，那继承过来的成员变量和一些方法，咱们怎么去使用呢？

2.1 super

　　终于讲到使人头疼的super了。

　　

 

重写：当子类须要父类的功能，而子类有新的内容，能够重写父类中的方法。在实际开发过程当中，随着代码量的逐渐增长，维护成了一个很大的问题，若是须要对某个方法进行修改，其自己代码以及其子类代码都会受到影响，而重写则很好的解决了这个问题。方法重写又称为方法覆盖、方法复写。

方法重写特色

在子类和父类中，出现了方法声明相同的状况
子类的方法声明要和父类相同
子类要重写的方法，方法的权限修饰符不能比父类更低（public 、protected  、default  、private 权限依次增长）
父类私有的方法，子类不能进行方法重写

方法重写和方法重载的区别：

方法重写：子类和父类中方法相同，两个类之间的关系，函数的返回值类型、函数名、参数列表都同样
方法重载：指在同一个类中，多个方法名相同，他们的参数列表不一样（个数不一样，数据类型不一样）

 

重写方法时要注意的地方：

1.方法重写时， 方法名与形参列表必须一致。
2.方法重写时，子类的权限修饰符必需要大于或者等于父类的权限修饰符。
3.方法重写时，子类的返回值类型必需要小于或者 等于父类的返回值类型。
4.方法重写时， 子类抛出的异常类型要小于或者等于父类抛出的异常类型。 Exception(最坏) RuntimeException(小坏)

 

　　先来看一个例子：

A类：（父类）

 1 package day02;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月12日 下午2:52:37
 6 */
 7 public class A {
 8     
 9     protected String name;
10     protected String health;
11     protected String love;
12     
13     
14     
15     public String getName() {
16         return name;
17     }
18     public String setName(String name) {
19         return this.name = name;
20     }
21     public String getHealth() {
22         return health;
23     }
24     public void setHealth(String health) {
25         this.health = health;
26     }
27     public String getLove() {
28         return love;
29     }
30     public void setLove(String love) {
31         this.love = love;
32     }
33     public A() {
34         super();
35         // TODO Auto-generated constructor stub
36     }
37     public void eat()
38     {
39         System.out.println("吃饭！");
40     }
41     public void work()
42     {
43         System.out.println("工做！");
44     }
45     public void sleep()
46     {
47         System.out.println("睡觉！");
48     }
49 
50 }

 

B类：（子类，继承了A父类）

 1 package day02;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月12日 下午2:53:02
 6 */
 7 public class B extends A{
 8     private int i;
 9     
10     
11     
12     public int getI() {
13         return i;
14     }
15 
16     public void setI(int i) {
17         this.i = i;
18     }
19 
20     public B(){
21         super();
22     }
23     
24     public void work()
25     {
26         super.work();       //使用super关键字调用父类方法
27         System.out.println("学习！");
28         System.out.println("娱乐！");
29 
30     }
31 }

D类：（子类，继承了A父类）

 1 package day02;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月12日 下午2:53:02
 6 */
 7 public class D extends A{
 8     private int i;
 9     
10     
11     
12     public int getI() {
13         return i;
14     }
15 
16     public void setI(int i) {
17         this.i = i;
18     }
19 
20     public D(){
21         super();
22     }
23     
24     public void work()
25     {
26         super.work();       //使用super关键字调用父类方法
27         System.out.println("学习！");
28         System.out.println("娱乐！");
29 
30     }
31 }

C类：（测试类，主类）

 1 package day02;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月12日 下午2:53:34
 6 */
 7 public class C {
 8     public static void main(String[] args) {
 9         /*A aa = new A();
10         aa.work();*/
11         
12         A bb = new B();
13         A dd = new D();
14         bb.name = bb.setName("456");
15         dd.name = dd.setName("123");
16         System.out.println(bb.name);
17         System.out.println(dd.name);
18         System.out.println(bb.getName());
19         bb.work();
20     }
21 
22 }

解说：

　　咱们能够看到，我如今父类，A类种定义了name;health;love;三个成员变量，为了能够实现继承，咱们不将它定义成私有变量，同时父类里面拥有三个方法，吃饭，睡觉，工做。

　　 B类和D类继承了A类，同时咱们将work方法进行了重写，添加了本身特有的方法。

而后，咱们来看看结果：

　　

 

 后来，咱们发现，经过super，能够调用父类的方法，以及能够经过super调用父类的成员变量。这个例子很好的归纳，this指针，super的用法，重写的用法。

多态咱们后续进行补充。。。