Java基础编程白话讲解分享

day01

1.   javac  相当于一个翻译官 将你的.java文件翻译成虚拟机能读懂的内容

2.   java  相当于一个工具,虚拟机使用此工具去做文件里面要求做的事儿.

大白话:

比如你是外企员工,你的老板是外国人,安排你做事儿给你的文档你看不懂,然后找一个翻译官给你翻译,翻译过后,你根据文件内容去做事儿.其中虚拟机就是你自己,翻译官就是javac命令,java就是你完成工作的工具,然后你就输出了helloworld 做完了文档中的事儿.

day02

1.    常量:太阳的个数,一年有多少个季节,一天多少小时(这些永远不会改变的量,我们就称之为常量)

2.    变量:车的时速(同样是车的速度,在高速或者市区速度区间是不一样的),在程序运行中,会随各种情况改变的量.

3.    例子:

           intspeed;

           speed= 60;

           System.out.println(" 市区限速,最高只能跑" +speed);

           speed= 120;

           System.out.println(" 我们在高速上,可以随便跑"+ speed);

4.   8 大基本数据类型:(相当于各个不同容量的容器,有的装水,有的饮料)  

      bytebeizi;// 可以装1升水的

      shortwan;// 可以装2升水的碗

      int  shuigang;// 可以装4升水的水缸

      longshuichi;// 可以装8升水的池子

      floatyouhu;// 可以装4升油的壶

      doubleyutong;// 可以装8升油的桶

      charjiuping;// 可以装2升啤酒的瓶子

      boolean    yesOrno;//true false 真相只有一个 要么真 要么假 是非黑白

思考:    如果有5升水 你应该用什么来装?

例子:    beizi = (byte) 128;

           System.out.println(beizi);// 这里面 打印出-128 为什么了?因为你的杯子不够大水满则溢

5.    数据类型转换:  小杯子中的水倒入大杯子,水不会溢出 (叫隐式转换)

                          把大杯子中的水倒入大杯子中,虽然可以将小杯子装满,但是装不下的会溢出(水满则溢,月盈则亏) (叫强制转换)

6.    算术运算符:      (其实就是数学中的一些加减 乘 除 大于 小于 取余数 )

+         -          *          /          >         <         >=      <=      %

特殊的 ++ --

++我们在java中叫做自增

--我们在java中叫做自减

++在前,先做自增操作再执行后面的代码,++在后,先执行后面的代码再自增

-- 在前,先做自减操作再执行后面的代码,--在后,先执行后面的代码再自减

7.    赋值:我们给杯子里倒水 给油桶装油

8.    比较运算符:     相互比较    有大于,小于,等于,大于等于,小于等于

     判断完之后 结果始终是boolean (true,false)

9.    逻辑运算符 或 与 非   (死扣概念) 注意 短路区别

day03

1.    三目运算符

boolean ?  值1 : 值2

布尔值为true,取值1,布尔值为false,取值2

白话:   

明天下雨吗? 带伞: 不带伞
有xx吗? 男: 女     (可以引导到if elseif else)
解释：什么是三目？那么我要先问什么是两目？简单举个例子1+2=3；这就是两目，就是两个模块，那么一目呢？就是i++;这个就是单目，就是只有一个模块，我们观察上面的语法，有三个模块，所以我们称为三目。
再看他的语法结构，第一个模块：布尔。这里不管你直接给个布尔变量也好，还是给比较表达式，只要结果是布尔就可以。然后就？这就是问的意思，问第一个模块是真还是假，真的话怎么办？选择值1，假呢？选择值二。这就是三目的原理。合成一句话就是我问第一个模块是对还是错，对就选择值一，错就值二。
然后强调一点，三目的运算符的返回值是看你的值1：值2,这两个值是什么数据类型就返回什么数据类型。

2.    程序运行流程:

顺序结构:   从上往下

If结构:

if(boolean){

}

白话:    相当于一个门 你拿到钥匙key 如果钥匙是对的,给你开门,执行{}中的代码钥匙不对,{}中不执行,If语句就像一个门,小括号就是钥匙孔,这个门只有true才能打开.

例子:    if(是男人嘛?)

