Java oop 面向对象笔记

正课:

  main(){

    ...

    ...

    generate(?);

    ...

    ...

    check(?);

  }

  generate(?){

  }

  check(?){

  }

 

面向过程编程:一堆方法,调来调去

面向对象编程:以对象为核心，围绕着对象做操作

面向接口编程:面向对象的基础之上，抽接口

    复用性好、可维护性好、可扩展性好、

    移植性好......

 

面向过程:实在

面向对象:抽象

  A,B,C

  只放在一个地方更合适---抽象所在

 

晕是正常的------多练、多想

 

不晕两种情况:

1.什么都不懂

2.以为自己不晕---语法掌握

 

6天:掌握语法，知道何时用

 

讲完打飞机小游戏

------面向对象6天内容实际的应用

 

 

缺陷一:缺乏对数据的封装

缺陷二:数据和方法分离状态

 

class Emp{

   String name;

   int age;

   char gender;

   double salary;

}

 

将name,age,gender,salary----包到一种类型(Emp)中

 

public static void print(Emp emp){

  输出emp.name,emp.age,emp.salary,emp.gender

}

public static void print(String a,int b

                         char c,double d){

}

 

public static void print(String name,int age,

                         char gender,double salary){

  输出4个变量的值

}

main(){

  String name = "zhangsan";

  int age = 25;

  char gender='男';

  double salary = 5000;

  print(name,age,gender,salary);

 

  String a = "abc";

  int b = -1000000000;

  char c='国';

  double d = -10000;

  print(a,b,c,d);

}

笔记:

1.现实世界是由很多对象组成的

2.现实世界是先有对象，再抽出类

  代码中先创建类，再创建对象

3.一个类可以创建多个对象

  同一个类的多个对象，结构相同，数据不同

4.类是一种数据类型

  只能包含:

    1)描述对象所共有的特征:------变量

          属性-----静的

    2)对象所共有的行为:----------方法

          行为-----动的

5.new后，成员变量有默认值

6.创建对象语法:

    类名 引用 = new 类名();

  其中:new 类名()是在创建对象

       因对象为数据，所有声明引用来指代数据

7.访问成员变量、访问方法

  ----通过点来操作，语法:

     引用.成员变量

     引用.方法名();

8.基本类型之间画等号----在赋值

    ------身份证复印件

  引用类型之间画等号----指向同一个对象

    ------房子钥匙

9.null:空，表示没有指向对象

  若引用的值为null，则不能再进行点操作，

  否则会出现NullPointerException异常

 

 

 

 

 

 

 

 

 

 

 

class Teacher{

   String name;

   int age;

   String address;

   double salary;

  

   void teach(){

   }

   void eat(){

   }

   void sleep(){

   }

}

类中只能包含成员变量和方法

class Student{   //学生类

   String name;

   int age;

   String address;  //成员变量

 

   int eat(int num){ }

   void sleep(){ }

   void study(){ }  //方法

}

class StudentTest{   //测试类都包含main

   main(){

      Student zs = new Student();

      zs.name = "zhangsan";

      zs.age = 25;

      zs.address = "河北廊坊";

      zs.eat();

      zs.sleep();

      zs.study();

 

      Student ls = new Student();

      ls.name = "lisi";

      ls.age = 18;

      ls.address = "黑龙江佳木斯";

      ls.eat();

      ls.sleep();

      ls.study();

 

      Student ww = new Student();

   }

}

 

 

int[]   arr = new int[4];

   ----数组元素有默认值

Student zs  = new Student();

   ----成员变量就有默认值

 

 

 

步骤:

1.找对象------好多好多格子

2.抽类------class Cell{ }

3.设计类:

    1)成员变量---row行号,col列号

    2)方法

 

方法是用于操作数据的

class Cell{      //格子类

   int row;   //行号

   int col;   //列号

 

   void drop(){  //下落1个

      row++;

   }

   void moveLeft(int step){  //左移step个

      col -= step;

   }

   String getCellInfo(){  //获取格子坐标

      return row+",,,"+col;

   }

 

}

 

 

 

 

 

 

 

class Cell{

   drop();

   moveLeft();

   moveRight();

   getCellInfo();

 

   print(); -----打墙+格

}

 

格子对象没有打墙的行为

 

 

 

1.打印雇员信息

2.Cell类+成员变量

3.Cell类的方法

4.创建Cell类对象+打墙+打格

 

 

 

 

 

 

 

 

 

房子-----------对象

房子钥匙-------引用

配了/复制一把钥匙给他

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

new Student(); //创建学生类对象

new Teacher(); //创建老师类对象

 

对象是一个数据

 

创建对象

 

 

类型       引用类型变量  对象

           引用---简称

Student     zs =          new   Student();

Teacher     wkj =         new   Teacher();

ClassRoom   cr =          new   ClassRoom();

Cell        c =           new   Cell();

 

Student zs = new Student();

zs.name = "zhangsan";

 

int num = 5;

int n = num;

 

 

 

Cell c = new Cell();

c.row = 5;

c.col = 4;

 

for(int i=1;i<=20;i++){     //行号

   for(int j=1;j<=10;j++){  //列号

      if(i==c.row && j==c.col){

         System.out.println("* ");

      }else{

         System.out.println("- ");

      }

   }

   System.out.println();

}

 

 

main(){

  Cell c = new Cell();

  c.row = 5;

  c.col = 4;

  print(c); //Cell cc = c;

 

  c.drop();

  print(c);

 

  c.moveLeft();

  print(c);

}

public static void print(Cell cc){

  //双层for循环+if判断

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

i=1

  j=1/2/3/.../11

i=2

  j=1/2/3/.../11

 

- - - - - - - - - -

- - - - - - - - - -

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

//练习:

1.创建Student类，包含:

    特征: name,age,address

    行为: study(),sayHi()---输出3个变量的值

2.创建StudentTest类，包含main()方法

    main方法中:

      1)创建Student对象zs

        给变量赋值，调用方法

      2)创建Student对象ls

        给变量赋值，调用方法

 

Student zs = new Student(); //创建对象

 

 

 

 

 

 

英雄机:

  特征:

    width，height，x，y，image

  行为:

    move()，shoot()

 

小蜜蜂:

  特征:

    width, height, x, y, image

  行为:

    move()

 

 

 

 

 

 

 

 

 

类         对象

月饼模子   月饼

图纸       高楼

 

class Student{  //学生类

}

 

