java从入门到精通----OOP 2

一、Shoot射击游戏第一天:
1)创建了6个对象类，并创建World类测试

正课:
1.什么是类？什么是对象？
1)现实世界是由很多对象组成的
基于对象抽出了类
2)对象:真实存在的单个个体
类:类型/类别，代表一类个体
3)类中可以包含:
3.1)所有对象所共有的属性/特征----------------成员变量
3.2)所有对象所共有的行为---------------------方法
4)一个类可以创建多个对象
同一类型所创建出来的对象，结构相同，数据不同
5)类是对象的模板，对象是类具体的实例
2.如何创建类？如何创建对象？如何访问成员？

练习:
1)将今天的内容重写两次
2)oo.day02中设计Student和StudentTest

当日事当日毕

class Hero{ //英雄机
width,height,x,y,life,doubleFire

void step(){} //切换图片
void moveTo(){} //随着鼠标移动

}

class Airplane{
width,height,x,y,speed
void step(){}
}

MeShoot
cn.tedu.shoot
Hero
Airplane
BigAirplane
Bee
Bullet
Sky
World

1)先找对象:英雄机、天空、小敌机、大敌机、小蜜蜂、子弹
2)抽类:Hero、Sky、Airplane、BigAirplane、Bee、Bullet
3)设计类中的成员变量和方法(下周讲业务再详细做)
4)创建对象并测试

角色:
英雄机、子弹、小敌机、大敌机、小蜜蜂、天空

关系:
1)英雄机可以发射子弹
2)子弹可以射击小敌机、大敌机、小蜜蜂
3)小敌机、大敌机、小蜜蜂可以撞英雄机
4)英雄机、子弹、小敌机、大敌机、小蜜蜂都在天空上飞

规则:
1)英雄机可以单倍火力(火力值为0)或双倍火力(火力值大于0)
2)子弹打中小敌机-----------------玩家得1分
子弹打中大敌机-----------------玩家得3分
子弹打中小蜜蜂-----------------英雄机得奖励(1条命或40火力值)
子弹发射一次双倍火力，则火力值减2
3)小敌机、大敌机、小蜜蜂与英雄机撞上后
英雄机减命同时清空火力值-----英雄机命数为0则游戏结束

引用
类(数据类型) 引用类型变量指向对象
Student zs = new Student();

数据类型引用指向对象
Student zs = new Student();

基本类型变量(变量)
int a = 5;
赋值

new Student();----------------------一般不这样做

Student zs = new Student();
zs.name = "zhangsan";
zs.age = 25;

引用类型----------默认值null

oo.day01
Student
StudentTest

类对象
月饼模子月饼

Student zs = new Student();
zs.name = "zhangsan";
zs.age = 25;
zs.address = "河北廊坊";
zs.stuId = "001";
zs.eat();
zs.sleep();
zs.study();
zs.abc = 250; //编译错误，没有abc属性

Student ls = new Student();
ls.name = "lisi";
ls.age = 26;
ls.address = "黑龙江佳木斯";
ls.stuId = "002";
ls.eat();
ls.sleep();
ls.study();

class Student{ //学生
String name;
int age;
String address;
String stuId;
void eat(){}
void sleep(){}
void study(){}
}

Student zs = new Student();
Student ls = new Student();
Student ww = new Student();

class Teacher{ //老师
String name;
int age;
String address;
double salary;
void eat(){}
void sleep(){}
void play(){}
void teach(){}
}

class Student{ //学生
String name;
int age;
String address;
String stuId;
void eat(){}
void sleep(){}
void study(){}
}

class Dog{ //狗
String color;
String type;
void 叫(){}
void 看门(){}
}

class Car{ //汽车
String type;
String color;
double price;
void run(){}
void back(){}
void stop(){}
}

对象类
WKJ 老师
GKK
XY

张三学生
李四
王五

小花狗
小黑
小强

马六汽车
奥迪
奥拓

class Emp{ //Emp就是我自己造的一个数据类型，名为Emp
String name;
int age;
double salary;
void print(){
System.out.println("姓名:"+name);
System.out.println("年龄:"+age);
System.out.println("工资:"+salary);
}
}

面向过程的结构化程序设计弊端:
1)缺乏对数据的封装
2)数据与方法(操作数据)的分离

基本类型-------------------只能装一个数据
数组类型-------------------必须数据类型相同
自己造数据类型-------------想装什么就装什么

class Test{ //测试类
public static void main(String[] args){
Emp e = new Emp(); //创建了一个雇员对象
e.name = "zhangsan";
e.age = 25;
e.salary = 5000;
e.print();
}
}

高质量的代码:
复用性好、扩展性好、维护性好、
可移植性好、健壮性好、可读性好、效率好...

开发经理

抽了4个人，花费2个月的时间-----------设计了一套架构

福州夜间施工-----加功能(30万)
我一个人，每天最多一个小时---------干了5天

清华思路------------环保、GIS、MIS

40、50人-----项目多
一个组5个人左右

OA办公系统(产品)-------国家机关
Java-------------重做

A:加一些东西
B:加一些东西
C:加一些东西

产品:可以适应很多家公司的
项目:只能适应一家公司的

面向对象:OO

面向对象分析------OOA
面向对象设计------OOD
面向对象分析与设计-----OOAD

面向对象编程------OOP--------------你们所参与的

晕乎乎的----------------------正常的

不晕:
1)什么也不懂
2)自以为不晕------------------很不错很不错的了

迭代的

语言基础:
1.固定的(画一个圆形)
2.去银行取钱

面向对象:
1.抽象的(画一个图形)
2.向着社会主义社会发展

射击游戏项目
理论+项目

面向对象------讲9天+1天

二、Shoot射击游戏第一天:
1.创建6个对象类，并创建World类测试

Shoot射击游戏第二天:
1.创建了6个对象类的构造方法，在World类中测试

回顾:
1.什么是类？什么是对象？
2.如何创建类？如何创建对象？如何访问成员？

笔记:
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: 身份证复印件

练习:
1)在oo.day03包中创建Stu和StuTest
2)将今天的所有项目代码重做两次

今天的图画一下

NullRefDemo

房子:对象
房子钥匙:引用
配一把钥匙:引用

内存管理:由JVM来管理的
1)堆:所有new出来的对象(包括成员变量)
2)栈:所有的局部变量
3)方法区:.class字节码文件(包括方法)

x = (int)(Math.random()*100);

Random rand = new Random();
x = rand.nextInt(400-49); //0到350之间的

class Student {
String name;
int age;
String address;


Student(String name){
this(name,0);
}
Student(String name,int age){
this(name,age,null);
}
Student(String name,int age,String address){
this.name = name;
   this.age = age;
   this.address = address;
}

}

Student zs = new Student();
zs.name = "zhangsan";
zs.age = 25;
zs.address = "LF";
zs.study();
zs.sayHi();

Student ls = new Student();
ls.name = "lisi";
ls.age = 27;
ls.address = "JMS";
ls.study();
ls.sayHi();

Student zs = new Student("zhangsan",25,"LF");
Student ls = new Student("lisi",26,"JMS");