{

男厕所

} else{

女厕所

}          //if你是男的 去男厕所 否则去女厕所

If else if...else结构

if (boolean){}

else if(boolean){}

else if(boolean){}

...

else{}

白话: 有多个箱子,其中一个有宝贝,你只有一把钥匙,然后你得一个个去试,只有一个箱子能被打开,然后你得到宝贝.

3.   if 嵌套

if(大门钥匙){

      进了大门,看到房门

      if(房门钥匙){

           进了房门,拿到了房间里的钱

      }else{

           进不去房门,什么也拿不到

      }

}

例子:    boolean bigDoorKey = true; // 大门钥匙

           booleanbedRoomKey = true; //  房门钥匙

           if(bigDoorKey) {

                 System.out.println(" 我进了大门了,哈哈哈,看到一个房门");

                 if(bedRoomKey) {

                      System.out.println(" 我进了房门,拿到一个娃娃");

                 }else {

                      System.out.println(" 房门钥匙不对,什么都不给你看");

                 }

           }

           

4.    switch语句

    江苏卫视非诚勿扰节目

  int heartBitGirlNum=1;// 上台选心动女生编号

   switch (heartBitGirlNum){

         case 1:

                System.out.println("您的女朋女是如花");

               break;

             case 2:

                System.out.println("您的女朋女是石榴姐");

                break;     

             case 3:

                System.out.println("您的女朋女是马蓉");

                 break;  

             case 4:

                System.out.println("您的女朋女是梅超风");

                 break;

             case 5:

                System.out.println("您的女朋女是容嬷嬷");  

                break;

             case 6:

                System.out.println("您的女朋女是凤姐");

                 break;

             case 7:

                System.out.println("您的女朋女是灭绝师太");

                break;

             case 8:

                System.out.println("您的女朋女是东施");

                 break;

                 case 9:

                System.out.println("您的心动女生是韩红");

                 break;  

             case 10:

                System.out.println("您的女朋女是芙蓉姐");

                break;               

             case 11:

                System.out.println("您的女朋女是金星");

                  break;

           case 12:

                System.out.println("您的女朋女是芙姐");

             break;

              default:      

                System.out.println("您的女朋女是凤姐");

              break;           

        }

5.   for 循环

            for (int i = 0; i < 100; i++) {

                 System.out.println(" 女朋友的名字");

           }

// 首先 初始化条件，再判断条件 再第一次循环，在条件控制语句，也就是++，然后再条件判断，在条件控制，以此类推。

day04

1.   while 循环

当我活着的时候,我每天都要吃饭,呼吸,睡觉

咯儿屁了 就break;

while(){

}// 小括号里写条件判断表达式，或者boolean变量 重点是结果是boolean就可以

例子1:

           intage = 0; //  你出生了

           while(age <= 100) {

                 System.out.println(" 我过" + age + "岁生日了");

                 age++;

                 if(age == 100) {

                      System.out.println(" 嗝儿屁了");

                 }

           }

例子2:

           booleanisLive = true; //  你出生了

           while(isLive) {

                 for(int i = 0; i <= 100; i++) {

                      if(i == 100) {  //100 岁的时候,嗝儿屁了

                            break;

                      }

                      System.out.println(" 我过" + i + "岁生日了");

                 }

           }

2.   do while() 循环

do {

//首先执行这里面的代码

}     while() {//再判断小括号里面是是否是true 是true就继续执行

}

特点:循环必定执行一次,然后再判断条件是否满足

3.   continue   break   return

continue 是结束本次的循环（就是这个关键字后面的代码不执行了），继续下一次

break, 结束循环

return, 结束这个方法,方法弹栈

4.    方法

解释:    做一件事的方式和方法

格式:

public static void  把妹(){

}

白话:撩妹三十六式 每个人把妹的方式都不一样
例子:    public static boolean 把妹(){
                 if(高富帅){
                      System.out.println("妹子跟我坐跑车走了...");
                      return true;
                 }else if(矮矬穷){
                      System.out.println("妹子说要坐在宝马里哭");
                      return false;
                 }
           }

5.    方法重载:

死扣概念：方法名一样，参数列表必须不一样,跟返回值无关