Student zs = new Student();

Student ls = new Student();

Student ww = new Student();

 

 

 

 

 

 

 

 

 

 

 

学员管理系统:

对象:

  学员

  老师

  教室

  课程

抽出类:

  class Student{   //学生类

  }

  class Teacher{   //老师类

  }

  class ClassRoom{ //教室类

  }

  class Course{    //课程类

  }

 

  //创建对象

  //Scanner和Random就是类

  Scanner scan = new Scanner(System.in);

  Random rand = new Random();

 

  创建对象语法:

  类名  名 = new  类名();

 

 

 

 

 

 

 

回顾:
1.类和对象
2.创建类、成员变量、方法
3.创建对象
    new Cell();
    Cell c = new Cell();
    c:引用类型变量，简称"引用"
4.访问成员变量、方法
    对象.成员变量
    对象.方法(?);
5.基本类型之间画等号----赋值
  引用类型之间画等号----指向同一个对象
6.null:空，没有指向对象
       不能点，否则空指针异常

8种基本类型:可以直接赋值
除了8种之外:
    类、接口、数组----引用类型
    new出的

1.基本:
    直接赋值
    变量装的就是确切的值
    画等号----赋值
    int num = 5;
2.引用:
    new
    变量装的是地址
    画等号----指向同一个对象


正课:
1.方法的重载
class Aoo{
   void pay(){}
   void pay(double d){}
   void pay(String s1,String s2){}
   void pay(int a,double d){}
   void pay(double d,int a){}

   void pay(int num,double dou){} //错误
   int pay(){} //错误
}

用户:

void println(){}
void printlnString(String str){}
void printlnInt(int n){}
void printlnDouble(double d){}
void printlnBoolean(boolean b){}


System.out.println();
System.out.println("HelloWorld");
System.out.println(111);
System.out.println(5.55);


java建议:
  1个文件只包含1个类

java规定:
  java中一个文件可以包含多个类，
  但是，public的类只能有1个，
  并且，public的类必须与文件名相同


语法:
1.class---成员变量、方法
2.测试类---main(){创建对象}


构造方法:
1.构造方法常常用于给成员变量初始化
2.与类同名，没有返回值类型
3.构造方法是在创建对象时被自动调用
4.若自己不写构造方法，
  则编译器默认给一个无参构造，
  若自己写了，则不再默认提供无参构造
5.构造方法可以重载

this:
1.this指代当前对象，谁调指的就是谁
2.用法:
    this.成员变量---访问成员变量
    this.方法()-----访问方法
    this()--------调构造方法




class Cell{
   int row;
   int col;
   Cell(int row,int col){
      this.row = row;
      this.col = col;
   }
   Cell(int n){
      this(n,n);
   }
   Cell(){
      this(0,0); //调两个int型参数的构造
   }
}












class Cell{
   int row;
   int col;
   Cell(int row,int col){
      this.row = row;
      this.col = col;
   }
   void drop(){
      row++;
      //this.row++;  //相当于c.row++
   }
}
main(){
   Cell cc = new Cell(2,8);
   cc.drop();

   Cell c = new Cell(5,4);//c.row=5,c.col=4
   c.drop();
   System.out.println(c.row); //6

   Cell c = new Cell(5,4);
   Cell cc = new Cell(8,2);
}









class Cell{
   int row;
   int col;
   void drop(){}
   void moveLeft(){}
   String getCellInfo(){}
   
   Cell(){
   }
   Cell(int n){
      row = n;
      col = n;
   }
   Cell(int row,int col){
      this.row = row;
      this.col = col;
   }
}

class CellTest{
   main(){
      Cell c = new Cell();
      Cell c = new Cell(5);
      Cell c = new Cell(5,4);
      Cell c = new Cell();
      c.row = 5;
      c.col = 4;
   }
}


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


   void sayHi(){
      study();
      this.study();

      System.out.println(name+",,,"+age+",,,"+address);
   }

   Student zs = new Student("zhangsan",25,"河北");
   zs.sayHi();

   Student ls = new Student("lisi",26,"黑龙江");
   ls.sayHi();


   Student(){
   }
   Student(String name,int age,String address){
      this.name = name;
      this.age = age;
      this.address = address;
      //this.name---指的是成员变量
      //name--------指的是局部变量/参数
   }
}
class StudentTest{
   main(){
      Student zs = new Student();
      Student zs = new Student("zhangsan",25,"河北");

      Student ls = new Student("lisi",26,"黑龙江");

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

      Student ls = new Student();
      ls.setInfo("lisi",18,"黑龙江");


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

      Student ls = new Student();
      ls.name = "lisi";
      ls.age = 23;
      ls.address = "黑龙江";
   }
}

声明int型数组，名为arr，包含4个元素
arr中的每一个元素都是int类型
int   [] arr = new int[4];---基本类型数组

声明Cell型数组，名为arr，包含4个元素
arr中的每一个元素都是Cell类型
Cell  [] arr = new Cell[4];---引用类型数组

int是数据类型
Cell是数据类型


int    [] arr = new int[4];
boolean[] bs = new boolean[6];
Student[] stus = new Student[100];
Random [] rs = new Random[4];
Scanner[] ss = new Scanner[8];

Hero hero = new Hero(); //英雄机



1.引用类型数组的定义
  Cell[] cs = new Cell[4];
2.引用类型数组的初始化
  1) Cell[] cells = new Cell[4]; //new数组
     cells[0] = new Cell();
     cells[1] = new Cell(2);
     cells[2] = new Cell(5,4);
     cells[3] = new Cell(2,6);
  2) Cell[] cells = {
        new Cell(),
     new Cell(1),
     new Cell(5,4),
     new Cell(2,7)
     };
  3) Cell[] cells = new Cell[]{
        new Cell(),
     new Cell(1),
     new Cell(5,4),
     new Cell(2,7)
     };
     

数组也是一种数据类型

int   []  arr  = new int [4];
Cell  []  cs   = new Cell[4];


声明int[]类型的数组，名为as，包含4个元素
as为数组的数组，里面每一个元素都是int[]类型
每一个元素，默认值为null
as[0]默认值为null
as[0]是int[]类型

int[] []  as = new int[4][];
as[0] = new int[2];
as[1] = new int[4];
as[2] = new int[2];
as[3] = new int[5];