class Student {
String name;
int age;
String address;
Student(String name,int age,String address){
this.name = name; //ls.name="lisi";
   this.age = age; //ls.age=26;
   this.address = address; //ls.address="JMS";
}
void study(){
   System.out.println(name+"在学习...");
}
void sayHi(){
   System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
}
}

成员变量和局部变量是可以同名的，用时采用就近原则
成员变量和局部变量同名时，this不能省略

Student zs = new Student("zhangsan",25,"LF");
Student ls = new Student("lisi",26,"JMS");
Student ww = new Student();

class Student{
String name;
int age;
String address;
Student(){
}
//给成员变量赋初值
Student(String name1,int age1,String address1){
name = name1;
age = age1;
address = address1;
}
}

class Student{
String name;
int age;
String address;
//给成员变量初始化
Student(String name1,int age1,String address1){
name = name1;
age = age1;
address = address1;
}
}

Student zs = new Student("zhangsan",25,"LF");
Student ls = new Student("lisi",26,"JMS");

Student zs = new Student();
zs.setInfo("zhangsan",25,"LF");

Student ls = new Student();
ls.setInfo("lisi",26,"JMS");

Student zs = new Student();
zs.name = "zhangsan";
zs.age = 25;
zs.address = "河北廊坊";

Student ls = new Student();
ls.name = "lisi";
ls.age = 26;
ls.address = "黑龙江佳木斯";

//1)创建了一个学生对象
//2)给成员变量赋默认值
//3)调用了Student类的构造方法
Student zs = new Student();

void println(){
}
void println(int a){
}
void println(double b){
}
void println(char c){
}
void println(boolean b){
}
void println(String s){
}

System.out.println();
System.out.println(23);
System.out.println(45.67);
System.out.println('女');
System.out.println(true);
System.out.println("Hello");

java从入门到精通----OOP 2

三、

Shoot射击游戏第一天:
1.创建6个对象类，并创建World类测试

Shoot射击游戏第二天:
1.创建了6个对象类的构造方法，在World类中测试

Shoot射击游戏第三天:
1.设计小敌机数组、大敌机数组、小蜜蜂数组、子弹数组，并测试
2.设计FlyingObject超类，6个对象类继承超类
3.给FlyingObject超类设计了两个构造方法，6个派生类中分别调用

回顾:
1.方法的重载(Overload):
1)发生在一个类中，方法名相同，参数列表不同
2)编译器在编译时会根据方法的签名自动绑定调用的方法
2.构造方法:构造函数、构造器、构建器
给成员变量赋初值，与类同名、没有返回值类型，
   创建对象时被自动调用
   若自己不写，则默认无参的，若自己写了，则不再默认提供
   可以重载
3.this:指代当前对象，哪个对象调用方法它指的就是哪个对象
this.成员变量名--------------访问成员变量
   this.方法名()----------------调用方法
   this()-----------------------调用构造方法
4.null:空，没有指向任何对象
对null操作会发生NullPointerException空指针异常
5.引用类型变量之间画等号: 指向同一个对象，影响
基本类型变量之间画等号: 赋值，不影响

笔记:
1.引用类型数组:
1)Student[] stus = new Student[3];
stus[0] = new Student("zhangsan",25,"LF");
   stus[1] = new Student("lisi",26,"JMS");
   stus[2] = new Student("wangwu",27,"SD");
stus[1].age = 36; //给stus中第2个元素的年龄赋值为36
2)Student[] stus = new Student[]{
new Student("zhangsan",25,"LF"),
new Student("lisi",26,"JMS"),
new Student("wangwu",27,"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; //给arr中第2个元素中的第1个元素赋值为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] = 100;
   }
   }
2.继承:
1)作用:代码复用
2)通过extends来实现继承
3)超类:所有派生类所共有的属性和行为
派生类:派生类所特有的属性和行为
4)派生类继承超类后，派生类具有:超类的+派生类的
5)一个超类可以有多个派生类
一个派生类只能有一个超类-------单一继承
6)继承具有传递性
7)java规定:构造派生类之前必须先构造超类
在派生类的构造方法中若没有调用超类的构造方法
   ----------则默认super()调用超类的无参构造方法
   在派生类的构造方法中若调用了超类的构造方法
   ----------则不再默认提供
   super()调用超类构造方法，必须位于派生类构造的第1句
3.super:指代当前对象的超类对象
super的用法:
1)super.成员变量名-----------------访问超类的成员变量
   2)super.方法名()-------------------调用超类的方法(明天下午讲)
   3)super()--------------------------调用超类的构造方法

练习:
1.将今天的项目代码重写两次
2.oo.day04包中，要求:
1)创建Person超类，包含:
1.1)成员变量:name,age,address
   1.2)构造方法:Person(3个参数){}
   1.3)方法:sayHi()---输出name+age+address的值
2)创建Student类，继承Person，包含:
2.1)成员变量:stuId
   2.2)构造方法:Student(4个参数){}
3)创建Teacher类，继承Person，包含:
2.1)成员变量:salary
   2.2)构造方法:Teacher(4个参数){}
4)创建Doctor类，继承Person，包含:
2.1)成员变量:level
   2.2)构造方法:Doctor(4个参数){}
5)创建Test类，在main()中:
5.1)创建Student数组，Teacher数组，Doctor数组，并填充数据
   遍历三个数组，分别跟大家问好

SuperDemo

FlyingObject:飞行物

继承要符合is a(是一个)的关系

class Aoo{
int a;
}
class Boo extends Aoo{
int b;
}
class Coo extends Boo{
int c;
}

Coo o = new Coo();
o.c = 1;
o.b = 2;
o.a = 3;

class Person{----------------------------超类/父类
String name;
int age;
String address;
void eat(){}
void sleep(){}
}
class Student extends Person{------------派生类/子类
String stuId;
void study(){}
}
class Teacher extends Person{------------派生类/子类
double salary;
void teach(){}
}
class Doctor extends Person{-------------派生类/子类
String level;
void cut(){}
}

Teacher tea = new Teacher();
tea.salary/teach();
tea.name/age/address/eat()/sleep();

Student stu = new Student();
stu.stuId/study();
stu.name/age/address/eat()/sleep();

程序中的继承:
代码不用自己写，自己也能用

生活中的继承:
1)继承财产:
钱不用自己挣，自己也能花
2)继承皇位:
江山不用自己打，自己也能坐
3)继承工作:
工作不用自己找，自己也能干

3:为as的长度
4:为as中每个元素的长度

int[][] as = new int[3][4]; //3行4列
for(int i=0;i<as.length;i++){ //行
for(int j=0;j<as[i].length;j++){ //列
as[i][j] = 100;
}
}

i=0
j=0 00
j=1 01
j=2 02
j=3 03
i=1
j=0 10
j=1 11
j=2 12
j=3 13
i=1
j=0 20
j=1 21
j=2 22
j=3 23

//声明int[]型数组as，包含3个元素
//每个元素都是int[]型，默认值为null
int[][] as = new int[3][];
as[0] = new int[2];
as[1] = new int[3];
as[2] = new int[2];
//给as中第2个元素中的第1个元素赋值为100
as[1][0] = 100;

