java面向对象：三大特性：封装，继承，多态

———————————————————————————————————面向对象：三大特性：封装，继承，多态
———————————————————————————————————
1.什么是类？什么是对象？1)现实世界是由很多很多对象组成的基于对象抽出了类2)对象:真实存在的单个的个体类:类别/类型，代表一类个体3)类中包含:3.1)所有对象所共有的属性/特征----------成员变量3.2)所有对象所共有的行为---------------方法4)一个类可以创建多个对象同一类型所创建的对象，结构相同，数据不同5)类是对象的模板，对象是类的具体的实例
2.如何创建类？如何创建对象？如何访问成员？练习：
1)参与的角色:英雄机、小敌机、大敌机、小蜜蜂、子弹、天空
2)关系:英雄机发射子弹子弹射击敌人(小敌机、大敌机、小蜜蜂)英雄机与敌人(小敌机、大敌机、小蜜蜂)碰撞英雄机、小敌机、大敌机、小蜜蜂、子弹都是在天空上飞
3)英雄机发射子弹分单倍火力(火力值=0)和双倍火力(火力值>0)发射一次双倍火力，则火力值减2
4)子弹射击敌人:子弹消失、敌人爆破后消失打掉小敌机---------玩家得1分打掉大敌机---------玩家得3分打掉小蜜蜂---------英雄机得奖励(1条命或40火力值)
5)英雄机和敌人碰撞:敌人消失英雄机减1条命+英雄机清空火力值
6)当英雄机的命数为0时，游戏结束
7)项目四种状态:启动、运行、暂停、游戏结束设计射击游戏中的对象类:
1)先找对象:英雄机、小敌机、大敌机、小蜜蜂、子弹、天空
2)抽类:Hero、Airplane、BigAirplane、Bee、Bullet、Sky
3)设计类中的成员变量和方法
4)创建对象并测试————————————————————————————————
0.方法的签名: 方法名+参数列表
1.方法的重载(overload):1)发生在一个类中，方法名称相同，参数列表不同，方法体不同2)编译器在编译时根据方法的签名自动绑定调用的方法
2.构造方法:1)给成员变量赋初值2)与类同名，没有返回值类型3)在创建(new)对象时被自动调用4)若自己不写构造，则默认一个无参构造方法若自己写了构造，则不再默认提供了5)构造方法可以重载
3.this:指代当前对象，哪个对象调用方法指的就是哪个对象只能用在方法中，在方法中访问成员变量之前默认有个this.this的用法:1)this.成员变量名-------------访问成员变量2)this.方法名()---------------调用方法(一般不用)3)this()----------------------调用构造方法
4.null:空，没有指向任何对象若引用的值为null，则该引用不能再进行任何操作了若操作则发生NullPointerException空指针异常
5.引用类型之间画等号:1)指向同一个对象2)通过一个引用对数据的修改会影响另一个引用对数据的访问eg:房子钥匙基本类型之间画等号:1)赋值2)对一个变量的修改不会影响另一个变量eg:身份证复印件房子:对象房子钥匙:引用配一把钥匙:引用
内存管理:由JVM来管理的
1)堆:存储new出来的对象(包括成员变量)
2)栈:存储局部变量(包括方法的参数)
3)方法区:存储.class字节码文件(包括方法)练习：
给Hero、Airplane、BigAirplane、Bee、Bullet、Sky
分别添加构造方法
————————————————————————————
1.引用类型数组:1)Student[] stus = new Student[3]; //创建Student数组对象stus[0] = new Student("zhangsan",25,"LF"); //创建Student对象 并调用Studentstus[1] = new Student("lisi",26,"JMS");stus[2] = new Student("wangwu",28,"SD");System.out.println(stus[0].address);2)Student[] stus = new Student[]{new Student("zhangsan",25,"LF"),new Student("lisi",26,"JMS"),new Student("wangwu",28,"SD")};3)int[][] arr = new int[3][];-----------数组的数组arr[0] = new int[2];arr[1] = new int[3];arr[2] = new int[2];arr[1][0] = 100;4)int[][] arr = new int[3][4];----------数组的数组for(int i=0;i<arr.length;i++){for(int j=0;j<arr[i].length;j++){arr[i][j] = (int)(Math.random()*100);}}
例如：int[][] arr= new int[3][];//[3]是数组长度，[]代表每一个数组中都长度arr[0] = new int[2]; //第一个数组的长度为2arr[1] = new int[3]; //第二个数组都长度为3arr[2] = new int[4];arr[1][2] = 100;  // 给第2个数组中第3个元素赋值为100System.out.println(arr[1][2]);//输出第二个数组中第三个int[][] arr1 = new int[3][4]; //一共有3个组数，每个数组都长度为4for(int i = 0;i<arr1.length;i++){ //遍历数组arr1中都元素[3]for(int j = 0;j<arr1[i].length;j++){//遍历数组arr1中每一个数组的长度，arr1[i]arr1[i][j] = 250; // 给每一个数组赋值为250System.out.println(arr1[i][j]);
2.继承:1)作用:代码复用2)通过extends来实现继承3)超类/父类:所有派生类所共有的属性和行为派生类/子类:派生类所特有的属性的行为4)派生类继承超类后，派生类具有:派生类的+超类的5)一个超类可以有多个派生类一个派生类只能有一个超类-------单一继承6)继承具有传递性7)java规定:构造派生类之前必须先构造超类在派生类的构造方法中若没有调用超类的构造方法------则默认super()调用超类的无参构造方法在派生类的构造方法中若调用了超类的构造方法------则不再默认提供注意:super()调用超类构造必须位于派生类构造的第一行
3.super:指代当前对象的超类对象super的用法:1)super.成员变量名------------访问超类的成员变量2)super.方法名()--------------调用超类的方法-------明天讲3)super()---------------------调用超类的构造方法 例：class Person { //class创建类。//超类/父类String name;int age;String address;Person(String name, int age, String address) {  //构造方法this.name = name;this.age = age;this.address = address;}void sayHi() {  //方法System.out.println("你好，我叫" + name + "，今年" + age + "岁了，家住" +                    address);}}class Student extends Person {//派生类/子类  使用extends继承String stuId;Student(String name, int age, String address, String stuId) {super(name, age, address); // super调用超类的值this.stuId = stuId;     // this. 给stuld赋值。 super的超类已经赋过，所以不需要再赋值}}练习：
1.创建Person类，包含:1)成员变量:name,age,address2)构造方法:Person(3个参数){}3)方法:sayHi(){输出3个数据}
2.创建Student类，继承Person，包含:1)成员变量:stuId2)构造方法:Student(4个参数){}
3.创建Teacher类，继承Person，包含:1)成员变量:salary2)构造方法:Teacher(4个参数){}
4.创建Doctor类，继承Person，包含:1)成员变量:level2)构造方法:Doctor(4个参数){}
5.创建Test类，main中:1)创建Student数组ss，填充数据，遍历问好2)创建Teacher数组ts，填充数据，遍历问好3)创建Doctor数组ds，填充数据，遍历问好public class Test {public static void main(String[] args) {Person[] ps = new Person[3];ps[0] = new Student("张发阳",22,"宝兴", "1634");ps[1] = new Teacher("张三", 35, "浙江", 4122);ps[2] = new Doctor("李四", 46, "上海", "aaa");for(int i=0;i<ps.length;i++){ps[i].sayHi();      }}
}class Person {String name;int age;String address;Person(String name, int age, String address) {this.name = name;this.age = age;this.address = address;}void sayHi() {System.out.println("你好，我叫" + name + "，今年" + age + "岁了，家住" + address);}}
class Student extends Person {String stuId;Student(String name, int age, String address, String stuId) {super(name, age, address);this.stuId = stuId;}void sayHi() {System.out.println("我职业是教师，名叫" + name + "，" + "今年" + age + "岁了，家住" + address + "，学号为：" + stuId);}}
class Teacher extends Person {double salary;//工资Teacher(String name, int age, String address, double salary) {super(name, age, address);this.salary = salary;}void sayHi() {System.out.println("我职业是教师，名叫" + name + "，" + "今年" + age + "岁了，家住" + address + "，工资为：" + salary);}}
class Doctor extends Person {String level;Doctor(String name, int age, String address, String level) {super(name, age, address);this.level = level;}void sayHi() {System.out.println("我职业是医生，名叫" + name + "，" + "今年" + age + "岁了，家住" + address + "，任职：" + level);}
}

——————————————————————————————
2018/8/14
1.向上造型；
1）超类型的引用指向派生类的对象
2）能点出来什么，看引用的类型
例：