例子:    public static int 把妹(){

                 return 把了几个妹

           }     

           publicstatic String  把妹(鲜花,跑车){

                 return 妹子的长相

           }

           publicstatic boolean  把妹(卫龙,棒棒糖,酸奶){

                 return 把到没有

           }

day05

1.    数组

白话:就相当于一个酒窖 里面有很多瓶子

int[] pingzi = new int[10] //相当于有10个空瓶子瓶子

pingzi[0] = 啤酒;   //动态初始化,往瓶子里面灌各种各样的酒

pingzi[1] = 红酒;

pingzi[3] = 威士忌;

...

2.    引用类型和基本数据类型传参的区别

记住:    引用类型当参数传递的时候,传递的是它本身

基本数据类型当参数传递的时候,传递的是它的副本

day06

1.    类和对象

类：分类的意思（日常生活中我们先找到具有相同属性的事物把其分为一类）

对象：每个个体，具备相同属性的对象属于同一类（比如：在坐的属于人类，我们吃的属于食物类，我们喝的属于饮品类）

类和对象的关系：类是对象的模板，对象就是按照类的模型来创建

例子:   

/**

*  人类

*  人类需要具备各种属性

*  那么我们创建的人类对象所有人都会有这么几个属性:

*  人种,肤色,性别

*  证明人类是每个人的模板

*

*/

public   class  Human {

  String  race ;   // 人种

  String  color ;  // 肤色

  String sex;   //性别

}

public   static   void  main(String[] args) {

      // 创建了三个人,每个人都有这些属性,所以类是对象的模板,所有对象都是按照类中的属性创建的

     Human xiaoming =  new  Human();   // 一个人(对象出生了)

     xiaoming. color  =  " 黄" ;        // 每个人(对象)具备相同的属性 属性内容不一样(属性值)

     xiaoming. sex  =  " 男" ;

     xiaoming. race  =  " 中国 人" ;

     

     Human jack =  new  Human();     // 一个人(对象出生了)

     jack. color  =  " 白" ;         // 每个人(对象)具备相同的属性 属性内容不一样(属性值)

     jack. sex  =  " 男" ;

     jack. race  =  " 欧洲人" ;

     

     Human sam =  new  Human();      // 一个人(对象出生了)

     sam. color  =  " 黑" ;          // 每个人(对象)具备相同的属性 属性内容不一样(属性值)

     sam. sex  =  " 男" ;

     sam. race  =  " 美国人" ;

  }

2.    封装

白话:    辛辛苦苦存了100万,直接放在家里茶几上,安全吗?看看代码:

public  class Home {

      int   money  = 100;  // 辛辛苦苦攒了一百万

}

//你家熊孩子回来了,看见了一百万

public  static  void main(String[] args) {

     HomeXiongHaiZi =  new  Home();  //  你家熊孩子回家了

     System. out .println( " 熊孩子一回家,看见"  + XiongHaiZi. money  + " 万" );  //  看到一百万

}

// 熊孩子一看 , 我靠 , 一百万 , 拿出去做个大保健 , 撩个妹 , 总之要花点儿去

public   static   void  main(String[] args) {

     HomeXiongHaiZi =  new  Home();  //  你家熊孩子回家了

     System. out .println( " 熊孩子一回家,看见"  + XiongHaiZi. money  + " 万" );  //  看到一百万

     System. out .println( " 拿点儿花花,撩妹,大保健..." );  //  激动的不行,拿钱出去花

     XiongHaiZi. money  = 55;  //  花了45万,100万剩下55万(重新赋值)

     System. out .println( " 只剩下"  + XiongHaiZi. money  +  " 万了" );

  }

// 辛辛苦苦好几年 , 一天回到解放前

这时候我们想 , 这怎么办 , 钱放茶几不安全啊 , 怎么办 , 那么伟大的 java 给我们提供了封装 private( 相当于保险箱 , 没有密码我不给你 ), 现在我把钱藏起来了 , 一般人我不给他知道 , 看看代码

public   static   void  main(String[] args) {

     HomeXiongHaiZi =  new  Home();  //  你家熊孩子回家了

     System. out .println( " 熊孩子一回家,看见"  + XiongHaiZi. money   + " 万" );  //  找不到钱了,哈哈哈

  }   The field Home.money is not visible

