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
}
包,避免类命名冲突
项目--------------------小区名
包----------------------楼号+单元号
类----------------------房间
有了窗口,想往窗口上画对象,其实就是在画图片
转载于:https://www.cnblogs.com/xiaofeixx/p/8903693.html