     public static void main(String[] args) {Aoo o1 = new Aoo();o1.a = 1;o1.show();//o1.b = 2; //编译错误，超类不能访问派生类的   Boo o2 = new Boo();o2.b = 1;o2.test();o2.a = 2;  //正确，派生类可以访问超类的o2.show();Aoo o3 = new Boo(); //向上造型o3.a = 1;o3.show();//o3.b = 2; //编译错误，能点出来什么，看引用的类型}}class Aoo{int a;void show() {}
}class Boo extends Aoo{int b;void test() {}
}2.方法的重写（Override）：重新写，覆盖1）发生在父子类中，方法名称相同，参数列表相同，方法体不同2）重写发放被调用时，看对象的类型//超类大，派生类小class Coo{void show() {}double test() {return 0.0;}Doo say() {return null;}Coo sayHi() {return null;}
}class Doo extends Coo{//int show() {return 1;} //编译错误，void时必须相等//int test() {return 0;} //编译错误，基本类型时必须相等//Coo say() {return null;} //编译错误，引用类型必须小于或等于Doo sayHi() {return null;} //正确}
3.重写与重载的区别：-----常见面试题1）重写:1.1)发生在父子类中，方法名称相同，参数列表相同，方法体不同1.2）遵循“运行期绑定”，看对象的类型来调用方法class Eoo{void show() { //方法System.out.println("超类show");}}class Foo extends Eoo{void show() { //方法重写System.out.println("派生类show");}}2）重载：2.1）发生在一个类中，方法名称相同，参数列表不同，方法体不同2.2）遵循“编译期绑定"，看参数/引用的类型来绑定方法class Aoo(){    //??方法重载void say(int age){System.out.println("你好，我今年"+age+"岁了");}void sa(String name){System.out.println("你好，我叫"+name);}void sa(String name,String address){"你好，我叫"+name+"，家住"+address);}
}//重写的演示public static void main(String[] args) {Goo goo = new Goo();Eoo o = new Foo();goo.test(o); //重载看参数/引用Eoo}
}class Goo{void test(Eoo o) {  System.out.println("超类型参数");o.show(); //重写看对象Foo}void test(Foo o) { System.out.println("派生类型参数");o.show();}}class Eoo{void show() { //方法System.out.println("超类show");}}class Foo extends Eoo{void show() { //方法重写System.out.println("派生类show");}}

练习：
/*1.创建Person类，包含：1）成员变量：name，age，address；2）构造方法：Person（3个参数){}3)方法：sayHi｛输出3个数据｝
2.创建Student类，继承Person，包含：1）成员变量：stuId2）构造方法：Student（4个参数）｛｝3）方法：重写sayHi（）｛输出4个数据｝
3.创建Teacher类，继承Person，包含：1）成员变量：salary2）构造方法：Teacher（4个参数）｛｝3）方法：重写sayHi（）｛输出4个数据｝
4.创建Doctor类，继承Person，包含：1）成员变量：lever2）构造方法：Doctor（4个参数）｛｝3）方法：重写sayHi（）｛输出4个数据｝
5.创建Test类，main中：创建Person数组ps，填充数据，遍历问好*/class Person{String name;int age;String address;Person(String name,int age,String address){this.name = name;this.age = age;this.address = address;   }void sayHi(){System.out.println("你好，我叫"+name+"，今年"+age+"岁了，家住"+address);}
}class Student extends Person{int stuId;Student(String name,int age,String address,int stuId){super(name,age,address);this.stuId = stuId;}void sayHi(){System.out.println("我的职业是学生，名为"+name+"，今年"+age+"岁了，家住"+address+"，学号是："+stuId);}
}class Teacher extends Person{double salary;Teacher(String name,int age,String address,double salary){super(name,age,address);this.salary = salary;}void sayHi(){System.out.println("我的职业是老师，名为"+name+"，今年"+age+"岁了，家住"+address+",工资为"+salary);}
}class    Doctor extends Person{String level;Doctor(String name,int age,String address,String level){super(name,age,address);this.level = level;}void sayHi(){System.out.println("我的职业是医生，名为"+name+"，今年"+age+"岁了，家住"+address+",任职："+level);}
}public class Test {public static void main(String[] args){  Person[] ps = new Person[4];ps[0] = new Person("张发阳",20,"宝兴兴兴");ps[1] = new Student("张发阳",25,"宝兴",1634);ps[2] = new Doctor("张发阳",35,"宝兴兴","副院长");ps[3] = new Teacher("张发阳",45,"宝兴兴兴",3000);      for(int i =0;i<ps.length;i++){ps[i].sayHi();}              }}

———————————————————————————————————

笔记:
1.package:1)作用:避免类名的冲突2)包名可以有层次结构3)类的全称: 包名.类名，同包中的类不能同名4)建议:包名所有字母都小写package a;class Aoo{  }  //全称a.Aoopackage b;class Aoo{   } //全称b.Aoo   不在一个包，所以不报错class Aoo{   } //错误，一个包里不可以重复类名 import:1)同包中的类可以直接访问，不同包中的类不能直接访问，想访问有如下两种方式:1.1)先import声明类再直接使用类------建议import oo.day05.Aoo; //声明类public class Coo {void show() {Aoo o = new Aoo();o.a = 1;}}1.2)类的全称------------------------太繁琐、不建议void show() {oo.day05.Aoo o = new oo.day05.Aoo();oo.day05.Aoo.a = 1;
2.访问控制修饰符:1)public:公开的，任何类2)private:私有的，本类3)protected:受保护的，本类、派生类、同包类4)默认的:什么也不写，本类、同包类说明:1)类的访问修饰符只能是public或默认的2)类中成员的访问修饰符如上四种都可以修饰符      本类             同一个包中的类       子类                其他类
public      可以访问            可以访问              可以访问        可以访问
private     可以访问          不能访问              不能访问         不能访问
protected 可以访问          可以访问              可以访问         不能访问
默认         可以访问          可以访问              可以访问        不能访问
例：public int a;    //任何类protected int b; //本类、派生类、同包类int c;           //本类、同包类private int d;   //本类void show() {a = 1;b = 2;c = 3;d = 4;}}//演示privateclass Boo{ void show() {Aoo o = new Aoo();o.a = 1;o.b = 2;o.c = 3;//o.d = 4;}}3.final:最终的、不可改变的----应用率低1)修饰变量:变量不能被改变//演示final修饰方法//演示final修饰变量class Eoo{ final int a = 5;final int b;Eoo(){b = 6;}void show() {final int c;//a = 55; //编译错误，final的变量不能被改变}}2)修饰方法:方法不能被重写class Foo{final void show() {}void test() {}}class Goo extends Foo{//void show() {} //编译错误，final修饰的方法不能被重写void test() {}}3)修饰类:类不能被继承//演示final修饰类final class Hoo{}//class Ioo extends Hoo{} //编译错误，final修饰的类不能被继承class Joo{}final class Koo extends Joo{}
4.static:静态的1)静态变量:1.1)由static修饰1.2)属于类的，存储在方法区中，只有一份1.3)常常通过类名点来访问1.4)何时用:所有对象所共享的数据(图片、音频、视频等)2)静态方法:2.1)由static修饰2.2)属于类的，存储在方法区中，只有一份2.3)常常通过类名点来访问2.4)静态方法没有隐式this传递，静态方法中不能直接访问实例成员2.5)何时用:方法的操作仅与参数相关而与对象无关3)静态块:3.1)属于类的，在类被加载期间自动执行，类只被加载一次，所以静态块只执行一次3.2)何时用:用于加载/初始化静态资源(图片、音频、视频等)//static的演示public static void main(String[] args) {Loo o1 = new Loo();o1.show();Loo o2 = new Loo();o2.show();System.out.println(Loo.b); //2，建议类名点来访问     Moo.test(); //类名点来访问        Noo o4 = new Noo();Noo o5 = new Noo();}}//演示静态块class Noo{ static {System.out.println("静态块");}Noo(){System.out.println("构造方法");}}//演示静态方法class Moo{ int a;static int b;void show() { //有thisSystem.out.println(this.a);System.out.println(Moo.b);}static void test() { //没有this//静态方法没有隐式this传递//没有this意味着没有对象//而实例变量a必须通过对象点来访问//结论:静态方法中不能直接访问实例成员//System.out.println(a); //编译错误System.out.println(Moo.b);}}//演示静态变量    class Loo{int a;static int b;Loo(){a++;b++;}void show() {System.out.println("a="+a+",b="+b);}}内存管理: （背）1)堆:new出来的对象(包括实例变量)2)栈:局部变量(包括方法的参数)3)方法区:.class字节码文件(包括方法、静态变量)例：成员变量:1)实例变量:没有static修饰，属于对象的，存储在堆中，有几个对象就有几份通过对象名点来访问2)静态变量:由static修饰，属于类的，存储在方法区中，只有一份通过类名点来访问
—————————————————————————————
笔记:
1.static final常量:1)必须声明同时初始化2)类名点来访问、不能被改变3)建议:常量名所有字母都大写，多个单词之前用_分隔4)编译器在编译时将常量直接替换为具体的值，效率高5)何时用:数据永远不变，并且经常使用
2.抽象方法:1)由abstract修饰2)只有方法的定义，没有具体的实现(连{}都没有)
3.抽象类:1)由abstract修饰2)包含抽象方法的类必须是抽象类不包含抽象方法的类也可以声明为抽象类------我乐意3)抽象类不能被实例化 ，但数组可以4)抽象类是需要被继承的，派生类:4.1)重写抽象类中的所有抽象方法-----建议4.2)也声明为抽象类-----------------一般不这样做5)抽象类的意义:5.1)封装共有的属性和行为--------------代码复用5.2)为所有派生类提供统一的类型--------向上造型5.3)可以包含抽象方法，为所有派生类提供统一的入口，派生类的具体实现不同，但入口是一致的设计规则:
1)将派生类共有的属性和行为，抽到超类中--------抽共性
2)派生类的行为都一样，设计为普通方法派生类的行为都不一样，设计为抽象方法
————————————————————————————————常见面试题：问： 内部类有独立.class吗?答： 有例：Mama$(发音：多嘞儿)baby.class   //Mama外部类，baby内部类
1.成员内部类：应用率不高1）类中套类，外面的称为Outer外部类，里面的成为Inner内部类Class Aoo{ //外部类Class Boo{//内部类｝｝使用方法：public static void main(String[] args) {Demo14 a = new Demo14();Foo f = a.new Foo();f.Doo();}2)内部类通常只服务于外部类，对外不具备可见性3)内部类对象通常是在外部类中创建的4)内部类中可以直接访问外部类的成员(包括私有的)内部类中有个隐式的引用指向了创建它的外部类对象eg: 外部类名.this
2.匿名内部类:1)若想创建一个类(派生类)的对象，并且对象只创建一个，此时该类不必命名，称为匿名内部类2)在jdk1.8以前，匿名内部类中若想访问外面的变量，该变量必须是final的功能实现过程:
1.先写行为/方法:1)若为某个对象所特有的行为，就将方法设计在对应的类中2)若为所有对象所共有的行为，就将方法设计在超类中
2.页面/窗口调用:1)若为定时触发的，则在定时器中调用2)若为事件触发的，则在侦听器中调用程序的运行结果与你所预期的结果不同:
1)打桩: System.out.println(数据);
2)Debug调试:
————————————————————————————————
笔记:
1.接口:1)是一种数据类型(引用类型)2)由interface定义3)只能包含常量和抽象方法4)接口不能被实例化5)接口是需要被实现/继承的，实现类/派生类:必须重写所有抽象方法6)一个类可以实现多个接口，用逗号分隔若又继承又实现时，应先继承后实现7)接口继承接口(可以继承多个接口)设计规则:1)将所有派生类所共有的属性和行为，抽到超类中-----抽共性2)派生类的行为都一样，设计为普通方法派生类的行为都不一样，设计为抽象方法3)将部分派生类所共有的行为，抽到接口中符合既是也是原则时，需使用接口接口是对继承单根性的扩展----------实现多继承
————————————————————————————
笔记:
1.多态:1)多态的意义:    //抽象方法一定是多态1.1)同一类型的引用指向不同的对象时，有不同的实现----行为的多态:cut()、run()、step()......1.2)同一个对象被造型为不同的类型时，有不同的功能----对象的多态:我、你、水......2)向上造型/自动类型转换:2.1)超类型的引用指向派生类的对象2.2)能造型成为的类型有: 超类+所实现的接口2.3)能点出来什么，看引用的类型3)强制类型转换，成功的条件只有如下两种:3.1)引用所指向的对象，就是该类型3.2)引用所指向的对象，实现了该接口或继承的该类4)强转时若不符合如上条件，则发生ClassCastException类型转换异常，建议在强转之前先通过instanceof(实例)来判断引用的对象是否是该类型基本类型之间强制类型转换，
---------一定正确，但有可能溢出或丢失精度
引用类型之间强制类型转换，
---------有可能会失败报错超类大，派生类小
自动:小类型到大类型
强制:大类型到小类型
—————————————————————————————————
正课:
1.内存管理:由JVM来管理的------了解1)堆:1.1)存储new出来的对象(包括实例变量)1.2)垃圾:没有任何引用指向的对象垃圾回收器(GC)不定时到内存中清扫垃圾，回收过程是透明的(看不到的)，不一定一发现垃圾就立刻回收，调用System.gc()可以建议JVM尽快调度GC来回收1.3)内存泄漏:不再使用的对象还没有被及时的回收建议:对象不再使用时应及时将引用设置为null1.4)实例变量的生命周期:创建对象时存储在堆中，对象被回收时一并被回收2)栈:2.1)存储正在调用的方法中的局部变量(包括方法参数)2.2)调用方法时会为该方法在栈中分配一块对应的栈帧，栈帧中存储局部变量(包括方法参数)当方法调用结束时，栈帧被清除，局部变量一并失效2.3)局部变量的生命周期:调用方法时存储在栈中，方法结束时与栈帧一并被清除3)方法区:3.1)存储.class字节码文件(包括方法、静态变量)3.2)方法只有一份，通过this来区分具体的调用对象+++++++++++++++++++++++++++++++++++++总结：
面向对象三大特征:
1.封装:1)类:封装的是对象的属性和行为2)方法:封装一段特定的是业务逻辑功能实现3)访问控制修饰符:封装的是具体的访问权限
2.继承:1)作用:代码复用2)超类:所有派生类所共有的属性和行为接口:部分派生类所共有的行为派生类:派生类所特有的属性和行为3)单一继承、多接口实现，传递性
3.多态:1)意义:1.1)行为的多态(所有抽象方法都是多态的)1.2)对象的多态(所有对象都是多态的)2)向上造型、强制类型转换、instanceof判断3)多态的表现形式:3.1)重写:根据对象的不同来表现多态3.2)重载:根据参数的不同来表现多态设计游戏思路（面向对象课程安排）：Shoot射击游戏第一天:1.创建了6个对象类，创建World类测试（理论:1.什么是类？什么是对象？2.如何创建类？如何创建对象？如何访问成员？项目:3.创建了6个对象类，并创建World类测试）Shoot射击游戏第二天:1.给6个对象类添加构造方法，并测试（理论:1.方法的重载2.构造方法3.this5.null和NullPointerException6.引用类型之间画等号项目:4.给6个对象类添加构造方法，并测试）Shoot射击游戏第三天:
1.设计小敌机数组、大敌机数组、小蜜蜂数组、子弹数组，并测试
2.设计超类FlyingObject，6个对象类继承
3.给FlyingObject类设计两个构造方法，6个对象类分别调用（ 理论:1.引用类型数组3.继承5.super项目:2.设计小敌机数组、大敌机数组、小蜜蜂数组、子弹数组，并测试4.设计FlyingObject超类，6个对象类继承6.给FlyingObject超类设计两个构造方法，6个对象类分别调用）Shoot射击游戏第四天:
1.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组，并测试
2.在6个对象中重写step()
3.画窗口（理论:1.向上造型3.方法的重写4.重写与重载的区别项目:2.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组，并测试5.在6个派生类中重写超类的step()方法6.画窗口）Shoot射击游戏第五天:
1.给类中成员添加访问控制修饰符
2.给6个对象设计图片属性（理论:1.package和import2.访问控制修饰符4.final5.static项目:3.给类中成员添加访问控制修饰符6.给6个对象设计图片属性）Shoot射击游戏第六天:
1.设计窗口的宽和高为常量，适当地方做修改
2.画对象:1)想画对象得获取对象的图片，每个对象都能获取图片，意味着获取图片行为为共有行为，设计为超类FlyingObject中，每个对象获取图片的行为都是不一样的，所以设计为抽象方法----在FlyingObject中设计抽象方法getImage()来获取对象的图片2)对象在获取图片时需要考虑对象在不同状态下获取不同的图片，所以要给对象设计状态，每个对象都有状态，所以将状态设计在超类中，而状态一般都是常量----在FlyingObject中设计三个常量，state变量表示当前状态在获取图片时需要先对对象的状态进行判断，每个对象都得判断，所以将判断状态行为设计在超类中，每个对象判断状态的方式都是一样的，所以设计为普通方法----在FlyingObject中设计isLife()、isDead()、isRemove()来判断对象的状态3)----重写FlyingObject中的抽象方法getImage():3.1)天空Sky，直接返回image即可3.2)子弹Bullet:3.2.1)若活着的，直接返回image即可3.2.2)若死了的，则删除3.3)英雄机Hero:3.3.3)若活着的，返回images[0]和images[1]的来回切换     3.4)小敌机Airplane:3.4.1)若活着的，直接返回images[0]3.4.1)若死了的，返回images[1]到images[4]的轮转，4后则删除3.5)大敌机Airplane:3.5.1)若活着的，直接返回images[0]3.5.1)若死了的，返回images[1]到images[4]的轮转，4后则删除3.6)小蜜蜂Airplane:3.6.1)若活着的，直接返回images[0]3.6.1)若死了的，返回images[1]到images[4]的轮转，4后则删除4)图片有了则可以开画了，每个对象都能画，意味着画为共有的行为，所以设计在超类中，每个对象画的方式都是一样的，所以设计为普通方法----在FlyingObject中设计paintObject()实现画对象5)天空Sky每次需要画两张图，所以重写超类的paintObject()----在Sky中重写paintObject()6)在World类中调用paintObject()实现往窗口上画对象----在World中重写paint()方法（理论:1.static final常量3.抽象方法4.抽象类项目:2.设计窗口的宽和高为常量，适当地方做修改5.画对象）Shoot射击游戏第七天:
1.敌人入场:1)敌人是由窗口产生的，所以在World中创建nextOne()生成敌人对象2)敌人入场为定时发生的，在run()中调用enterAction()实现敌人入场在enterAction()中:每400毫秒，获取敌人对象，扩容并装到最后一个元素上
2.子弹入场:1)子弹是由英雄机发射出来的，所以在Hero中创建shoot()生成子弹对象2)子弹入场为定时发生的，在run()中调用shootAction()实现子弹入场在shootAction()中:每300毫秒，获取子弹对象，扩容并数组追加
3.飞行物移动:1)飞行物移动为所有对象所共有的行为，所以在超类中设计抽象方法step()派生类中重写step()2)飞行物移动为定时发生的，在run()中调用stepAction()实现飞行物移动在stepAction()中:天空动，遍历敌人敌人动，遍历子弹子弹动（理论:1.成员内部类2.匿名内部类项目:3.敌人入场4.子弹入场5.飞行物移动）Shoot射击游戏第八天:
1.英雄机随着鼠标移动:1)英雄机随着鼠标动为英雄机的行为，所以在Hero中设计moveTo()实现英雄机随着鼠标移动2)英雄机随着鼠标动为事件触发的，所以在侦听器中重写mouseMoved()在mouseMoved()中:获取鼠标的x和y坐标，英雄机随着动
2.删除越界的敌人和子弹:1)将检测敌人越界行为outOfBounds()设计在FlyingObject中，在Bullet中重写outOfBounds()2)删除越界行为为定时发生的，所以在run()中调用outOfBoundsAction()实现删除越界，在outOfBoundsAction()中:声明不越界数组，遍历敌人/子弹数组，判断若不越界，则将不越界对象添加到不越界数组中，最后将不越界数组复制到enemies/bullets中
3.设计Enemy得分接口，Airplane和BigAirplane实现设计Award奖励接口，Bee实现（理论:3.接口项目:1.英雄机随着鼠标移动2.删除越界的敌人和子弹）Shoot射击游戏第九天:
1.敌人与子弹的碰撞:1)在FlyingObject中设计hit()实现敌人与子弹的碰撞在FlyingObject中设计goDead()实现飞行物去死在Hero中设计addLife()增命、addDoubleFire()增火力2)敌人与子弹的碰撞为定时发生的，在run()中调bulletBangAction()实现敌人与子弹的碰撞在bulletBangAction()中:遍历子弹得子弹，遍历敌人得敌人，判断若撞上了:子弹去死、敌人去死判断被撞对象:若是Enemy，则玩家增分若是Award，则英雄机增命或增火力
2.画分和画命:1)在Hero中设计getLife()获取英雄机的命2)在paint()中:画分和画命（理论:1.多态项目:2.子弹与敌人的碰撞3.画分和画命）Shoot射击游戏第十天:
1.英雄机与敌人的碰撞:1)借用FlyingObject的hit()碰撞、goDead()去死在Hero类中设计subtractLife()减命、clearDoubleFire()清空火力值2)英雄机与敌人碰撞为定时发生的，在run()中调用heroBangAction()实现英雄机与敌人的碰撞在heroBangAction()中:遍历敌人得敌人，判断是否与英雄机撞上了，若撞上了:敌人去死、英雄机减命、英雄机清空火力值
2.检测游戏结束:1)借用Hero的getLife()获取命数2)检测游戏结束为定时发生的，在run()在调用checkGameOverAction()检测结束在checkGameOverAction()中:判断当英雄机的命数<=0时，则游戏结束(将当前状态修改为游戏结束状态)
3.画状态:1)设计四个常量表示4种状态，并设计state表示当前状态(默认为启动状态)设计三个静态变量表示3个图片，并在static块中初始化在paint()中，实现在不同状态下画不同的图片2)将run中那一堆action设计为只在运行状态下才执行将英雄机随着鼠标动设计为只在运行状态下才执行3)重写mouseClicked()鼠标点击事件:启动变运行、游戏结束先清理再变启动重写mouseExited()鼠标移出事件:  运行变暂停重写mouseEntered()鼠标移入事件: 暂停变运行（ 理论:1.内存管理项目:2.英雄机与敌人的碰撞3.检测游戏结束4.画状态）

