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
{
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;
}
}
day07
1. 构造方法
什么是构造方法？？？
上面的代码逻辑跟生活不符合比如（看下面代码）
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，因为方便调用。
day08
1. 继承
子类继承父类大家都是这么说的，但是呢？这么说了之后还是懵圈啊~~并不理解啊
边看代码边解释吧：往下看
我们先创建个人类，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
...
|
|