熊孩子回家了 , 还想再花点儿 , 找不到钱了 .

封装特性：就是在其他类中无法直接访问你私有的属性（安全）

关于get和set

嗯你钱是藏起来了，但是问题来了，万一你老婆要用找不到怎么办 ？？？？

public   static   void  main(String[] args) {

     HomeLaoPo =  new  Home();  //  你家老婆要买包

     System. out .println( " 熊孩子一回家,看见"  + LaoPo. money   + " 万" );  //  找不到钱,等着你回来,今晚睡沙发

}

你老婆也没看到钱，等你回来,要么跪CPU,要么今天晚上睡沙发

所以不管你藏在哪你的告诉你老婆啊，那么在java代码中private,是封装，（藏钱的关键字）

那么还有public，暴露自己，在其他的类中可以访问到（也就是告诉你老婆钱在哪），不多说，撸代码！！！

你把钱藏的位置和保险箱的密码也告诉你老婆了

public   class  Home {

   private   int   money  = 100;  //  辛辛苦苦攒了一百万,用保险箱private保险箱藏起来

   // public 修饰对外提供访问的公有方法,让其他类可以直接访问,相当于只要有密码,保险箱就可以打开

   public   int  zaiZhe() {  //  告诉你老婆钱在这里,你老婆现在能看到钱在保险箱里

      return   money ;  //  私有的属性,在本类中可以直接拿来用,有了密码我就可以找到钱了.

  }

   public   void  huaQian( int  money) {  // 花钱的方法,小括号里面表示让你老婆自己来决定花多少

     System. out .println( " 密码输入正确,拿着花吧!!!" );

      this . money  = money;  //this 代表谁来花钱,然后重新赋值,将剩下的钱放回到保险箱

  }

}

现在告诉了你老婆钱放在那儿,也告诉了密码,你老婆就可以直接拿着钱去消费了

public   static   void  main(String[] args) {

     HomeLaoPo =  new  Home();  //  你家老婆回来了

     System. out .println( " 找到了"  + LaoPo.zaiZhe() +  " 万" );  //  通过你告诉的位置和密码,你老婆拿到钱了

     LaoPo.huaQian(90); //  买了个迪奥的包,香奈儿的香水,一套纪梵希的衣服

     System. out .println( " 花钱就是开心,还剩"  + LaoPo.zaiZhe() + " 万" );

  }

控制台输出结果:

找到了100万

密码输入正确,拿着花吧!!!

花钱就是开心,还剩90万

以上代码就是get set方法的由来 只是我把方法名字换了，结合生活，为什么要有这两个方法，get就相当于zaiZhe（）这个方法，经过同意才能找到（public修饰的get方法，调用就等同于同意被访问），set就相当于huaQian()这个方法（public修饰的get方法，调用就等同于同意被访问赋值），

综合上面代码所述所以构建完整代码一定要有构造，要有封装，要有get,和set方法,我们来看看一个类的完整代码:

/**

*  人类 人类需要具备各种属性 那么我们创建的人类对象所有人都会有这么几个属性: 人种,肤色,性别 证明人类是每个人的模板

*

*/

public   class  Human {

  String race ;  //  人种

  String color ;  //  肤色

  String sex ;  //  性别

   public  Human() {

  }

   //  这个就是构造方法,在创建人的时候,就给他把颜色涂好了,其他的属性也都设置好了....

   public  Human(String race, String color, String sex) {

      this . race  = race;

      this . color  = color;

      this . sex  = sex;

  }

   public  String getRace() {

      return   race ;

  }

   public   void  setRace(String race) {

      this . race  = race;

  }

   public  String getColor() {

      return   color ;

  }

   public   void  setColor(String color) {

      this . color  = color;

  }

   public  String getSex() {

      return   sex ;

  }

   public   void  setSex(String sex) {

      this . sex  = sex;

  }

}

day07

1.    构造方法

什么是构造方法？？？

上面的代码逻辑跟生活不符合比如（看下面代码）

Human xiaoming =  new Human();  //一个人(对象出生了)

这句话的意思是,天天滚出去的小明出生了