as----------------int[][]
as[0]-------------int[]
as[0][0]----------int

//声明double[]型数组ds，包含10个元素
//每个元素都是double[]型，默认值为null
double[][] ds = new double[10][];

int[] arr = new int[]{
2,
5,
8
};

Student[] stus = new Student[]{
new Student("zhangsan",25,"LF"),
new Student("lisi",26,"JMS"),
new Student("wangwu",27,"SD")
};

//声明Student数组stus，包含3个元素
//每个元素都是Student类型，默认值为null
Student[] stus = new Student[3];

int[] arr = new int[3];
arr[0] = 5;

Student[] stus = new Student[3]; //创建Student数组对象
stus[0] = new Student(); //创建Student对象

Airplane[] as = new Airplane[10];

//声明整型数组arr，包含3个元素
//每个元素都是int类型，默认值为0
int[] arr = new int[3];

//声明Airplane数组as，包含10个元素
//每个元素都是Airplane类型，默认值为null
Airplane[] as = new Airplane[10];

Bee[] bs = new Bee[20];

int[] arr = new int[3];

堆:new出来的对象(包括成员变量)
栈:局部变量

变量里面装值
引用里面装地址

局部变量若是基本类型，存值
引用类型，存地址

java从入门到精通----OOP 2

四、Shoot射击游戏第一天:
1.创建6个对象类，并创建World类测试

Shoot射击游戏第二天:
1.创建了6个对象类的构造方法，在World类中测试

Shoot射击游戏第四天:
1.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组
2.在6个派生类中重写step()
3.画窗口

回顾:
1.引用类型数组:
Student[] stus = new Student[3];
stus[0] = new Student();

   int[][] arr = new int[3][];
   arr[0] = new int[2];
2.继承:
代码复用，extends，
   超类:共有的派生类:特有的
   派生类继承超类后，派生类具有:超类+派生类的
   单一继承、传递性
   构造派生类之前必须先构造超类
   ----派生类构造中若不调用超类构造，则默认super()调超类无参构造
   ----若派生类中调用了超类构造，则不再默认提供
3.super:指代当前对象的超类对象
super.成员变量名-------------访问超类的成员变量
super.方法名()---------------调用超类的方法
super()----------------------调用超类的构造方法

笔记:
1.向上造型:
1)超类型的引用指向派生类对象
2)能点出来什么，看引用的类型
2.方法的重写(Override):重新写、覆盖
1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
2)重写方法被调用时，看对象的类型
3)重写遵循"两同两小一大"原则:
3.1)两同:
   3.1.1)方法名相同
       3.1.2)参数列表相同
   3.2)两小:
   3.2.1)派生类方法的返回值类型小于或等于超类方法的
       3.2.1.1)void时，必须相等
           3.2.1.2)基本类型时，必须相等
           3.2.1.3)引用类型时，小于或等于
       3.2.2)派生类方法抛出的异常小于或等于超类方法的------API讲异常时
   3.3)一大:
   3.3.1)派生类方法的访问权限大于或等于超类方法的------明天讲
3.重写与重载的区别:---------常见面试题
1)重写:
1.1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
   1.2)遵循"运行期绑定"，看对象的类型来调用方法
2)重载:
2.1)发生在一个类中，方法名称相同，参数列表不同，方法体不同
   2.2)遵循"编译期绑定"，看引用/参数的类型来绑定方法

练习:
1.将今天的项目代码重做两次
1)将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组
2)在6个派生类中重写step()
3)画窗口

当日事当日毕

swing相关:
1)JFrame:框架(相框)
2)JPanel:面板(相板)

C/S:客户端/服务器
B/S:浏览器/服务器-----------------你们所参与的

C/S端-------本身java就没那么火过
C-----------微软是老大

java

OverrideOverloadDemo

编译期:.java源文件，经过编译，生成.class字节码文件--检测语法
运行期:JVM加载.class并运行.class

内存管理:由JVM来管理的

OverrideDemo

我继承了一个中餐馆

A:我还是想做中餐-----------------不需要重写
B:我想改做西餐-------------------需要重写
C:我想在中餐基础之上加西餐-------需要重写(先super后重写)

Boo o1 = new Boo();
o1.show();------------------222
Aoo o3 = new Boo();
o3.show();------------------222

Aoo o2 = new Aoo();
o2.show();------------------111

class Aoo{
void show(){
输出111
}
}
class Boo extends Aoo{
void show(){
输出222
}
}

class World{
FlyingObject[] enemies;
FlyingObject[] enemies = null;

FlyingObject[] enemies = {};
FlyingObject[] enemies = new FlyingObject[0];
}

for(int i=0;i<enemies.length;i++){
enemies[i].step();
}

小敌机、大敌机、小蜜蜂-------------敌人

FlyingObject[] fs = new FlyingObject[8];
fs[0] = new Bee();

FlyingObject o1 = new Airplane();
FlyingObject o2 = new BigAirplane();
FlyingObject o3 = new Bee();
FlyingObject o4 = new Hero();
FlyingObject o5 = new Sky();
FlyingObject o6 = new Bullet(100,200);

o1.FlyingObject类中有的
o2.FlyingObject类中有的
o3.FlyingObject类中有的
o4.FlyingObject类中有的
o5.FlyingObject类中有的
o6.FlyingObject类中有的

Person p1 = new Student();
Person p2 = new Teacher();
Person p3 = new Doctor();
p1.Person类中有的
p2.Person类中有的
p3.Person类中有的

Animal o3 = new Tiger();
o3.Animal类中有的

class Animal{ //动物
}
class Tiger extends Animal{ //老虎
}

//动物是动物
Animal o1 = new Animal();
//老虎是老虎
Tiger o2 = new Tiger();
//老虎是动物
Animal o3 = new Tiger();

//动物是老虎-----语义不通
Tiger o4 = new Animal(); //编译错误

class Animal{ //动物
}
class Tiger extends Animal{ //老虎
}

五、

Shoot射击游戏第一天:
1.创建6个对象类，并创建World类测试

Shoot射击游戏第二天:
1.创建了6个对象类的构造方法，在World类中测试

Shoot射击游戏第四天:
1.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组
2.在6个派生类中重写step()
3.画窗口

Shoot射击游戏第五天:
1.将类中的成员添加访问控制修饰符
2.设置图片属性

回顾:
1.向上造型:
1)超类型的引用指向派生类的对象
2)能点出来什么，看引用的类型
2.方法的重写(Override):
1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
2)重写方法被调用时，看对象的类型
3.重写与重载的区别:
1)重写(Override):
1.1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
1.2)"运行期"绑定，看对象类型来调用方法
2)重载(overload):
2.1)发生在一个类中，方法名称相同，参数列表不同，方法体不同
2.2)"编译期"绑定，看引用/参数类型来绑定方法

笔记:
1.package:
1)作用:避免类名冲突
2)包名可以有层次结构
3)类的全称为: 包名.类名
4)建议:包名所有字母都小写
import:
1)同包中的类可以直接访问，
不同包中的类不能直接访问，想访问只有如下两种方式:
   1.1)先import声明类再使用类----建议
   1.2)类的全称------------------太繁琐，不建议