int[][] as = new int[3][];
as[0] = new int[4];
as[1] = new int[4];
as[2] = new int[4];
简写:
int[][] as = new int[3][4];
for(int i=0;i<3;i++){   //行
   for(int j=0;j<4;j++){  //列
      as[i][j] = 100;
   }
}

练习:------全部熟练做下来
1.创建Cell型数组，包含4个元素
  分别对每一个数组元素赋值
2.创建Cell型数组，直接对每一个元素赋值--{ }
3.创建int[]型数组arr，包含3个元素
  第1个元素又包含2个元素
  第2个元素又包含3个元素
  第3个元素又包含2个元素
  将arr的第2个元素中的第1个元素赋值为100
4.创建int[]型数组，为3行4列
  双层循环输出每一个元素的值


1.找对象-----7种图形对象
2.抽类
    class T{}
    class J{}
    class O{}
    class S{}
    class Z{}
    class I{}
    class L{}
3.设计类中的成员变量(特征)、方法(行为)
    class T{
       Cell[] cells;
       T(int row,int col){
          cells = new Cell[4];
       cells[0] = new Cell(row,col);
       cells[1] = new Cell(row,col+1);
       cells[2] = new Cell(row,col+2);
       cells[3] = new Cell(row+1,col+1);
       }

       void drop(){   //下落一个
          for(int i=0;i           cells[i].row++;
       }
       }
       void moveLeft(){ //左移一个
          for(int i=0;i           cells[i].col--;
       }
       }
       void moveRight(){ //左移一个
          for(int i=0;i           cells[i].col++;
       }
       }
       void print(){  //输出4个格子的坐标
          for(int i=0;i           String s = cells[i].getCellInfo();
          System.out.println(s);
          
          System.out.println(cells[i].getCellInfo());
       }
       }
    }




    class J{
       Cell[] cells;
       J(int row,int col){
          cells = new Cell[4];
       cells[0] = new Cell(row,col);
       cells[1] = new Cell(row,col+1);
       cells[2] = new Cell(row,col+2);
       cells[3] = new Cell(row+1,col+2);
       }


    }





    main(){
       T t = new T(1,5);
    }




















int[][] as = new int[3][];
as[0] = new int[4];
System.out.println(as[0][0]);//0




System.out.println(as[0][0]);//错误














as[1][2] = 100;


给as中第2个元素的第3个元素赋值为100



as[0]---int类型
int[] as = new int[4];













//1给arr[0]赋值，2给arr[1]赋值......
int[] arr = {
   1,
   2,
   3,
   4
};
//1给cs[0]赋值，2给cs[1]赋值
Cell[] cs = {
   new Cell(),
   new Cell(5),
   new Cell(5,4),
   new Cell(3,7)
};
System.out.println(cs[1].row);








Cell[] cs = new Cell[4];
cs[0] = new Cell();
cs[1] = new Cell(5,4);
cs[2] = new Cell(3,2);
cs[3] = new Cell(8);






cs[4] = new Cell();  //越界



System.out.println(cs[0].row);  //0










cs[0]=null cs[1]=null ......
Cell[] cs = new Cell[4];
cs[0].row = 5;  //空指针异常









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

Cell[] cs = new Cell[4]; //new是在创建数组
cs[0]为Cell类型
cs[0] = new Cell();  //new是在创建Cell对象












new之后，arr中每个元素都是0
int[] arr = new int[4];
boolean[] bs = new boolean[4];

new之后，cs中每个元素都是null
Cell[] cs = new Cell[4];
Student[] ss = new Student[4];





 

回顾:

1.方法的重载

    签名:方法名+参数列表

    重载:同一个类中，方法名相同，参数列表不同

2.构造方法

    常常初始化成员变量

    与类同名，没有返回值类型

    创建对象(new)时被自动调用

    自己不写，默认给一个无参的，自己写则不给了

    可以重载

3.this:指代当前对象，哪个对象调指的就是哪个对象

    this.成员变量

    this.方法()

    this()-------调用构造方法

  类中的方法，只要用到了成员变量，

  前面默认都有this

4.引用类型数组

    int[]    arr   = new int[4];

    Cell[]   cells = new Cell[4];

    int[][]  cells = new int[4][];

 

 

 

正课:

1.继承财产:

    钱不用自己挣，也能用(花)

  继承皇位:

    江山不用自己打，也是你的

  继承工作:

    工作不用自己找，也是你的

  程序中的继承:

    代码不用写，也能用

 

 

继承:避免代码重复

     父类中包含所有子类公有的数据

     子类中包含子类所特有的数据

 

Student zs = new Student();

zs.name/age/address/eat()/sleep()---父类

zs.className/study()----子类

 

Teacher wkj = new Teacher();

wkj.name/age/address/eat()/sleep()---父类

wkj.salary/teach()

wkj.className/study()----不可以

 

class Person{     //父类

   String name;

   int age;

   String address;

   char sex;

   void eat(){}

   void sleep(){}

}

 

class Student extends Person{   //子类

   String className;

   void study(){}   //学习

}

class Teacher extends Person{   //子类

   int salary;

   void teach(){}   //授课

}

class Doctor extends Person{    //子类

   String level;  

   void cut(){}    //开刀

}

 

 

class Tetromino{   //图形类---父类

   //公有的数据

   Cell[] cells;

   void drop(){}

   void moveLeft(){}

   void moveRight(){}

   void print(){}

}

 

class T extends Tetromino{

   //特有的数据

   T(int row,int col){

     

   }

}

class J extends Tetromino{

}

class O extends Tetromino{

}

 

 

class 飞行物{

   int width;

   int height;

   int x;

   int y;

   void move(){}

}

class 英雄机 extends 飞行物,A{   //错误的

}

class 小蜜蜂 extends 飞行物{

}

class 小飞机 extends 飞行物{

}

class 子弹 extends 飞行物{

}

class A{

}

 

 

 

 

java继承有传递性:

class A{

  int aa;

}

class B extends A{

  int bb;

}

class C extends B{

  int cc;

}

C c = new C();

c.cc/bb/aa

 

B b = new B();

b.aa/bb

 

A a = new A();

a.aa

 

 

 

class Tetromino{

   Cell[] cells;

   Tetromino(){

      cells = new Cell[4];

   }

   void drop(){}

   void moveLeft(){}

   void moveRight(){}

   void print(){}

}

class T extends Tetromino{

   T(){

      this(0,0);

   }

