潜艇游戏第一天：
- 创建了6个类，创建World类并测试
潜艇游戏第二天：
- 给6个类设计构造方法，并测试
潜艇游戏第三天：
- 设计侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组、水雷数组、炸弹数组，并测试
- 设计SeaObject超类，6个类继承超类
- 给SeaObject类设计两个构造方法，6个派生类分别调用
- 将三种潜艇统一造型到SeaObject数组中，并测试
建议练习顺序：2、3、(1+4)
潜艇游戏第四天：
- 在6个派生类中重写超类的move()移动方法，并测试
- 给类中成员添加访问控制修饰符
- 设计Images图片类
上期：
- 引用类型数组(下)：
- 区别一：给引用类型数组元素赋值，需要new个对象
- 区别二：访问引用类型数组元素的数据，需要通过元素去打点
- 继承：
代码复用、extends、超类：共有的 派生类：特有的
派生类可以访问派生类的+超类的，但超类不能访问派生类的
单一继承，传递性
规定：构造派生类之前必须先构造超类
- 在派生类的构造方法若没有调用超类构造方法，则默认super()调用超类的无参构造方法
- 在派生类的构造方法中若自己调用了超类构造方法，则不再默认提供
- super：指代当前对象的超类对象
super.成员变量名 访问超类的成员变量
super.方法名() 调用超类的方法
super() 调用超类的构造方法 - 向上造型：
- 超类型的引用指向派生类的对象
- 能点出来什么，看引用的类型
速记：
- 方法的重写(override/overriding)：重新写、覆盖
- 发生在父子类中，方法名相同，参数列表相同
- 重写方法被调用时，看对象的类型
- 遵循"两同两小一大"原则：
- 两同：
- 方法名相同
- 参数列表相同
- 两小：
- 派生类方法的返回值类型小于或等于超类方法的
- void和基本类型时，必须相等
- 引用类型时，小于或等于
- 派生类方法抛出的异常小于或等于超类方法的
- 一大：
- 派生类方法的访问权限大于或等于超类方法的
- package和import：
- package：声明包
- 作用：避免类的命名冲突
- 同包中的类不能同名，但不同包中的类可以同名
- 类的全称：包名.类名
- 建议：包名所有字母都小写，并且常常有层次结构
- import：导入类
- 同包中的类可以直接访问，但不同包中的类不能直接访问，若想访问：
- 先import导入类再访问----------建议
- 类的全称-----------------------------太繁琐，不建议
- 访问控制修饰符：---------------------保护数据的安全
- public：公开的，任何类
- private：私有的，本类
- protected：受保护的，本类、派生类、同包类------------用得很少
- 默认的：什么也不写，本类、同包类--------------------------不建议默认访问权限
注意：
- 访问权限由低到高依次为：private<默认的<protected<public
- 类的访问权限只能是public或默认的，而类中成员的访问权限如上4种都可以
- static：静态的
- 静态变量：
- 由static修饰
- 属于类，存储在方法区中，只有一份
- 常常通过类名点来访问
- 何时用：所有对象所共享的数据(图片、音频、视频等)
- 静态方法：
- 由static修饰
- 属于类，存储在方法区中，只有一份
- 常常通过类名点来访问
- 静态方法中没有隐式this传递，所以不能直接访问实例成员
- 何时用：方法的操作与对象无关(不需要访问对象的属性或方法)
- 静态块：
- 由static修饰
- 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次
- 何时用：加载/初始化静态资源(图片、音频、视频等)
完整笔记：
- 方法的重写(override/overriding)：重新写、覆盖
- 发生在父子类中，方法名相同，参数列表相同
- 重写方法被调用时，看对象的类型---------------------这是规定，记住就可以了
class 餐馆{
void 做餐(){ 做中餐 }
}
//1)我还是想做中餐-------------------不需要重写
class Aoo extends 餐馆{
}
//2)我想改做西餐---------------------需要重写
class Boo extends 餐馆{
void 做餐(){ 做西餐 }
}
//3)我想在中餐基础之上加入西餐---------需要重写
class Coo extends 餐馆{
void 做餐(){
super.做餐();
做西餐
}
}- 遵循"两同两小一大"原则：-------------了解即可，一般都是一模一样的
- 两同：
- 方法名相同
- 参数列表相同
- 两小：
- 派生类方法的返回值类型小于或等于超类方法的
- void和基本类型时，必须相等
- 引用类型时，小于或等于
//超类大，派生类小
class Aoo{ //大
void show(){}
double test(){ return 0.0; } //看一看
Boo say(){ return null; }
Aoo sayHi(){ return null; }
}
class Boo { //小
//int show(){ return 1; } //编译错误，void时必须相同
//int test(){ return 0; } //编译错误，基本类型时必须相同
//Aoo say(){ return null; } //编译错误，引用类型时必须小于或等于
Boo sayHi(){ return null; } //正确
}- 派生类方法抛出的异常小于或等于超类方法的
- 一大：
- 派生类方法的访问权限大于或等于超类方法的
- package和import：
- package：声明包
- 作用：避免类的命名冲突
- 同包中的类不能同名，但不同包中的类可以同名
- 类的全称：包名.类名
- 建议：包名所有字母都小写，并且常常有层次结构
- import：导入类
- 同包中的类可以直接访问，但不同包中的类不能直接访问，若想访问：
- 先import导入类再访问----------建议
- 类的全称-----------------------------太繁琐，不建议
- 访问控制修饰符：---------------------保护数据的安全
- public：公开的，任何类
- private：私有的，本类
- protected：受保护的，本类、派生类、同包类------------用得很少
- 默认的：什么也不写，本类、同包类--------------------------不建议默认访问权限
注意：
- 访问权限由低到高依次为：private<默认的<protected<public
- 类的访问权限只能是public或默认的，而类中成员的访问权限如上4种都可以
package ooday04;
public class Coo {
public int a; //任何类
protected int b; //本类、派生类、同包类
int c; //本类、同包类
private int d; //本类
void show(){
a = 1;
b = 2;
c = 3;
d = 4;
}
}
class Doo{ //-------------------演示private
void show(){
Coo o = new Coo();
o.a = 1;
o.b = 2;
o.c = 3;
//o.d = 4; //编译错误
}
}
package ooday04_vis;
import ooday04.Coo;
public class Eoo { //演示同包的
void show(){
Coo o = new Coo();
o.a = 1;
//o.b = 2; //编译错误
//o.c = 3; //编译错误
//o.d = 4; //编译错误
}
}
class Foo extends Coo{ //跨包继承-----演示protected
void show(){
a = 1;
b = 2;
//c = 3; //编译错误
//d = 4; //编译错误
}
}- static：静态的
- 静态变量：
- 由static修饰
- 属于类，存储在方法区中，只有一份
- 常常通过类名点来访问
- 何时用：所有对象所共享的数据(图片、音频、视频等)
public class StaticDemo {
public static void main(String[] args) {
Goo o1 = new Goo();
o1.show();
Goo o2 = new Goo();
o2.show();
Goo o3 = new Goo();
o3.show();
System.out.println(Goo.b); //常常通过类名点来访问
}
}
//演示静态变量
class Goo{
int a; //实例变量
static int b; //静态变量
Goo(){
a++;
b++;
}
void show(){
System.out.println("a="+a+",b="+b);
}
}- 静态方法：
- 由static修饰
- 属于类，存储在方法区中，只有一份
- 常常通过类名点来访问
- 静态方法中没有隐式this传递，所以不能直接访问实例成员
- 何时用：方法的操作与对象无关(不需要访问对象的属性或方法)
public class StaticDemo {
public static void main(String[] args) {
int a = Ioo.plus(5,6); //常常通过类名点来访问
}
}
//演示静态方法
class Hoo{
int a; //实例变量(由对象来访问)
static int b; //静态变量(由类来访问)
void show(){ //有隐式this
System.out.println(this.a);
System.out.println(Hoo.b);
}
static void test(){ //没有隐式this
//静态方法中没有隐式this传递
//没有this就意味着没有对象
//而实例变量a是必须通过对象点来访问的
//所以如下语句发生编译错误
//System.out.println(a); //编译错误
System.out.println(Hoo.b);
}
}
//演示静态方法何时用:
class Ioo{
int a; //实例变量(描述对象的属性)
//show()中访问了对象的属性a，意味着show方法的操作与对象有关，不能设计为静态方法
void show(){
System.out.println(a);
}
//plus()中并没有访问对象的属性/行为，意味着plus的操作与对象无关，可以设计为静态方法
static int plus(int num1,int num2){
int num = num1+num2;
return num;
}
}- 静态块：
- 由static修饰
- 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次
- 何时用：加载/初始化静态资源(图片、音频、视频等)
public class StaticDemo {
public static void main(String[] args) {
Joo o4 = new Joo();
Joo o5 = new Joo();
Joo o6 = new Joo();
}
}
//演示静态块
class Joo{
static{
System.out.println("静态块");
}
Joo(){
System.out.println("构造方法");
}
}补充：
- 数据(成员变量)私有化(private)，行为(方法)大部分公开化(public)
- 成员变量的分类：
- 实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份，通过对象/引用打点来访问
- 静态变量：有static修饰，属于类的，存储在方法区中，只有一份，通过类名点来访问
- 内存管理：由JVM来管理的
- 堆：new出来的对象(包含实例变量、数组的元素)
- 栈：局部变量(包括方法的参数)
- 方法区：.class字节码文件(包括静态变量、所有方法)
- 给实例变量初始化建议写在构造方法中，给静态变量初始化建议写在静态块中
词汇：
1)graphics:图像/画笔
2)PI:圆周率
3)count:数量
4)abstract:抽象的
5)live:活着的
6)dead:死了的
7)state:状态
8)is:是
9)paint:画
10)final:最终的
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