xiaoming.color = "黄";       //每个人(对象)具备相同的属性 属性内容不一样(属性值)

     xiaoming. sex  =  " 男" ;

     xiaoming.race = "中国人";

这三句话是说,小明出生了,然后我们给他涂了个黄颜色,装了个xxx,在中国出生所以是中国人,这符合逻辑吗?

所以说,我们应该在小明出生之前,这些东西就应该确定了,伟大的Java早就想到了这点,给我们提供了一个叫做构造方法的语法,看如下代码:

public   class  Human {

  String race ;   // 人种

  String color ;  // 肤色

  String sex ;    // 性别

   // 这个就是构造方法,在创建人的时候,就给他把颜色涂好了,其他的属性也都设置好了....

   public  Human(String race, String color, String sex) {

      this . race  = race;

      this . color  = color;

      this . sex  = sex;

  }

}

现在我们再按以前的方式,让小明出生,看还能不能行:

public   static   void  main(String[] args) {

     Humanxiaoming =  new  Human() ;   // 现在来创建一个小明,结果是不是不行了,提示我们要设置属性

  }

那好,我们现在来利用构造方法来创建三个人

/**

   *  创建了三个不同的人,每个人都是这些属性,所以类是对象的模板

   *  一个人(对象)出生了:在创建对象的时候调用构造方法

   *  为属性赋值:确定人种,涂上颜色,重要的是确定了性别

   */

   public   static   void  main(String[] args) {

     Humanxiaoming =  new  Human( " 中国人" , " 黄" , " 男" );  // 调用构造方法创建小明

     Humanjack =  new  Human( " 欧洲人" , " 白" , " 男" );    // 又一个健康的人出生了

     Humansam =  new  Human( " 美国人" , " 黑" , " 男" );     // 又一个健康的人出生了

System. out.println("我是" + xiaoming.race + ",我的皮肤是" + xiaoming.color +",我的性别是" + xiaoming.sex);

     System. out.println("我是" + jack.race + ",我的皮肤是" + jack.color + ",我的性别是"

+jack.sex);

     System. out.println("我是" + sam.race + ",我的皮肤是" + sam.color + ",我的性别是" + sam.sex);

  }

2.    Static关键字

静态关键字：static

先说概念：静态就是被所有类共享的......概念说了还是一脸的蒙蔽

那么直接撸代码吧：往下看

public   class  ClassRoom {

   int   water  = 100;   // 教室里的饮水机有100L的水

}

然后同学去接水

public   static   void  main(String[] args) {

     ClassRoomstu1 =  new  ClassRoom();  // 学生1

     stu1. water  = 99;  // 学生接了一杯水,还剩99L

     ClassRoomstu2 =  new  ClassRoom();  // 学生2

      // 按理说,学生2去接水的时候,饮水机里只有99L水了吧

     System. out .println( " 还剩"  + stu2. water  +  " 升水" );

  }

请看运行结果:
还剩100升水

？？？？不科学啊？怎么还剩100升水呢，我们推理一下，真相永远只有一个！！！

那就是因为这两个学员（对象）用的根本不是一个饮水机（属性没有共享）！！

那么我们要做的就是把饮水机让每个学员用的是一样的（属性共享）

Java中为我们提供了这样一个神奇的关键字 static，接着看代码：

public   class  ClassRoom {

   // 饮水机里有100升水,直接用static修饰

   static   int   water  = 100;  //  教室里的饮水机有100L的水

}

在看看第二个同学接水后的结果:

还剩99升水

通过上述案例我们知道static的应用，属性需要被每个对象的所共同拥有的时候就要用static修饰.

3.    代码块

代码块：静态代码块：随着类加载，在类中，方法外

  局部代码块：方法内

  构造代码块：在类中方法外

上述三种代码块，不管怎么样他们都是代码块，所以我们首先搞懂 什么是代码块！！

代码块：被大括号括起来的都是代码块，就这么简单！！

代码块做些什么事情？之前方法是不调用不执行，那么代码快呢？

静态代码块：随着类的加载就执行      语法:static {里面你想写的代码就可以了}

局部代码块：随着方法的调用而执行    语法：方法里面写个{里面你想写的代码就可以了}就O了

构造代码块：在创建对象的时候调用   语法：在类中方法外写个{里面你想写的代码就可以了}就可以了