   T(int row,int col){

      cells[0] = new Cell(row,col);

      cells[1] = new Cell(row,col+1);

      cells[2] = new Cell(row,col+2);

      cells[3] = new Cell(row+1,col+1);

   }

}

class J extends Tetromino{

}

 

 

 

 

 

 

class A{

   A(){

   }

   A(int num){

      输出222

   }

}

class B extends A{

   B(){

      super(5);

      输出111

   }

}

 

打墙+打星方法:

  Tetromino父类---

     T

     J

 

 

  TetrominoTest测试类---放在此处

 

 

 

 

 

class Cell{

  

}

class CellTest{

   main(){

      Cell c = new Cell(5,4);

      printCell(c);//Cell cc = c;

   }

   printCell(Cell cc){  //打墙+打格

      for(){

         for(){

         if(i==cc.row && j==cc.col){

            *

         }else{

            -

         }

     }

      }

   }

}

 

 

main(){

   T t = new T(0,0);

   printCell(t);

}

public static void printCell(T tt){ //打墙+格

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

      for(int j=0;j<10;j++){

         boolean flag = true; //默认打-

     for(int k=0;k<4;k++){

         if(i==tt.cells[k].row && j==tt.cells[k].col){

            flag = false;  //不打-

            System.out.print("* ");

            break;

         }

     }

     if(flag){

         System.out.print("- ");

     }

      }

      System.out.println();

   }

}

以前打1个Cell(星),

 

 

 

如果不打*，肯定打-吗

if(i==? && j==?){

   System.out.print("* ");

}else{

   System.out.print("- ");

}

 

-----------

----***----

-----*-----

 

 

 

 

 

1.JVM内存管理

2.继承

 

java中,调一个方法，就给该方法分配一个"栈桢"

栈桢中存的就是局部变量

方法调用结束，栈桢消失，局部变量跟着消失

class Cell{

 

  int add(int num1,int num2){  //求和

   int num = num1+num2;

   return num;

  }

 

}

 

 

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

   for(int j=0;j<10;j++){

      boolean flag = true;

      for(int k=0;k<4;k++){

        if(i==tt.cells[k].row&&j==tt.cells[k].col){

        System.out.print("* ");

        flag = false;

        break;

     }

      }

      if(flag){

         System.out.print("- ");

      }

   }

   System.out.println();

}

 

T是图形

class T extends Tetromino{

}

学生是人

class Student extends Person{

}

 

 

 

 

老虎是动物

class Animal{   //动物类

}

class Tiger extends Animal{    //老虎类

}

 

动物是动物

Animal a = new Animal();

老虎是老虎

Tiger t = new Tiger();

老虎是动物

Animal a = new Tiger();

 

父类类型引用指向子类的对象---向上造型

 

 

 

动物是老虎--------------语义不通

Tiger t = new Animal();  //错误

 

 

 

Person p = new Student(); //向上造型

Person p = new Teacher();

Person p = new Doctor();

 

Tetromino tt = new T();

Tetromino tt = new J();

Tetromino tt = new O();

Tetromino tt = new I();

Tetromino tt = new L();

Tetromino tt = new S();

Tetromino tt = new Z();  //向上造型

 

 

 

一切以对象为中心

 

main(){

   T t = new T(0,0);

   printTetromino(t.cells); //不建议

   printTetromino(t); //建议

}

printTetromino(Tetromino t){ //传的对象

   t.cells

   t.drop()

   t.moveLeft()

   t.moveRight()

   t.print()

}

printTetromino(Cell[] cs){  //传的对象的数据

}

 

练习:

1.创建父类Aoo，包含a,show()

2.创建子类Boo继承Aoo，包含b,say()

3.创建测试类Test，在main()中:

  1)创建父类对象，访问成员---?

  2)创建子类对象，访问成员---?

  3)向上造型，访问成员-------?

 

 

向上造型:父类引用指向子类对象

         只能点出来父类的成员

意义何在?

 

 

 

生产水果:

 

Apple createApple(){

  return new Apple();

}

Banana createBanana(){

  return new Banana();

}

Fruit createFruit(){   //生成水果

 

  Fruit f = new Apple();

  return f;

 

  return new Apple();

 

 

 

  return new Banana();

  return new Pair();

}

 

main(){

  Tetromino t = new T(2,5);

  printTetromino(t);  //Tetromino tt = t;

}

void printTetromino(Tetromino tt){

  tt.cells-----相当于t.cells

  Cell[] cells = tt.cells; //获取4个格子

}

class Tetromino{

  Cell[] cells;

  Tetromino(){

    this.cells = new Cell[4];  //this指t

  }

  void drop(){}....

}

class T extends Tetromino{

  T(int row,int col){

    super();

    this.cells[0] = new Cell(row,col);

    this.cells[1] = new Cell(row,col+1);

    this.cells[2] = new Cell(row,col+2);

    this.cells[3] = new Cell(row+1,col+1);

  }

}

 

 

 

1.堆、栈、方法区-----了解

2.继承

  构造子类之前先构造父类----super()

  向上造型

 

 

 

 

 

 

 

 

 

 

 

 

 

class J extends Tetromino{

}

 

 

 

回顾:

1.堆、栈、方法区

2.继承:避免代码重复

       子类 extends 父类

       子类具有本类成员以及父类成员

  new 子类();----调子类构造(之前，先调父类)

  super();

3.向上造型:父类引用指向子类对象

    注意:能点出来什么，看类型

 

main(){

   Tetromino t = new T();

   printTetromino(t);

 

   Tetromino j = new J();

   printTetromino(j);

}

void printTetromino(Tetromino tt){

}

 

正课:

 

main(){

   Student zs = new Student();

   zs.name = "zhangsan";

   zs.age = 25;

   zs.address = "黑龙江";

   zs.className = "JSD1407";

   zs.sayHi();----name,,age,,address,className

 

   Teacher wkj = new Teacher();

   wkj.name = "wangkejing";

   wkj.age = 18;

   wkj.address = "河北廊坊";

   wkj.salary = 5000;

   wkj.sayHi();----name,age,address,salary

 

 

   Student zs = new Student();

   print(zs);

   Teacher wkj = new Teacher();

   print(wkj);

  

   Person p = new Student();

   print(p);

 

   Person pp = new Person();

   print(pp);

}

 

public static print(Person per){

   per.sayHi();  //正确的---Student类的

               

}

 

方法的重写:发生两个类中，并且是子父的关系

           子类方法与父类方法签名相同时，

        我们说，子类重写了父类的方法

 