2.访问控制修饰符:
1)public:公开的，任何类
2)private:私有的，本类
3)protected:受保护的，本类、子类、同包类
4)默认的:什么也不写，本类、同包类
说明:
1)类的访问修饰只能是public和默认的
   2)类中成员的访问修饰如上四种都可以
3.final:最终的、不可改变的---------------应用率低
1)修饰变量:变量不能被改变
2)修饰方法:方法不能被重写
3)修饰类:类不能被继承
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)何时用:加载/初始化静态资源(图片、音频、视频等)
5.static final常量:------今天自学，明天讲

练习:
1.将今天的项目代码重写两次
2.代码格式改好

异常
异常处理

需要对文件进行操作，对文件操作特别容易出现异常
------强制做文件操作时，必须要加入异常处理

窗口
想画对象，先有图片-------给6个对象类准备图片属性

能否将图片设计在超类FlyingObject中
--------------------------------------不能

private static BufferedImage image;

读图片

6个对象类的static块中-------都得去读图片

实例变量多还是静态变量多?----------------实例变量多
实例方法多还是静态方法多?----------------实例方法多

一般的方法都是与对象有关的

Arrays.sort(arr);----------------静态的

无论a1,a2,a3,...,a100中的哪一个对象
去sort(arr)最终的结果都是一样的
---说明sort()这个方法的执行仅与参数相关而与对象无关

假设sort()不是静态的:
Arrays a1 = new Arrays();
a1.sort(arr);

Arrays a2 = new Arrays();
a2.sort(arr);

Arrays a3 = new Arrays();
a3.sort(arr);

double a = Math.sqrt(25);------------静态的

无论m1,m2,m3,...,m100中的哪一个对象
去sqrt(25)最终的结果都是一样的
---说明sqrt()这个方法仅与参数相关而与对象无关

假设sqrt()不是静态的:
Math m1 = new Math();
double a = m1.sqrt(25); //5.0

Math m2 = new Math();
double b = m2.sqrt(25);

Math m3 = new Math();
double b = m3.sqrt(25);

Scanner scan = new Scanner(System.in);
int a = scan.nextInt();
double b = scan.nextDouble();---------------实例方法

double c = Math.random();
double d = Math.sqrt(25);
int[] b = Arrays.copyOf(a,6);
Arrays.sort(arr);

小敌机------------图片

map.jpg--------------------图片(只有一份)
意外.mp4-------------------音频(只有一份)
无间道2.avi----------------视频(只有一份)

成员变量:
1)实例变量:没有static，属于对象的，存储在堆中，
有几个对象就有几个
通过对象名点来访问
2)静态变量:由static修饰，属于类的，存储在方法区中，
只有一份
通过类名点来访问

堆:new出来的对象(包括实例变量)
栈:局部变量
方法区:.class字节码文件(包括方法、静态变量)

class Aoo{
int a;
static int b;
}

方法:
1)公开的---------------public

成员变量:
1)超类中的成员变量---------protected
2)普通类中的成员变量-------private

数据(变量)私有化(private)，行为(方法)公开化(public)

class Card{
private String cardId;
private String cardPwd;
private double balance;

public boolean payMoney(double money){
if(balance>=money){
   balance-=money;
   return true;
   }else{
   return false;
   }
}

public boolean checkPwd(String pwd){
if(cardPwd.equals(pwd)){
   return true;
   }else{
   return false;
   }
}

}

import java.util.Scanner;
Scanner scan = new Scanner(System.in);
int a = scan.nextInt();
double b = scan.nextDouble();
String c = scan.next();

package java.util;
class Scanner{
Scanner(Stream s){
}
int nextInt(){
}
double nextDouble(){
}
String next(){
}
}

民生银行

A公司:
package a.b.c;
class Aoo{
}

B公司:
package a.b.c;
class Aoo{
}

可移植性

建议:
域名反写 . 项目名称 . 模块名称 . 类名
cn.tedu . aproject . stumanager .
cn.tedu . aproject . teachermanager .

cn.tedu . bproject

com.taobao .

package a.b.c.d.e;
class Aoo{
}
package a.b.c.d.e;
class Aoo{
}

项目包类
东日瑞景 4号楼2单元 601

访问控制修饰符-----------一个案例
static-------------------一个案例

六、

Shoot射击游戏第一天:
1.创建6个对象类，并创建World类测试

Shoot射击游戏第二天:
1.创建了6个对象类的构造方法，在World类中测试

Shoot射击游戏第四天:
1.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组
2.在6个派生类中重写step()
3.画窗口

Shoot射击游戏第五天:
1.将类中的成员添加访问控制修饰符
2.设置图片属性

Shoot射击游戏第六天:
1.画对象:
1)想画对象，得先去获取对象的图片，
每个对象都得获取图片，意味着获取图片行为为共有的行为，
   所以需要将获取图片的行为设计在FlyingObject超类中，
每个对象获取图片的行为都是不一样的，
所以获取图片的行为设计为抽象方法
   --------在FlyingObject类中设计抽象方法getImage()
2)在获取对象的图片时，需要去考虑对象的状态(生命周期)，
状态分三种(活着的、死了的(未删除)、删除的)，
   在实际应用中，状态都应设计为常量，
   每个对象都有状态，所以将状态设计在FlyingObject超类中，
   --------在FlyingObject类中设计三个常量和变量(存储当前状态)
在获取图片时，需要去判断每个对象的状态，用于获取不同的图片，
   所以对象状态判断的行为为共有的行为，设计在FlyingObject超类中，
   每个对象判断状态的行为都是一样的，设计为普通方法
   --------在FlyingObject类中设计isLife()/isDead()/isRemove()
3)在派生类中重写getImage()用于在不同状态下获取不同的图片
3.1)Sky天空，直接返回image
   3.2)Bullet子弹:
   3.2.1)若活着的，直接返回image
       3.2.2)若死了的，就删除
3.3)Airplane小敌机:
3.3.1)若活着呢，返回第1张图片
3.3.2)若死了呢，从第2张图到第5张图轮换，第5张图后可以删除了
3.4)Airplane小敌机:
3.4.1)若活着呢，返回第1张图片
3.4.2)若死了呢，从第2张图到第5张图轮换，第5张图后可以删除了
   3.5)Airplane小敌机:
3.5.1)若活着呢，返回第1张图片
3.5.2)若死了呢，从第2张图到第5张图轮换，第5张图后可以删除了
3.6)Hero英雄机:
   3.6.1)若活着呢，返回2张图片的切换
4)图片有了，就可以开画了，6个对象都可开画，属于共有的行为，
所以将画的行为设计在FlyingObject超类中，
   所有对象画的行为都是一样的，所以设计为普通方法
   --------在FlyingObject超类中设计普通方法paintObject()画对象
5)因为Sky天空是两张图，所以需要重写超类的paintObject()
--------在Sky类中重写paintObject()
6)画的行为完以后，只需要在窗口上调用即可
--------在World类中重写paint()，而后调用paintObject()