上面这些个代码块的的区别：

位置的不同：

静态代码块：随着类加载，在类中，方法外

局部代码块：方法内

构造代码块：在类中方法外

语法不同：这里就不写了都在上面的语法中。

执行顺序不同看下面代码就知道了：

这是以上的几个代码块的写法，还加了一个构造方法，更清晰的看到先后顺序

public   class  Test {

   public   void  show() {

      // 我是局部代码块

     System. out .println( " 我是局部代码块" );

  }

  {

      //  构造代码块

     System. out .println( " 我是构造代码块" );

  }

   public  Test() {

      //  构造方法

     System. out .println( " 我是构造方法" );

  }

   static  {

      //  静态代码块

     System. out .println( " 我是静态代码块" );

  }

   public   static   void  main(String[] args) {

     Testt =  new  Test();

     t.show();

  }

}

运行结果:

我是静态代码块

我是构造代码块

我是构造方法

我是局部代码块

4.    静态方法

特点:

静态的方法直接类名.调用

在静态方法中是没有this关键字的

静态方法只能访问静态的成员变量和静态的成员方法

之前普通方法都是通过对象调用的，那么为什么静态方法能直接类名调用呢？因为静态修饰的属性或者方法随着类的加载而加载，所以不需要有对象，类名就可以直接用。

看个例子:

public   class  Test {

   // 将show方法定义为静态的

   static   void  show() {

     System. out .println( " 我是静态的" );

  }

   public   static   void  main(String[] args) {

     Test.show();

  }

}

运行结果:

我是静态的

我们一般专门写个的工具类，里面都是些常用方法用static，因为方便调用。

day08

1.    继承

子类继承父类大家都是这么说的，但是呢？这么说了之后还是懵圈啊~~并不理解啊

边看代码边解释吧：往下看

我们先创建个人类，get,set方法是有的 只是没有截图出来

public   class  Human {

  String race ;  //  人种

  String color ;  //  肤色

  String sex ;  //  性别

   public  Human() {

  }

   //  这个就是构造方法,在创建人的时候,就给他把颜色涂好了,其他的属性也都设置好了....

   public  Human(String race, String color, String sex) {

      this . race  = race;

      this . color  = color;

      this . sex  = sex;

  }

}

好那么，现在问题来了，人类是个大范围啊，世界上这么多国家，比如说中国人，美国人，英国人，等等...........................那么我们是不是要把这些各个国家的人分类呢？

好吧把这些类创建出来，

// 中国人

class  Chinese{

}

// 美国人

class  American{

}

// 英国人

class  English{

}

上面说到了，这些类，都具备什么特性呢？很明显，他们都是人！！！

那么这些各个国家的人类需要具备什么特性呢？不用说肯定是跟上面的最开始Human类具备相同的属性

此时的你们：“嗯明白！！（特么废话啊，都是人类肯定跟Human具备相同属性啊）”

好既然你们都知道要跟人类具备相同的属性，那么我们该怎么做呢？

难道是这样么？??看下面的代码  （get,set,没写）

// 中国人

class  Chinese{

   private  String  race ;  //  人种

   private  String  color ;  //  肤色

   private  String  sex ;  //  性别

}

// 美国人

class  American{

   private  String  race ;  //  人种

   private  String  color ;  //  肤色

   private  String  sex ;  //  性别

}

// 英国人

class  English{

   private  String  race ;  //  人种

   private  String  color ;  //  肤色

   private  String  sex ;  //  性别

}

现在只有3个国家，我们这样直接复制就可以，那么我要是把所有的国家都写上呢？（还要把get，set加上）那么就算是复制也还是很累啊！！！

所以此时伟大的java就为我们提供了继承,extends不多说撸代码：

下面的都用类extends 关键字来继承Human 类

//  中国人用extends继承Human

class  Chinese  extends  Human {

}

//  美国人用extends继承Human

class  American  extends  Human {

}

//  英国人用extends继承Human

class  English  extends  Human {

}

那么使用extends有什么用呢？就可以不用写那么多重复的属性了么？？

看代码:

public   static   void  main(String[] args) {

     Chinesec =  new  Chinese();

     c.setColor( " 黄" );

     c.setRace( " 中国人" );

     c.setSex( " 男" );

     System. out .println( " 我的肤色是"  + c.getColor() +  ", 我的种族是"  + c.getRace()

         + ", 我的性别是"  + c.getSex());

     Americana =  new  American();

     a.setColor( " 黑" );

     a.setRace( " 美国人" );

     a.setSex( " 女" );

     System. out .println( " 我的肤色是"  + a.getColor() +  ", 我的种族是"  + a.getRace()

         + ", 我的性别是"  + a.getSex());

     Englishe =  new  English();

     e.setColor( " 白" );

     e.setRace( " 英国人" );

     e.setSex( " 男" );

     System. out .println( " 我的肤色是"  + e.getColor() +  ", 我的种族是"  + e.getRace()

         +  ", 我的性别是"  + e.getSex());

  }

是不是很神奇，上面的三个类里面明明什么都没写，但是却神奇的可以用Human类的，get,set方法，这里有个概念就引伸出来，

子类继承父类，可以直接调用父类的公有的方法，和公有的属性。

其实继承不单纯的是子类继承父类， 其实是一个大类，分多个子类，这些个子类都具备该大类的公有的属性和方法。

为什么强调是公有呢？看代码！！

private Stringrace; // 人种

   private  String color ;  //  肤色

   private String sex; // 性别

以上这些属性是私有的吧，我们子类直接用用试试

怎么用？肯定是new 子类对象啊然后调用属性啊

public   static   void  main(String[] args) {

     Chinesec =  new  Chinese();

     c. race   =  " 中国人" ;

  }

看运行结果:

The field Human.race is not visible

直接报错......

所以说就算你爹有100万 ，他不愿意给你还是白搭

爸爸类：私有的方法（意思是不给儿子~~~）

public   class  Father {

   private   void  money(){

     System. out .println( " 爸爸有100万" );

  }

}

很明显Son类继承了Father类（是上面的儿子）

class  Son  extends  Father{

}

然后.............

public   static   void  main(String[] args) {

     Sons =  new  Son();  // 儿子来了

     s. money ();   // 儿子要用钱,结果发现用不了

  }

运行报错:

The method money() from the typeFather is not visible

就是这个意思，就算你爹有他也不愿意给你用啊，为啥因为是他私有的,

另外,子类可以有爹,有爷爷,这就是类的多层继承.

2.    多态

多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，就是同一种事物表现出的多种形态.编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话.

举个例子:你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。

上代码:

// 员工类

public   class  Employee {

   s tatic   {

     System. out .println( " 老板来了" );

  }

   public   void  work() {  //  员工的工作方法,看到老板来了,就要开始工作

     System. out .println( " 老板来了,让我们开始工作了" );

  }

}

// 销售员工继承员工类,销售的工作 是卖车

class  xiaoShou  extends  Employee {

   public   void  work() {

     System. out .println( " 销售 今天卖了10辆车" );

  }

}

// 程序猿继承员工类,程序猿会撸代码

class  chengXuYuan  extends  Employee {

   public   void  work() {

     System. out .println( " 程序猿一边撸代码,一边掉头发, 还要 当备胎" );

  }

}

现在我们来测试一下：

public   static   void  main(String[] args) {

     Employeexs =  new  xiaoShou();

     xs.work();

     Employeeyuan =  new  chengXuYuan();

     yuan.work();

  }

运行结果：

老板来了

销售今天卖了10辆车

程序猿一边撸代码,一边掉头发,还要当备胎

从这段代码可以清晰的看到,虽然都是员工(父类),但是实际创建的对象不同(销售和程序员),这就是父类引用指向子类对象,由于子类重写了父类的work方法,所以销售和程序员干的活儿不一样,类似的我还可以举一个例子:大哥叫小弟去收保护费,小弟A过去直接拿着搬砖棒子给人一顿打,进了医院,乖乖的交了保护费,小弟B叫了200收下,在大厅一坐,对方也吓傻了,请他的小弟吃了大排档,也交了保护费,小弟C一个人去,跟对方头头喝茶聊天唠嗑扯皮,对方被逼疯了,也交了保护费...得到同样的命令,三个人有各自的解决办法,这就是多态:复用相同接口,实现不同操作.