当方法被重写时，调哪个方法看对象

 

class Person{

   String name;

   int age;

   String address;

   void sayHi(){

      System.out.println

       (name+",,"+age+",,"+address);

   }

}

class Student extends Person{

   String className;

   void sayHi(){

      System.out.println

       (name+",,"+age+",,"+address+",,"+className);

   }

}

class Teacher extends Person{

   int salary;

   void sayHi(){

      System.out.println

       (name+",,"+age+",,"+address+",,"+salary);

   }

}

 

 

 

class Aoo{

  int a;

  void show(){

     111

  }

}

class Boo extends Aoo{

  int b;

  void show(){ --在Aoo的show()方法基础之上再做事

     super.show();---调父类的show()方法

     222

  }

}

 

main(){

   T t = new T();

   t.print();-------打印4个格子坐标

}

class Tetromino{

   void print(){----打印4个格子的坐标(问好)

   }

}

class T extends Tetromino{

   void print(){

      System.out.println("i am a t");

      super.print();

   }

}

class J extends Tetromino{

}

 

this:------------本类

this.成员变量

this.方法()

this()

super:-----------父类

super.成员变量

super.方法()

super()

 

 

重写(override)和重载(overload)的区别------常见面试题

重载:

  在一个类中，方法名相同，参数列表不同

重写:

  在两个类中，并且是子类和父类的关系，签名相同

 

 

 

 

 

重载:编译时----.java到.class的过程

               内存没东西---只看语法对不对

 

重写:运行时----jvm加载.class并运行.class的过程

               内存才有东西

 

堆、栈、方法区------jvm分配的内存

 

 

 

重载时看类型，重写时看对象

1.创建Aoo类，包含show()，输出111

2.创建Boo类继承Aoo类，重写show()，输出222

3.创建Coo类，包含:

    t(Aoo o){ 输出333   o.show(); }

    t(Boo o){ 输出444   o.show(); }

4.测试类，main()方法中:

    Coo c = new Coo();

    Aoo o = new Boo();

    c.t(o);------问输出结果????

                   333 222

 

建议

域名反写   项目名称       模块名称

com.tarena.studentmanager.course.类名

 

 

 

 

 

package a.b.c.d.e; //声明包

public class Test{

}

 

 

//a.Test----全局限定名

a.b.c.d.e.Test o = new a.b.c.d.e.Test();

 

import a.b.c.d.e.Test; //声明类、引入类

Test t = new Test();   //创建对象

 

 

import java.util.Arrays;

import java.util.Random;

import java.util.Scanner;

 

import java.util.*;---------不建议

 

 

 

 

 

 

Scanner scan = new Scanner(System.in);

 

java.util.Scanner scan = new java.util.Scanner(System.in);

 

 

 

同一个包中的类之间，需要import吗?

 

全局限定名=包名+类名

 

main(){

  Aoo o = new Boo();

  o.show();-----------Boo

 

  Boo o = new Boo();

  o.show();-----------Boo

 

  Aoo o = new Aoo();

  o.show();-----------Aoo

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

1.重写------------------

2.package,import

3.访问修饰符public......

4.static,final

 

 

 

去银行取钱:

密码----------密码正确与否---

              密码是多少-----不知道

class Bank{

   private int password;  //密码----藏起来

   public boolean checkPwd(int pwd){----放开

      if(pwd == password){

         return true;

      }

      return false;

   }

}

 

 

 

 

 

 

//单例模式

class Aoo{

  private Aoo(){

  }

  void show(){

     Aoo o = new Aoo(); //正确

  }

}

class Boo{

  void show(){

     Aoo o = new Aoo();  //错误

  }

}

 

 

实例化:创建对象的过程

实例:实际的例子-----------对象

 

class Aoo{

   int a;-------------属于对象

   static int b;------属于类

   void show(){

     b++;

   }

}

 

成员变量:

  1)实例变量-----不用static修饰的

  2)静态变量-----static修饰的

 

何时用静态变量，何时用实例变量

class Customer{ //帐户类

   String customerName;  //帐户名称

   String customerPwd;   //帐户密码

   static double poir;          //利率

}

实例变量:属于对象，一个对象有一份

静态变量:属于类，所有对象公用这一份

 

Customer zs = new Customer();

zs.customerPwd = 123456;

 

Customer ls = new Customer();

ls.customerPwd = 654321;

 

 

 

类的方法中，常常需要对对象的实例变量操作

类的非静态方法，默认有个隐式的this

类的静态方法，没有隐式的this的

class Cell{

   int row;  //属于对象---实例变量

   int col;  //属于对象---实例变量

   static int num;

   static void show(){

      row++;   //错误的

      num++;   //正确的

 

      Cell c = new Cell();

      c.row = 5;

   }

   void drop(){

      this.row++;

   }

   void moveLeft(){

      this.col--;

   }

 

}

main(){

  Cell c1 = new Cell(2,5);

  c1.drop();  //3,5

 

  Cell c2 = new Cell(6,7);

  c2.drop();  //7,7

}

 

 

非静态方法:---有隐式this

  可以直接访问静态变量和实例变量

  需要访问实例变量时用

 

静态方法:-----没有隐式this

  只能直接访问静态变量，不能直接访问实例变量

  不需要访问实例变量时，只需对参数操作即可

 

何时用静态方法，何时用非静态方法:

 

 

 

 

静态方法，只与参数相关，与实例变量有关

Arrays.sort(arr);

Math.random();

Math.sqrt(25);

 

 

 

 

何时用静态代码块:

  一般用于加载静态资源(图片、音频、视频)

 

 

 

 

小结:

1.重写

  重写与重载的区别

2.package,import

3.访问修饰符:public,private,protected,默认

 

 

 

回顾:

1.重写(override):

    子类与父类方法签名完全相同

  重写与重载的区别

2.package,import

3.public,private,protected,默认

4.static:

    成员变量:----静态变量

    方法:没有隐式的this，所以不能直接访问实例变量

    块:

  final:意为不可变

    变量

    方法

    类

 

 

正课:

1.抽象类、抽象方法

2.接口

 

 

class Test{

   public static void main(String[] args){

      Cell c = new Cell(5,2);

      Test.printCell(c);

 

      Test t = new Test();

      t.show();

   }

   public void show(){

   }

   public static void printCell(Cell c){

   }

}

 

 

 

 

java是不建议空方法的

 

