java-day05

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

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

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

Shoot射击游戏第四天:
1.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组，并测试
2.在6个对象类中重写step()移动
3.画窗口

Shoot射击游戏第五天:
1.给类中成员添加访问控制修饰符
2.给6个对象类添加图片属性




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

笔记:
1.package:
  1)作用:避免类的命名冲突
  2)类的全称: 包名.类名
  3)包名可以有层次结构
  4)建议:包名所有字母都小写
  import:
  1)同包中的类可以直接访问，
    不同包中的类不能直接访问，想访问有如下两种方式:
    1.1)先import声明类，再直接访问类-----建议
    1.2)类的全称-------------------------太繁琐，不建议
2.访问控制修饰符:
  1)public:公开的，任何类
  2)protected:受保护的，本类、子类、同包类
  3)默认的:什么也不写，本类、同包类
  4)private:私有的，本类
  说明:
    1)类的访问修饰符只能是public或默认的
    2)类中成员的访问修饰符如上4种都可以
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.预习static final常量
3.将今天的两个功能在昨天基础之上重写两次


当日事当日毕












读图片------------文件IO操作

对文件的操作，特别容易出现异常
----------java强制做IO操作时，必须做异常的处理





















方法的操作-----大部分都是应该与对象有关的


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

















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 d = Math.sqrt(25);

无论是m1,m2,m3,...,m100中的哪一个对象
去sqrt(25)，最终的结果都是一样的，
说明sqrt()的操作与对象无关而仅与参数有关


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

  Math m2 = new Math();
  double d = m2.sqrt(25); //5.0

  Math m3 = new Math();
  double d = m3.sqrt(25); //5.0
















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

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

















1)day07中的GuessingGame类
2)oo.day01中的Student类
3)射击游戏的World类






















map.jpg---------------------图片(一份)
意外.mp4--------------------音频(一份)
战狼2.avi-------------------视频(一份)

























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


Aoo.b = 1;
Aoo o = new Aoo();
o.a = 1;

class Aoo{
  int a;
  static int b;
}


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














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

class Card{
  private String cardId;
  private String cardPwd;
  private double balance;
 
  public boolean checkPwd(String pwd){
    if(pwd.equals(cardPwd)){
      return true;
    }else{
      return false;
    }
  }
  public boolean payMoney(double money){
    if(balance>=money){
      balance-=money;
      return true;
    }else{
      return false;
    }
  }


}




























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

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
























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

















  cn.tedu    .   bproject   .


可移植性













  com.taobao .


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

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













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

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
















包，避免类命名冲突


项目--------------------小区名
包----------------------楼号+单元号
类----------------------房间


























有了窗口，想往窗口上画对象，其实就是在画图片