回顾:
1.package和import:
2.访问控制修饰符:
1)public:任何类
2)protected:本类、子类、同包类
3)默认的:什么也不写，本类、同包类
4)private:本类
3.final:不能变
变量不能被改变，方法不能被重写，类不能被继承
4.static:静态的
static，类，方法区，一份，类名点，
   所有对象所共享的数据(图片、音频、视频等)
static，类，方法区，一份，类名点，
   静态方法没有隐式this，不能直接访问实例成员
   方法的操作仅与参数相关而与对象无关
   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)所有派生类的行为都一样，设计为普通方法
所有派生类的行为都不一样，设计为抽象方法
3)

FlyingObject o = new Airplane();
FlyingObject o = new BigAirplane();

abstract class FlyingObject{
width,height,x,y
abstract void step();
}
class Airplane extends FlyingObject{
void step(){ //y向下 }
}
class Bee extends FlyingObject{
void step(){ //x和y都得变 }
}
class Bullet extends FlyingObject{
void step(){ //y向上 }
}

new FlyingObject(); //编译错误
new FlyingObject[5]; //正确

abstract class Aoo{
abstract void show();
}
class Boo extends Aoo{
void show(){ //重写----变不完整为完整
}
}

FlyingObject o = new FlyingObject(); //创建FlyingObject对象

FlyingObject[] o = new FlyingObject[3]; //创建FlyingObject数组对象

NUMBER
COUNT
SCORE
MY_SCORE

七、

Shoot射击游戏第一天:
1.创建6个对象类，并创建World类测试

Shoot射击游戏第二天:
1.创建了6个对象类的构造方法，在World类中测试

Shoot射击游戏第四天:
1.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组
2.在6个派生类中重写step()
3.画窗口

Shoot射击游戏第五天:
1.将类中的成员添加访问控制修饰符
2.设置图片属性

Shoot射击游戏第七天:
1.敌人入场:
1)敌人是由窗口产生的，所以在World中设计nextOne()生成敌人对象
2)敌人入场为定时发生的，在run()中调用enterAction()实现敌人入场
在enterAction()中:
   每400毫秒调用nextOne()获取敌人，enemies扩容，装在最后一个元素上
2.子弹入场:
1)子弹是由英雄机发射出来的，所以在Hero中设计shoot()生成子弹对象
2)子弹入场为定时发生的，在run()中调用shootAction()实现子弹入场
在shootAction()中:
   每300毫秒调用hero的shoot()获取子弹，bullets扩容，数组追加
3.飞行物移动:
1)移动是所有对象所共有的行为，并且每个对象移动的形为都是不一样的，
所以在超类FlyingObject中设计了抽象方法step()，派生类重写step()
2)飞行物移动为定时发生的，在run()中调用stepAction()实现飞行物移动
在stepAction()中:
   天空动，遍历敌人而后敌人动，遍历子弹而后子弹动

回顾:
1.static final常量:
必须声明同时初始化，类名点，不能改变
编译时直接被替换为具体的值，效率高
数据永远不变，经常使用
2.抽象方法:
abstract，只有方法的定义，没有具体的实现
3.抽象类:
abstract，包含抽象方法的类必须是抽象类
不能被实例化
是需要被继承的，派生类:
1)重写抽象类中的所有抽象方法
2)也声明为抽象类
意义:代码复用、向上造型、
可以包含抽象方法，为所有派生类提供统一的入口
派生类中重写的实现不同，但入口是一致的

正课:
1.成员内部类: 应用率低
1)类中套类，里面的称为Inner内部类，外面的称为Outer外部类
2)内部类通常只服务于外部类，对外不具备可见性
3)内部类通常是在外部类中创建的
4)内部类中可以直接访问外部类的成员(包括私有的)
内部类中有一个隐式的引用指向了创建它的外部类对象
eg: 外部类名.this.
2.匿名内部类:
1)若想创建一个类的对象，并且对象只被创建一次，
此时该类不必命名，称之为匿名内部类
2)jdk1.7(含)版本之前，匿名内部类中想访问外面的变量，
要求该变量必须是final的

常见面试题:
问:内部类有独立的.class吗?
答:有

功能实现步骤:
1.先写行为(方法):
1)若是某个对象特有的行为，则将行为设计在派生类中
若是所有对象共有的行为，则将行为设计在超类中
1.1)所有派生类行为都一样，设计为普通方法
1.2)所有派生类行为都不一样，设计为抽象方法，而后派生类重写
2.窗口调用:
1)定时触发的，在run()中调用
2)事件触发的，在侦听器中调用
3)画出来的，在paint()中调用

找问题最简单的方式就是打桩
System.out.println(数据);

Bullet[] bs = hero.shoot();
bullets = Arrays.copyOf(bullets,bullets.length+bs.length);
System.arraycopy(bs,0,bullets,bullets.length-bs.length,bs.length); //数组的追加

if(bs.length>2){
bullets[bullets.length-1] = bs[0];
bullets[bullets.length-2] = bs[1];
bullets[bullets.length-3] = bs[2];
}else if(bs.length>1){
bullets[bullets.length-1] = bs[0];
bullets[bullets.length-2] = bs[1];
}else{
bullets[bullets.length-1] = bs[0];
}

项目功能:
1)敌人入场----------------定时发生
2)子弹入场----------------定时发生
3)飞行物移动--------------定时发生

paint()调用的方式只有两种:
1)frame.setVisible(true);
2)repaint();

假设有5个敌人了，又来了一个

5个变6个

//生成敌人(小敌机、大敌机、小蜜蜂)对象
public FlyingObject nextOne(){
随机
}

敌人对象-------------------是由窗口创建出来的
----创建敌人对象的行为---------设计在窗口类World中

子弹对象-------------------是由英雄机发射出来的
----创建子弹对象的行为---------设计在英雄机类Hero中

敌人入场:
1)创建敌人对象
2)将对象添加到enemies数组中

子弹入场:
1)创建子弹对象
2)将对象添加到bullets数组中

项目功能:
1)敌人入场----------------定时发生
2)子弹入场----------------定时发生
3)飞行物移动--------------定时发生

TimerTask, long, long
timer.schedule(new TimerTask(){
public void run(){ //定时干的那个事----每10毫秒走一次
//敌人入场、子弹入场、飞行物移动、
}
},10,10);

第1个10:从程序启动到第一次触发的时间间隔
第2个10:从第一次触发到第二次触发的时间间隔
从第二次触发到第三次触发的时间间隔
从第三次触发到第四次触发的时间间隔
...

定时器------定时的干一件事

字母、数字、_和$符

NstInnerClassDemo$1.class
NstInnerClassDemo$2.class
NstInnerClassDemo$3.class
Mama$Baby.class

jdk1.0到1.7----------------内存管理几乎没有改变
jdk1.8---------------------内存管理做了相当一部分的修改

1.6

NstInnerClassDemo

Aoo o1 = new Aoo();
Boo o2 = new Boo(); //编译错误