java面向对象：三大特性：封装，继承，多态相关推荐

深入理解Java面向对象三大特性封装继承多态
1.封装封装的定义: 首先是抽象,把事物抽象成一个类,其次才是封装,将事物拥有的属性和动作隐藏起来,只保留特定的方法与外界联系为什么需要封装: 封装符合面向对象设计原则的第一条:单一性原则,一个类 ...
Java面向对象三大特性(封装继承多态)解释及案例
文章目录包包基本语法命名规则命名规范导入包实例访问修饰符面向对象编程-封装面向对象编程-继承 super关键词 super和this的比较方法重写/覆盖 (override) 注意事 ...
Java面向对象三大特性之继承多态的预习笔记，are you ready? 面对疾风吧！
文章目录继承(extends) super关键字方法重写 instanceof关键字 abstract关键字接口(interface) 多态继承(extends) AextendsB A继承了 ...
Day55-每日一道Java面试题-Java 面向对象编程三大特性: 封装继承多态
Java 面向对象编程三大特性: 封装继承多态封装封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法,如果属性不想被外界访问,我们大可不必提供方法给外界访问.但是如果一个类没有 ...
java 面向对象三大特性之继承万字详解（超详细）
目录前言 : 一.为什么需要继承: 二.什么是继承(Warning : 篇幅较长)? 1.继承概述: 2.子类继承父类之后达到的效果 : ①如何使用继承? ②代码演示 : 3.继承的使用场景: eg ...
Java面向对象三大特性(封装、继承、多态)
文章目录前言一.封装 1. 封装的概念 2. private实现封装 3. getter和setter方法 4.封装的好处二.继承 1. 继承的概念 2. extends实现继承 3. supe ...
-1-2 java 面向对象基本概念封装继承多态变量 this super static 静态变量匿名对象值传递初始化过程代码块 final关键字抽象类接口
java是纯粹的面向对象的语言也就是万事万物皆是对象程序是对象的集合,他们通过发送消息来相互通信每个对象都有自己的由其他的对象所构建的存储,也就是对象可以包含对象每个对象都有它的类型也就是 ...
Python OOP：面向对象三大特性(封装、继承、多态)、类属性和实例属性、类方法@classmethod、静态方法@staticmethod、函数和类callable、__call__
一.面向对象三大特性二.多态定义:多态是⼀种使⽤对象的⽅式,⼦类重写⽗类⽅法,调⽤不同⼦类对象的相同⽗类⽅法,可以产⽣不同的执⾏结果. 一个父类,可以继承给多个子类,每个不同的子类可以创建多个对象 ...
java 面向对象三大特性之多态万字详解（超详细）
目录前言 : 一.为什么需要多态 : 1.白璧微瑕 : 2.举栗(请甘雨,刻晴,钟离吃饭): 3.代码 : 4.问题 : 二.什么是多态 : 1.定义 : 2.多态的实现步骤(重要) : 三.多态的 ...
【职坐标】java面向对象三大特性（二）——继承详解
[职坐标]java面向对象三大特性(二)--继承详解 a) 什么是继承? i. 多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可 b) ...

java面向对象：三大特性：封装，继承，多态

java面向对象：三大特性：封装，继承，多态相关推荐

最新文章

热门文章