看代码:

// 古惑仔接口

interface  GuHuoZai {

   public   abstract   void  shouBoHuFei();

}

// 山鸡实现了古惑仔接口 ( 当了古惑仔 ) , 重写收保护费方法

class  ShanJi  implements  GuHuoZai{

   @Override

   public   void  shouBoHuFei() {

     System. out .println( " 山鸡叫了200人,吓得对方请吃饭,加大保健,收到了保护费" );

  }

}

// 陈浩南实现古惑仔接口 ( 当了古惑仔 ) , 重写收保护费方法

class  ChenHaoNan  implements  GuHuoZai{

   @Override

   public   void  shouBoHuFei() {

     System. out .println( " 陈浩南一个人去跟对面老大喝茶,因为陈浩南的人格魅力,收到了保护费" );

  }

}

// 大天二实现古惑仔接口 ( 当了古惑仔 ) , 重写收保护费方法

class  DaTianEr  implements  GuHuoZai{

   @Override

   public   void  shouBoHuFei() {

     System. out .println( " 大天二拿着搬砖和棒子,把对面打的头破血流,收到了保护费" );

  }

}

测试一下:

public   static   void  main(String[] args) {

System. out.println("大哥蒋天生缺钱,要收保护费!");

     ChenHaoNanc =  new  ChenHaoNan();  // 陈浩南出现了

     c.shouBoHuFei();  // 陈浩南收保护费

     ShanJis =  new  ShanJi();   // 山鸡出现了

     s.shouBoHuFei();  // 山鸡收保护费  

     DaTianErd =  new  DaTianEr();  // 大天二出现了

     d.shouBoHuFei();  // 大天二收保护费

  }

运行结果:

大哥蒋天生缺钱,要收保护费!

陈浩南一个人去跟对面老大喝茶,因为陈浩南的人格魅力,收到了保护费

山鸡叫了200人,吓得对方请吃饭,加大保健,收到了保护费

大天二拿着搬砖和棒子,把对面打的头破血流,收到了保护费

以上就是多态的体现,另外要记住,多态的还有一个好处是,作为形式参数时,可以接受一切子类对象.

public   static   void  main(String[] args) {

     jiHe( new  ChenHaoNan( " 陈浩南" ));

     jiHe( new  DaTianEr( " 大天二" ));

  }

   //  古惑仔要打架,打电话叫人

   public   static   void  jiHe(GuHuoZai g) {

     System. out .println(g.getName() +  ", 马不停蹄的赶到!!!" );

  }

运行结果:

陈浩南,马不停蹄的赶到!!!

大天二,马不停蹄的赶到!!!

3.    多态&&抽象类

实现需求：一个公共厕所（容器，可以是数组或集合），5男五女，同时撒尿（打印：站着尿or蹲着尿） .

参考 ：

public abstractclass Human

{

  ...

  public abstract void goPee();

}

定义一个被称为 " 人类 " 的抽象基类 ." 去撒尿 " 这个方法是抽象的 , 因为对于整个人类来说没有一个统一的撒尿方法 . 只有当你具体地讨论这个人是男人还是女人的时候 ," 撒尿 " 这个方法才有具体的含义 . 与此同时 ," 人类 " 也是一个抽象的概念 - 不可能有一个既不是男人也不是女人的 " 人类 " 存在 . 当我们讨论一个人的时候 ,TA 要么是个男人 , 要么是个女人 .

public class Maleextends Human

{

...

    @Override

    public void goPee()

    {

        System.out.println("StandUp");

    }

}

public classFemale extends Human

{

...

    @Override

    public void goPee()

    {

        System.out.println("SitDown");

    }

}

现在我们有了更具体的关于男人和女人的类定义.他们都是人类的继承类,但是他们有不同的撒尿方法.

多态最完美的展现在于当我们试图让一屋子的人都去撒尿的时候:

public staticvoid main(String args)

{

    ArrayList<Human> group = newArrayList<Human>();

    group.add(new Male());

    group.add(new Female());

    //... add more...

    // tell the class to take a pee break

   for (Human person : group) person.goPee();

}

得到的结果是:

Stand Up

Sit Down

...