class Aoo{
private int a=5;
void show(){
Boo o2 = new Boo();
}
class Boo{
void test(){
   System.out.println(a);
   System.out.println(Aoo.this.a);
   System.out.println(this.a); //编译错误
   }
}
}

八、

Shoot射击游戏第一天:
1.创建6个对象类，并创建World类测试

Shoot射击游戏第二天:
1.创建了6个对象类的构造方法，在World类中测试

Shoot射击游戏第四天:
1.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组
2.在6个派生类中重写step()
3.画窗口

Shoot射击游戏第五天:
1.将类中的成员添加访问控制修饰符
2.设置图片属性

Shoot射击游戏第八天:
1.英雄机随着鼠标移动:
1)英雄机移动是英雄机的行为，所以在Hero中设计moveTo(x,y)实现英雄机随着鼠标移动
2)英雄机随着鼠标移动是事件触发的，在侦听器中重写mouseMoved()鼠标移动事件
在mouseMoved()中:
   获取鼠标的x和y坐标，而后英雄机随着动
2.删除越界的飞行物:
1)越界检查为所有飞行物都具备的行为，只是每个对象的具体行为不一样，
在超类FlyingObject中设计抽象方法outOfBounds()，6个派生类中分别重写
2)删除越界飞行物为定时发生的，所以在run()中调用outOfBoundsAction()
在outOfBoundsAction()中:
   声明不越界敌人/子弹数组，遍历enemies/bullets，获取每个敌人或子弹
   判断若不越界，则将对象添加到不越界敌人/子弹数组中，
   将不越界敌人/子弹数组复制到enemies/bullets中
3.设计Enemy得分接口，而后Airplane和BigAirplane实现接口
设计Award奖励接口，而后Bee实现接口

回顾:
1.成员内部类:
类中套类，内部类对外不具备可见性，
   内部类对象通常是在外部类中创建的，
   内部类中可以直接访问外部类的成员(包括私有的)
   内部类中有个隐式的引用指向了创建它的外部类对象
   外部类名.this.
2.匿名内部类:
若想创建一个类的对象，并且对象只创建一次，
   此时该类不必命名，称之为匿名内部类

笔记:
1.接口:
1)是一种数据类型(引用类型)
2)由interface定义的
3)只能包含常量和抽象方法
4)接口不能被实例化
5)接口是需要被实现/继承的，实现类/派生类:
必须重写接口中的所有抽象方法
6)一个类可以实现多个接口，用逗号分隔
若又继承又实现时，应先继承后实现
7)接口可以继承接口

设计规则:
1)将所有派生类所共有的属性和行为，抽到超类中---------抽共性
2)所有派生类的行为都一样，设计为普通方法
所有派生类的行为都不一样，设计为抽象方法
3)将部分派生类所共有的行为，抽到接口中
符合既是也是原则时，使用接口
接口是对继承的单根性的扩展-------------实现多继承

Enemy
Award

子弹打掉小敌机-------------------玩家得1分
子弹打掉大敌机-------------------玩家得3分

子弹打掉小蜜蜂-------------------英雄机得奖励(命、火力值)
子弹打掉大黄蜂-------------------英雄机得奖励、玩家得分

abstract class FlyingObject{
width,height,x,y,
step(),getImage()...
}
interface Enemy{ //得分接口
int getScore();
}
interface Award{ //奖励接口
int getAwardType();
}
class Bee extends FlyingObject implements Award{
public int getAwardType(){ }
}
class BigYellowBee extends FlyingObject implements Award,Enemy{
public int getAwardType(){ }
public int getScore(){ }
}

class Airplane extends FlyingObject implements Enemy{
public int getScore(){ return 1; }
}
class BigAirplane extends FlyingObject implements Enemy{
public int getScore(){ return 3; }
}

class Hero extends FlyingObject{
}
class Bullet extends FlyingObject{
}
class Sky extends FlyingObject{
}

类和类-------------------继承extends
接口和接口---------------继承extends
类和接口-----------------实现implements

Inter1 o1 = new Inter1(); //编译错误，接口不能实例化
Inter2 o2 = new Aoo(); //向上造型
Inter1 o3 = new Aoo(); //向上造型

interface Inter1{
void show();
}
interface Inter2 extends Inter1{
void test();
}
class Aoo implements Inter2{
public void test(){}
public void show(){}
}

interface Inter1{
void show();
}
interface Inter2{
void test();
}
abstract class Aoo{
abstract void say();
}
class Boo extends Aoo implements Inter1,Inter2{
public void show(){}
public void test(){}
void say(){}
}

interface Inter1{
void show();
void test();
}
class Aoo implements Inter1{
public void show(){}
public void test(){}
}

Inter1 o1 = new Inter1();

interface Inter1{
public static final int NUM = 5;
public abstract void show();
int COUNT = 6; //默认public static final
void test(); //默认public abstract

int nn; //编译错误，常量必须声明同时初始化
void say(){} //编译错误，抽象方法不能有方法体
}

abstract class Aoo{
}

设计规则:
1)
2)
3)

面向过程编程
面向对象编程
面向接口编程

只待了5天
接口、继承
派生类

效率-------------------硬件来解决
复用性、扩展性---------只能代码来解决

-----------------只要不越界的
public void outOfBoundsAction(){
int index = 0; //1)下标 2)不越界敌人个数
FlyingObject[] enemyLives = new FlyingObject[enemies.length];
for(int i=0;i<enemies.length;i++){
FlyingObject f = enemies[i];
if(!f.outOfBounds()){ //不越界
   enemyLives[index] = f;
   index++;
   }
}
enemies = Arrays.copyOf(enemyLives,index);
}

共50个敌人，其中有20个越界了
---------------缩20次

------------------------看到越界的就删除
public void outOfBoundsAction(){
for(int i=0;i<enemies.length;i++){
FlyingObject f = enemies[i];
if(f.outOfBounds()){ //越界了
将f从enemies数组中删除(缩容)
}
}
}

删除越界的飞行物:
1)先写行为:
删除越界飞行物时，需要先判断飞行物是否越界
每个对象都需要做出判断，所以将判断越界行为设计在超类中
每个对象判断越界的行为都是不一样的，所以设计为抽象方法
而后每个派生类中重写抽象方法
2)页面调用:

swing相关的:
1)事件:发生了一个事
2)事件处理:发生事之后所做的操作
3)侦听器:
3.1)有一个侦听器
3.2)把侦听器装到窗口去

MouseAdapter l = new MouseAdapter(){
public void mouseMoved(MouseEvent e){
//英雄机随着鼠标移动
}
};
this.addMouseListener(l); //鼠标操作事件
this.addMouseMotionListener(l); //鼠标滑动事件

class Aoo extends MouseAdapter{
}

事件事件处理
鼠标点击启动状态变为运行状态
鼠标移动英雄机随着鼠标动
鼠标移出运行状态变为暂停状态
鼠标移入暂停状态变为运行状态

项目功能:
1.英雄机随着鼠标动
2.删除越界的飞行物
3.设计两个接口

九、

Shoot射击游戏第一天:
1.创建6个对象类，并创建World类测试

Shoot射击游戏第二天:
1.创建了6个对象类的构造方法，在World类中测试

