|
Java基础编程白话讲解
（本文稿由武汉校区就业部老师提供） day01 1. javac 相当于一个翻译官 将你的.java文件翻译成虚拟机能读懂的内容 2. java 相当于一个工具,虚拟机使用此工具去做文件里面要求做的事儿. 大白话: 比如你是外企员工,你的老板是外国人,安排你做事儿给你的文档你看不懂,然后找一个翻译官给你翻译,翻译过后,你根据文件内容去做事儿.其中虚拟机就是你自己,翻译官就是javac命令,java就是你完成工作的工具,然后你就输出了helloworld 做完了文档中的事儿.
day021. 常量:太阳的个数,一年有多少个季节,一天多少小时(这些永远不会改变的量,我们就称之为常量) 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. 逻辑运算符 或 与 非 (死扣概念) 注意 短路区别 day031. 三目运算符 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("女朋友的名字"); } //首先 初始化条件，再判断条件 再第一次循环，在条件控制语句，也就是++，然后再条件判断，在条件控制，以此类推。
day041. 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把到没有 } day051. 数组 白话:就相当于一个酒窖 里面有很多瓶子 int[] pingzi = new int[10] //相当于有10个空瓶子瓶子 pingzi[0] = 啤酒; //动态初始化,往瓶子里面灌各种各样的酒 pingzi[1] = 红酒; pingzi[3] = 威士忌; ... 2. 引用类型和基本数据类型传参的区别 记住: 引用类型当参数传递的时候,传递的是它本身 基本数据类型当参数传递的时候,传递的是它的副本
day061. 类和对象 类：分类的意思（日常生活中我们先找到具有相同属性的事物把其分为一类） 对象：每个个体，具备相同属性的对象属于同一类（比如：在坐的属于人类，我们吃的属于食物类，我们喝的属于饮品类） 类和对象的关系：类是对象的模板，对象就是按照类的模型来创建 例子: /** * 人类 * 人类需要具备各种属性 * 那么我们创建的人类对象所有人都会有这么几个属性: * 人种,肤色,性别 * 证明人类是每个人的模板 * */ 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 { Stringrace; // 人种 Stringcolor; // 肤色 Stringsex; // 性别 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; } } day071. 构造方法 什么是构造方法？？？ 上面的代码逻辑跟生活不符合比如（看下面代码） Human xiaoming = new Human(); //一个人(对象出生了) 这句话的意思是,天天滚出去的小明出生了 xiaoming.color = "黄"; //每个人(对象)具备相同的属性 属性内容不一样(属性值) xiaoming.sex = "男"; xiaoming.race = "中国人"; 这三句话是说,小明出生了,然后我们给他涂了个黄颜色,装了个xxx,在中国出生所以是中国人,这符合逻辑吗? 所以说,我们应该在小明出生之前,这些东西就应该确定了,伟大的Java早就想到了这点,给我们提供了一个叫做构造方法的语法,看如下代码: public class Human { Stringrace; //人种 Stringcolor; //肤色 Stringsex; //性别 //这个就是构造方法,在创建人的时候,就给他把颜色涂好了,其他的属性也都设置好了.... 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，因为方便调用。
day081. 继承 子类继承父类大家都是这么说的，但是呢？这么说了之后还是懵圈啊~~并不理解啊 边看代码边解释吧：往下看 我们先创建个人类，get,set方法是有的 只是没有截图出来 public class Human { Stringrace; // 人种 Stringcolor; // 肤色 Stringsex; // 性别 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 Stringcolor; // 肤色 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 { static { 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 .. | 
收藏
淘帖
踩