抽象类能创建对象吗??????

 

Shape s = new Shape(); ------错误

abstract class Shape{    //抽象类(不完整)

   int c;  //周长

   abstract double area(); //抽象方法(不完整)

}

abstract class Square extends Shape{   //方形类

}

class Circle extends Shape{   //圆形类

   double area(){  //重写--变不完整为完整

      return 0.0796*c*c;

   }

}

Circle cir = new Circle();

 

 

 

abstract class 汽车{

   abstract void 制造发动机();

}

 

class 汽车{

   void 制造发动机(){

   }

}

new汽车对象

 

 

1.抽象方法:由abstract修饰

           只有方法的定义，没有方法体的

2.抽象类:由abstract修饰

         可以包含抽象方法，也可以包含普通方法

3.包含抽象方法的类，必须是抽象类

  类中没有抽象方法，也可以将类声明为抽象类

4.抽象类不能被实例化 Shape s = new Shape();//错误

5.抽象类一般需要被继承:

  1)子类也声明为抽象类

  2)子类重写抽象类中所有抽象方法---首选

6.抽象类的意义:

  1)封装子类公用的成员

    为子类提供一个公共的类型

  2)定义抽象方法，由子类来做不同的实现，

    但入口(方法名)是一样的

 

 

 

 

 

 

//声明一个数组，包含各种图形对象

//获取最大最积

 

数组-1个圆形对象，1个方形对象，1个三角形对象

通过算法，求这3个对象的最大面积

 

Shape s = new Shape(); //new Shape对象--错误

Shape s = new Circle();

Shape s = new Square();

 

Shape[] shapes = new Shape[3];//创建Shape数组

shapes[0] = new Circle(1);

shapes[1] = new Square(1);

shapes[2] = new Circle(1.2);

int maxArea = shapes[0].area();

for(int i=1;i

   double area = shapes[i].area();

   if(area > maxArea){

      maxArea = area;

   }

}

System.out.println("maxArea=" + maxArea);

 

 

 

abstract class Shape{   //抽象类(不完整)

   int c;   //周长

   abstract double area();  //抽象方法(不完整)

}

class Square extends Shape{   //方形类

   Square(double c){

      this.c = c;

   }

   double area(){  //重写

      return 0.0625*c*c;

   }

}

class Circle extends Shape{   //圆形

   Circle(double c){

      this.c = c;

   }

   double area(){  //重写

      return 0.0796*c*c;

   }

}

 

 

 

 

 

 

 

 

 

 

 

 

 

问:Tetromino类是为了创建对象吗?

俄罗斯方块游戏中：

  Tetromino tetri = new Tetromino(); //没有意义

 

abstract class Tetromino{

   Cell[] cells;

   void drop(){}

   void moveLeft(){}

}

class T extends Tetromino{

}

class J extends Tetromino{

}

class O extends Tetromino{

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

abstract 飞行物类:

  width,height

  x,y

  img

  abstract move();

 

英雄机----继承飞行物

小蜜蜂----继承飞行物

小飞机----继承飞行物

子弹------继承飞行物

 

 

只要遵守了USB规范，就能将设备插入到电脑上

只要遵守了国家盖楼房的标准，这个楼就能卖

 

只要遵守了这个规范，就能干某件事

 

重写:

  方法名同，参数列表同

  子类的访问权限大于或等于父类的

 

 

 

 

 

 

1.接口就是一个标准、一个规范

2.接口中只能包含常量和抽象方法

3.接口不能被实例化

    接口 引用 = new 实现类(); //向上造型

4.类实现接口，必须将所有抽象方法都实现

5.类可以实现多个接口，用逗号分隔

  若类又继承父类又实现接口，需先继承后实现

6.接口与接口之间可以继承

 

 

 

 

 

 

 

1.创建接口Inter，包含:

    常量: PI(完整写法)，NUM(简便写法)

    方法: Show(完整写法)，Say(简便写法)

2.创建接口Inter1，包含a()

  创建接口Inter2，包含b()

  创建接口Inter3，继承Inter1，并包含c()

  创建抽象类Aoo，包含普通方法d()，抽象方法e()

3.创建类Boo,实现Inter3,包含m()方法,实现抽象方法

  创建类Coo,实现Inter1,Inter2，实现抽象方法

  创建类Doo,继承Aoo并实现Inter1和Inter2

4.在main()方法中:

  1)创建Inter对象o1-------???

  2)输出Inter中的PI的值-------Inter.PI

  2)Inter3引用指向Boo对象---??能调什么方法

      Inter3 o = new Boo();

      o.a();

      o.c();

 

 

 

 

 

想开一个工商银行(对象)

工商银行类---------遵守标准(工行接口)

 

1.制定标准---接口

  interface UnionPay{   //银联接口

     void 存钱();

     void 取钱();

     void 改密码();

     void 查余额();

  }

  interface ICBC extends UnionPay{   //工行接口

     void 在线支付();

  }

  interface ABC extends UnionPay{    //农行接口

     void 支付电话费();

  }

2.遵守标准----类

  class ICBCImpl implements ICBC{  //工行类

     public void 存钱(){}

     public void 取钱(){}

     public void 改密码(){}

     public void 查余额(){}

     public void 在线支付(){}

    

  }

  class ABCImpl implements ABC{    //农行类

     public void 存钱(){}

     public void 取钱(){}

     public void 改密码(){}

     public void 查余额(){}

     public void 支付电话费(){}

  }

3.main(){

     ICBCImpl icbc1 = new ICBCImpl();//开了1个工行

     icbc1.存钱()/取钱()/改密码()/查余额()/在线支付()

 

     ABCImpl abc1 = new ABCImpl();

 

     ICBC i = new ICBCImpl(); //向上造型

  }

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

interface IInter{

  public static final int NUM = 5;

  int NUMNUM; //默认public static final的

 

  public abstract void show();

  void sayHi();//默认public abstract

}

interface IInter2{

  void sayHello();

}

class Abc{

}

class Coo extends Abc implements IInter1,IInter2{

}

 

 

 

 

 

class Boo implements IInter,IInter2{

  public void show(){}

  public void sayHi(){}

  public void sayHello(){}

}

 

 

          实现

class Aoo implements IInter{  //遵守标准

  public void show(){

  }

  public void sayHi(){

  }

}

 

 

 

 

 

 

 

接口:

1.电脑厂商，做一个USB接口(规范、标准)

  外部设备厂商，遵守USB接口(规范、标准)

   (鼠标、摄像头、键盘......)

2.国家制定盖楼房的标准

  开发商遵守这个标准

3.国家制定家具的标准

  家具厂商遵守这个标准

 

 

 

 

 

 

 

回顾:
0.抽象方法:只有方法的定义，没有方法体
1.抽象类:不能被实例化
2.接口:只能常量和抽象方法
    向上造型------多态
    抽象类 引用 = new 子类();
    接口   引用 = new 实现类();
3.接口和抽象类的区别---一会讲


正课:
1.多态
2.内部类
3.面向对象的汇总





main(){
   Shape[] shapes = new Shape[30000];
   shapes[0] = new Circle(2);   //向上造型
   shapes[1] = new Square(2);
   shapes[2] = new Six(2);
   maxArea(shapes);

   Shape s1 = new Circle();
   Shape s2 = new Square();
   Shape s3 = new Six();

}
public static void maxArea(Shape[] shapes){
   shapes[0].area();
}

class Six extends Shape{
   Six(double c){
      this.c=c;
   }
   double area(){
      return 0.0721*c*c;
   }
}



interface CCB extends UnionPay{
   void 支付燃气费();
}
class CCBImpl implements CCB{
   public void 支付燃气费(){}
   ....
   ....
   ....
   ....
}
UnionPay up = new CCBImpl(); //向上造型





int[] arr = {3,345,34,5,23,75};
Arrays.sort(arr);

Student[] stus = new Student[4];
....分别给每个元素赋值
Arrays.sort(stus); //语法可以的
                   //运行后报错
接口的概念-----只要遵守了标准，就能干某件事


cut()方法----多态的
cut是多态的
一个类型的引用在指向不同的对象时有不同的功能
1.理发师-------cut剪发
  外科医生-----cut开刀
  演员---------cut停止表演

人 a = new 理发师();
人 b = new 外科医生();
人 c = new 演员();     //向上造型
a.cut();-----剪发
b.cut();-----开刀
c.cut();-----停止表演

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


同一个对象，造型成不同的类型时，具有不同的功能
我的多态的
2.讲师--------------授课
  儿子他妈----------打他
  我妈的女儿--------发火
  老公我老婆--------打他、发火

讲师 a       = new 我();
儿子妈妈 b   = new 我();
老公的老婆 c = new 我();  //向上造型

a.授课();
b.打他();
c.揍他();
c.发火();

class 我 implements 讲师，儿子妈妈，老公的老婆{
   public void 授课(){}
   public void 打他(){}
   public void 揍他(){}
   public void 发火(){}
}
interface 讲师{
   void 授课();
}
interface 儿子妈妈{
   void 打他();
}
interface 老公的老婆{
   void 揍他();
   void 发火();
}



编译器认为: 子类小，父类大
            实现类小，接口大
达内职员 a = new 讲师();
技术顾问 b = new 讲师();

大到小，需要强转
讲师 aa = (讲师)a;
讲师 bb = (讲师)b;

aa.所有讲师类具有的成员




达内职员 a = new 项目经理();
讲师 aa = (讲师)a;          //异常的
项目经理 aa = (项目经理)a;  //正确的


技术顾问 a = new 讲师();
讲师 aa = (讲师)a;     //正确

达内职员 a = new 讲师();
技术顾问 aa = (技术顾问)a;


达内职员 a = new 讲师();
if(a instanceof 技术顾问){  -----true
   技术顾问 aa = (技术顾问)a;
}
if(a instanceof 项目经理){  -----false
   项目经理 aa = (项目经理)a;
}





语法:
  引用 instanceof 数据类型 ------boolean

小结:
  强转成功与否，看对象



练习:
1.创建接口Inter，包含a()
  创建抽象类Abs，包含b()
  创建类Aoo，继承Abs，实现Inter，包含num变量
  创建类Boo，继承Abs，包含num2变量
2.main()方法中:
  1)Abs引用指向Aoo对象,Inter引用指向Aoo对象
    两个引用分别点后，看点到什么东西
  2)Abs引用指向Aoo对象，
    将引用强转为Aoo类型-------???
    将引用强转为Inter类型-----???
    将引用强转为Boo类型-------???---错误
  3)如上2)中的强转错误的是哪句?
    通过instanceof避免那个错误，即判断后再转
    if(引用 instanceof Boo){
       Boo b = (Boo)引用;
    }

interface UnionPay{  //银联接口
   void 存();
   void 取();
}
interface ICBC extends UnionPay{  //工行接口
   在线支付();
}
interface ABC extends UnionPay{  //农行接口
   支付电话费();
}
class ICBCImpl implements ICBC{  //工行实现类
   public void 存(){}
   public void 取(){}
   public void 在线支付(){}
}
class ABCImpl implements ABC{  //农行实现类
   public void 存(){}
   public void 取(){}
   public void 支付电话费(){}
}

需求: 农行ATM系统，要求只有农行卡才能支付话费
分析:
1.ATM对象
2.抽ATM类
3.设计ATM类的数据和行为

class ABCATM{   //农行ATM机系统
   UnionPay card;   //银联卡
   void insertCard(UnionPay card){  //插卡
      this.card = card;
   }
   void payPhone(){   //支付话费功能
      //判断卡是否是农行卡
      if(card instanceof ABCImpl){
         ABCImpl abc = (ABCImpl)card;
     abc.支付电话费();
      }else{
         System.out.println
          ("卡类型不对，不能支付话费");
      }
   }
}
main(){
   ABCATM atm = new ABCATM();  //农行ATM机对象
   UnionPay card = new ABCImpl(); //银联卡-农行卡
   //UnionPay card = new ICBCImpl();//工行卡
   atm.insertCard(card);
   atm.payPhone();

   if(card instanceof ABCImpl){}
}



1.内部类:一个类只被一个类使用，对外不可见
         eg:宝宝是由妈妈来创造的
2.内部类对象通常只在外部类中被创建
  内部类中可以直接访问外部类的所有成员


class Mama{     //外部类
   String name;
   Mama(String name){
      this.name = name;
   }
   Baby create(){   //创建Baby对象
      return new Baby();
   }
   class Baby{  //内部类
      void mamaName(){
     //this指当前对象，下面错
     System.out.println(this.name);
     //Mama.this指当前外部类对象，下面对
     System.out.println(Mama.this.name);
     //默认有Mama.this，下面对
         System.out.println(name);
      }
   }

}