Shoot射击游戏第四天:
1.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组
2.在6个派生类中重写step()
3.画窗口

Shoot射击游戏第五天:
1.将类中的成员添加访问控制修饰符
2.设置图片属性

Shoot射击游戏第九天:
1.子弹与敌人的碰撞:
1)在超类FlyingObject中设计hit()实现敌人与子弹/英雄机的碰撞
在超类FlyingObject中设计goDead()实现飞行物去死
   在Hero类中设计addLife()增命、addDoubleFire()增火力
2)子弹与敌人的碰撞为定时发生的，所以在run()中调用bulletBangAction()实现子弹与敌人的碰撞
在bulletBangAction()中:
   遍历所有子弹，获取每个子弹，遍历所有敌人，获取每个敌人，
   判断是否撞上了，若撞上了则:
   2.1)子弹去死、敌人去死
       2.2)若撞了小敌机和大敌机，则玩家得分
       若撞了小蜜蜂，则英雄机得奖励
2.画分和画命:
1)在Hero类中设计getLife()获取命
2)在paint()方法中，画分和画命

回顾:
1.接口:
引用类型，interface定义，只能包含常量和抽象方法
不能被实例化，是需要被实现的，实现类:必须重写所有抽象方法
一个类可以实现多个接口，用逗号分隔，先继承后实现
接口可以继承接口

笔记:
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)打桩
2)快速定位错误位置
3)单元测试
4)Debug调试工具

若撞上了:
1)子弹去死，敌人去死
2)小敌机和大敌机------------玩家得分
小蜜蜂--------------------英雄机增命、增火力

int score = 0; //得分
public void bulletBangAction(){ //10毫秒
for(int j=0;j<enemies.length;j++){
   FlyingObject f = enemies[j];
for(int i=0;i<bullets.length;i++){
Bullet b = bullets[i];
   if(b.isLife() && f.isLife() && f.hit(b)){ //撞上了
b.goDead();
       f.goDead();

if(f instanceof Enemy){
       Enemy en = (Enemy)f;
       score += en.getScore();
       }
       if(f instanceof Award){
       Award aw = (Award)f;
int type = aw.getType();
switch(type){
       case Award.DOUBLE_FIRE:
       hero.addDoubleFire();
           break;
case Award.LIFE:
       hero.addLife();
           break;
       }
       }

if(f instanceof Airplane){
       Airplane a = (Airplane)f;
score += a.getScore();
       }
       if(f instanceof BigAirplane){
       BigAirplane ba = (BigAirplane)f;
score += ba.getScore();
       }
       if(f instanceof BigYellowBee){
       BigYellowBee byb = (BigYellowBee)f;
score += byb.getScore();
int type = byb.getType();
switch(type){
       case Award.DOUBLE_FIRE:
       hero.addDoubleFire();
           break;
case Award.LIFE:
       hero.addLife();
           break;
       }
       }
       if(f instanceof Bee){
       Bee be = (Bee)f;
int type = be.getType();
switch(type){
       case Award.DOUBLE_FIRE:
       hero.addDoubleFire();
           break;
case Award.LIFE:
       hero.addLife();
           break;
       }
       }

}
}
}

}

class BigYellowBee extends FlyingObject implements Enemy,Award{
public int getScore(){ return 5; }
public int getType(){ return ?; }
}

子弹与敌人的碰撞

class FlyingObject{ //敌人
public boolean hit(FlyingObject obj){
//this:敌人
//obj:子弹
}
}

英雄机与敌人的碰撞:

goDead()

MultiTypeDemo

Aoo o = new Boo();
Boo o1 = (Boo)o; //符合条件1
Inter1 o2 = (Inter1)o; //符合条件2
//Coo o3 = (Coo)o; //类型转换异常
if(o instanceof Boo){ //false
Boo o4 = (Boo)o;
}

System.out.println(o instanceof Boo); //true
System.out.println(o instanceof Inter1); //true
System.out.println(o instanceof Coo); //false

class Inter1{}
class Aoo{}
class Boo extends Aoo implements Inter1{}
class Coo extends Aoo{}

Airplane o1 = new Airplane();
FlyingObject o2 = new Airplane();
Enemy o3 = new Airplane();

我 me = new 我();
讲师 o1 = me;
孩子他妈 o2 = me;
老公的老婆 o3 = me;

o1.授课();
o2.揍他();
o3.咬他();
o3.收工资();

me.授课();
me.揍他();
me.咬他();
me.收工资();

interface 讲师{
void 授课();
}
interface 孩子他妈{
void 揍他();
}
interface 老公的老婆{
void 咬他();
void 收工资();
}
class 我 implements 讲师,孩子他妈,老公的老婆{
public void 授课(){}
public void 揍他(){}
public void 咬他(){}
public void 收工资(){}
}

动物 o1 = new 老虎();
动物 o2 = new 鸟();
动物 o3 = new 鱼();
o1.run(); //地
o2.run(); //天
o3.run(); //水

abstract class 动物{
abstract void run();
}
class 老虎 extends 动物{
void run(){在地上跑}
}
class 鸟 extends 动物{
void run(){在天上飞}
}
class 鱼 extends 动物{
void run(){在水里游}
}

人 p1 = new 理发师();
人 p2 = new 外科医生();
人 p3 = new 演员();
p1.cut(); //剪发
p2.cut(); //开刀
p3.cut(); //停止表演

abstract class 人{
abstract void cut();
}
class 理发师 extends 人{
void cut(){剪发}
}
class 外科医生 extends 人{
void cut(){开刀}
}
class 演员 extends 人{
void cut(){停止表演}
}

项目功能:
1)子弹与敌人的碰撞
2)画分和画命

十、

Shoot射击游戏第一天:
1.创建6个对象类，并创建World类测试

Shoot射击游戏第二天:
1.创建了6个对象类的构造方法，在World类中测试

Shoot射击游戏第四天:
1.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组
2.在6个派生类中重写step()
3.画窗口

Shoot射击游戏第五天:
1.将类中的成员添加访问控制修饰符
2.设置图片属性

Shoot射击游戏第九天:
1.英雄机与敌人的碰撞:
1)借用FlyingObject中的hit()碰撞行为
借用FlyingObject中的goDead()去死行为
   在Hero中设计subtractLife()减命、clearDoubleFire()清空火力值
2)因为英雄机与敌人碰撞为定时发生的，所以在run()中调用heroBangAction()实现碰撞
在heroBangAction()中:
   遍历所有敌人，获取每个敌人，判断是否与英雄机撞上了，
若撞上了: 敌人去死、英雄机减命、英雄机清空火力值
2.检测游戏结束:
1)借用Hero的getLife()获取命
2)因为检测游戏结束为定时发生的，所以在run()中调用checkGameOver()实现检测结束
在checkGameOverAction()中:
   判断英雄机的命数是否<=0，若为true则...
3.画状态:
1)设计了四个状态常量，当前状态state变量
设计了三个静态图片，在static块中初始化
2)在paint()中设计在不同状态下画不同的图片
3)将一堆action()设计为仅在运行状态下执行
将英雄机随着鼠标动设计为仅在运行状态下执行
4)重写mouseClicked()鼠标点击事件
重写mouseExited()鼠标点击事件
   重写mouseEntered()鼠标点击事件