匿名内部类:
1.何时用:
    有一个类(子类或实现类)，
    只需要创建一个对象，
    对象创建完，这个类就没有意义了


class Test{
   main(){
      //创建实现类的对象
      Inter1 o = new Inter1(){
         实现类的成员
      }; //正确

      Inter2 o = new Inter2(){
      }; //错误，{}中尚未重写show()方法
      
      //创建实现类对象，名为o
      Inter2 o = new Inter2(){
         public void show(){
         System.out.println("HiHiHi");
     }
      };
      o.show();

   }
}
interface Inter2{
   void show();
}
interface Inter1{
}

小结:
面向对象3大特征:
1.封装:保证安全
    类-------封装数据、行为
        作为一个整体操作
    方法-----封装功能的实现
        隐藏实现的细节
    访问修饰符----控制访问权限
        保证数据的安全
2.继承:实现代码的重用
    extends
3.多态:多种形态，在继承的基础之上
       提高可维护性、可扩展性
    1)一个类型指向不同对象，有不同的实现
    2)同一个对象造型成不同类型时，有不同的功能





作业:
          swing的侦听中用
1.内部类，匿名内部类----实际应用中应用率不高
  class Mama{
     class Baby{
     }
  }
  问:编译后生成几个.class
2.课后作业
3.运行Shoot游戏，了解需求
  看看数据模型(类、接口)























interface Inter{
}
main(){
   //创建接口对象，错误的
   Inter o = new Inter();  //接口不能被实例化

   //创建接口的实现类的对象---实现类省略了
   Inter o = new Inter(){
      实现类的成员
   };
}

//如下为不使用匿名内部类的方式
interface Inter{
}
class Aoo implements Inter{
   
}
main(){
   Aoo o = new Aoo();
}
















class Mama{   //妈妈类
   class Baby{
   }
}






class Test{
   main(){
      Baby b = new Baby();
   }
}
cass B{
   void show(){
      Baby b = new Baby();
   }
}






回顾:
1.多态
    1)一个引用指向不同对象，有不同的实现
    2)一个对象造型成不同类型，有不同的功能
  强制类型转换成功如下两种情况:
    1)引用指向的对象就是该类型
    2)引用指向的对象实现了该接口
  instanceof来避免强制转换错误
2.内部类:
    类(外部类)中套类(内部类)
    内部类一般在外部类中创建
    内部类一般只让外部类用，别的类不能用
    内部类可以直接访问外部类的所有成员
  匿名内部类:
    一个类(子类或实现类)
    只需要创建一个对象
    Inter i = new Inter(){ //实现类的对象
       重写接口中的所有抽象方法
    };
    new Inter(){
    };

正课:
1.整个软件
  1)了解需求-----Shoot游戏
  2)分析对象:
      英雄机
      敌机
      小蜜蜂
      子弹
  3)设计类:
      Hero---------英雄机
      Airplane-----敌机
      Bee----------小蜜蜂
      Bullet-------子弹
      FlyingObject-飞行物-------父类
      Enemy--------得分-----接口
      Award--------奖励---------接口
      ShootGame----射击游戏
   4)编码:







java建议:
1.成员变量私有private
2.方法公有public

java不建议使用默认访问修饰



1.设计了8个类
2.填充了8个类的成员变量(实例变量、静态变量)
3.ShootGame----宽高，图片，static块
4.做了4个对象类的构造方法进行数据的初始化













窗体界面-----java提供了API

JFrame类-----画框
JPanel类-----画板









3个月----
   前期了解需求、设计-----至少2个月时间
   编码、测试-------------将近1个月时间

需求分析说明书.doc
概要设计说明书.doc----数据库设计.doc
详细设计说明书.doc

编码
测试
打包部署---服务器---发布，上线


国内很多公司都是后补文档

需求人员----只懂业务，不懂编码
需求人员----既懂业务，也懂编码



main(){
   a();----//输出结果不对
}
a(){
   System.out.println("111");
   T t = new T(); //......
   System.out.println("222");
}

class T{
  T(){
     System.out.println("333");
     int x = ???;
     int y = ???;
     System.out.println(x);
     System.out.println(y);
  }
}



调step()方法----定时触发(定时器)

每10毫秒让飞行物走一步







提高题:
1.删除数组中的第1个元素
2.数组追加



算法-----数组的操作
FlyingObject[] flyings;  //敌人数组
Bullet[] bullets;   //子弹数组

Bullet b = new Bullet(10,20);
bullets = Arrays.copyOf(bullets,bullet.length+1);











算法1:发射子弹---子弹入场
1)子弹由英雄机发射----Hero中Shoot()--Bullet[]



--数组的追加
0   1   2   3   4    5
b   b   b   b   null null

假设: 
bullets----4个元素
bs---------2个元素--b1和b2
System.arrayCopy(bs,0,bullets,?,bs.length);


0   1   2   3
b   b   b   null
bullets----3个元素
bs---------1个元素
扩容后bullets----4个元素



swing-----
  事件---------发生了那么一个事
  事件处理-----发生那个事后怎么办

鼠标移动事件------英雄机跟着移动
鼠标点击事件------程序开始
鼠标移出事件------暂停
鼠标移入事件------继续



侦听Listener

面板去侦听鼠标事件


this.addMouseMotionLister(?);
?------MouseMontionLister(interface)

MouseMotionLister l = new MoouseMotionLister(){
   mouseDrag(); ---鼠标托拽
   mouseMove(); ---鼠标移动
};

class MouseAdapter implements MouseMotionLister{
   mouseDrag(){}  //空实现
   mouseMove(){}  //空实现
}

MouseAdapter l = new MouseAdaper(){
   public mouseMove(){
      //移动
   }
};



算法:----子弹打敌人
1.FlyingObject------shootBy(Bullet b){}
2.当子弹打到敌飞机以及蜜蜂后:
  1)敌人消失---从数组中删除
  2)英雄机加分或得奖励

分析:
1.每一个子弹都要和敌人比
  若shootBy()为true:
    1)删除敌人
    2)得奖励或加分








ShootGame-----JPanel
  Hero hero = new Hero();
  FlyingObject[] flyings = {};---敌机和蜜蜂
  Bullet[] bullets = {};
















英雄机如何动????????
分析:
1.Hero类-----moveTo(x,y)
2.moveTo(int x,int y){
     
  }