回顾:
1.多态:
1)意义:行为的多态、对象的多态
2)向上造型: 超类+所实现的接口
3)强转成功的条件:
3.1)引用所指向的对象就是该类型
3.2)引用所指向的对象实现了该接口/继承了该类
4)若不符合如上两个条件，则发生ClassCastException类型转换异常
建议在强转之前先instanceof来判断

正课:
1.内存管理:由JVM来管理
1)堆:
1.1)存储new出来的对象(包括实例变量)
   1.2)垃圾:没有任何引用所指向的对象，
   垃圾回收器(GC)不定时到内存中清扫垃圾，
回收过程是透明的(看不到的)，不一定一发现垃圾就立刻回收，
       调用System.gc()可以建议虚拟机尽快调度GC来回收垃圾
   1.3)实例变量的生命周期:
   创建对象时存在堆中，对象被回收时一并被回收
   1.4)内存泄漏:不再使用的对象还没有被及时的回收
   建议:不再使用的对象及时将引用设置为null
2)栈:
2.1)正在调用的方法中的局部变量(包括方法的参数)
   2.2)调用方法时，在栈中为该方法分配一块对应的栈帧，
   栈帧中存储方法中的局部变量(包括方法的参数)，
       方法调用结束时，栈帧被清除，局部变量一并被清除
   2.3)局部变量的生命周期:
   方法调用时存储在栈中，方法结束时与栈帧一并被清除
3)方法区:
3.1)存储.class字节码文件(包括方法、静态变量)
   3.2)方法只有一份，通过this来区分具体的访问对象

设计规则:
1)将所有派生类所共有的属性和行为，抽到超类中-------抽共性
2)所有派生类的行为都一样，设计为普通方法
所有派生类的行为都不一样，设计为抽象方法
3)将部分派生类所共有的行为，抽到接口中
符合既是也是原则时，使用接口
接口是对继承的单根性的扩展------------多继承

面向对象三大特征:
1.封装:
1)类:封装的是对象的属性的行为
2)方法:封装一段特定的业务逻辑功能
3)访问控制修饰符:封装的是具体的访问权限
2.继承:
1)作用:代码复用
2)超类:所有派生类所共有的属性和行为
接口:部分派生类所共有的行为
派生类:派生类所特有的属性和行为
3)单一继承、多接口实现，传递性
3.多态:
1)行为多态(所有抽象方法都是多态的)
对象多态(所有对象都是多态的)
2)向上造型、强制类型转换、instanceof
3)多态的表现形式:
3.1)重写:根据对象的不同来多态
3.2)重载:根据参数的不同来多态

面向对象课程安排:
第一天:
1.知识点:
1)什么是类？什么是对象？
   2)如何创建类？如何创建对象？如何访问成员？
2.项目:
1)创建6个对象类，并创建World类测试
第二天:
1.知识点:
1)方法的重载
   2)构造方法
   3)this
   4)null和NullPointerException
   5)引用类型之间画等号
2.项目:
1)给6个对象类添加构造方法，并测试
第三天:
1.知识点:
1)引用类型数组
   2)继承
   3)super
2.项目:
1)设计小敌机数组、大敌机数组、小蜜蜂数组、子弹数组，并测试
   2)设计超类FlyingObject，6个对象类分别继承，并测试
   3)给FlyingObject设计两个构造方法，6个对象类分别调用超类的构造方法
第四天:
1.知识点:
1)向上造型
   2)重写、重写与重载的区别
2.项目:
1)将小敌机、大敌机、小蜜蜂数组合为FlyingObject数组
   2)重写超类FlyingObject的step()方法
   3)画窗口
第五天:
1.知识点:
1)package和import
   2)访问控制修饰符
   3)final,static,static final
2.项目:
1)将类中的所有成员添加访问控制修饰符
   2)给6个对象类添加图片属性
   3)设计窗口的宽和高为常量，适当地方做修改
第六天:
1.知识点:
1)抽象方法
   2)抽象类
2.项目:
1)画对象
第七天:
1.知识点:
1)成员内部类
   2)匿名内部类
2.项目:
1)敌人入场
   2)子弹入场
   3)飞行物移动
第八天:
1.知识点:
1)接口
2.项目:
1)英雄机随着鼠标移动
   2)删除越界的飞行物
   3)设计Enemy和Award接口，小敌机、大敌机、小蜜蜂分别实现接口
第九天:
1.知识点:
1)多态:意义、向上造型、强制类型转换、instanceof
2.项目:
1)子弹与敌人的碰撞
   2)画分和画命
第十天:
1.知识点:
1)内存管理:堆、栈、方法区
2.项目:
1)英雄机与敌人的碰撞
   2)检测游戏结束
   3)画状态

1.何时用:当程序的运行结果与你的预期不同时，需要调试
2.调试方式:
1)打桩: System.out.println(数据);
2)Debug调试工具:
2.0)添加断点
2.1)四个键:
   2.1.1)F5:单步调试(会进入到方法中)
       2.1.2)F6:逐过程调试(不会进入到方法中)
       2.1.3)F7:结束方法的调试(从方法中返回)
       2.1.4)F8:直接跳到下一个断点(若后面无断点则结束调试)
   2.2)会看两个东西:
   2.2.1)会看变量
       2.2.2)添加监视

若撞上了:
1)敌人去死
2)英雄机减命、英雄机清空火力值

hero.getLife()<=0

现在的是-------只要不越界就要

要的是:
A:不越界，并且，LIFE的
B:不越界，并且，LIFE的或DEAD的(不是REMOVE的)

class Airplane{
int width;
int height;
int x;
int y;
}

Airplane a1 = new Airplane();
a1.width =;
a1.height=;
a1.x=;
a1.y=;

Airplane a2 = new Airplane();
a2.width =;
a2.height=;
a2.x=;
a2.y=;

class Aoo{
void show(){}
}
class Boo extends Aoo{
void show(String name){} //方法的重载
}

System.out.println();
System.out.println(25);
System.out.println(35.6);
System.out.println('你');
System.out.println(true);
System.out.println("Hello");

Aoo o = new Aoo();
Object oo = new Aoo();

Object

class FlyingObject extends Object{
}
class Airplane extends FlyingObject{
}

Airplane a = new Airplane();

实例变量:
1)类中，方法外
2)创建对象时存在堆中，对象被回收时一并被回收
3)有默认值
局部变量:
1)方法中
2)方法调用时存储在栈中，方法结束时与栈帧一并被清除
3)没有默认值

Aoo o = new Aoo();-------------------a=0
o.show(5);---------------------------b=5

class Aoo{
int a;
void show(int b){
int c;
   System.out.println(a); //0
   System.out.println(b); //5
   System.out.println(c); //编译错误
}
}

项目功能:
1.英雄机与敌人的碰撞
2.画状态

Debug调试:

java从入门到精通----OOP 2

java从入门到精通----OOP 2

相关推荐