面向对象
笔记
1. 数组：
- 复制：System.arraycopy(a,1,b,0,4);
int[] b = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1);
- 排序：Arrays.sort(arr);
2. 方法：
3. 方法的定义：
修饰词 返回值类型 方法名(参数列表) {
方法体
}
4. 方法的调用：
- 无返回值：方法名(有参传参);
- 有返回值：数据类型 变量 = 方法名(有参传参);
System.out.println( 方法名(有参传参) );
5. return：
- return 值;
- return;
## 笔记：
1. 什么是类？什么是对象？
- 现实生活是由很多很多对象组成的，基于对象抽出了类
- 对象：软件中真实存在的单个个体/东西
类：类型/类别，代表一类个体
- 类是对象的模板，对象是类的具体的实例
- 类中可以包含：
- 对象的属性/特征-----------------------------成员变量
- 对象的行为/动作/功能---------------------方法
- 一个类可以创建多个对象
2. 如何创建类？如何创建对象？如何访问成员？
```java
//创建类:
public class Student {
//成员变量
String name;
int age;
String address;
//方法
void study(){
System.out.println(name+"在学习...");
}
void sayHi(){
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
}
}
//创建对象:
public class StudentTest {
public static void main(String[] args) {
//创建一个学生对象
Student zs = new Student();
//访问成员变量
zs.name = "zhangsan";
zs.age = 25;
zs.address = "河北廊坊";
//调用方法
zs.study();
zs.sayHi();
Student ls = new Student();
ls.name = "lisi";
ls.age = 27;
ls.address = "黑龙江佳木斯";
ls.study();
ls.sayHi();
//1)创建了一个学生对象
//2)给所有成员变量赋默认值
Student ww = new Student();
ww.study();
ww.sayHi();
}
}
```
3. 方法的签名：方法名+参数列表
4. 方法的重载(overload/overloading)：-------------------更方便方法的调用
- 发生在同一类中，方法名相同，参数列表不同
- 编译器在编译时会根据方法的签名自动绑定方法
```java
//演示方法的重载
class Aoo{
void show(){}
void show(String name){}
void show(int age){}
void show(String name,int age){}
void show(int age,String name){}
//int show(){ return 1; } //编译错误，重载与返回值类型无关
//void show(String address){} //编译错误，重载与参数名称无关
}
//演示重载方法的调用
public class OverloadDemo {
public static void main(String[] args) {
Aoo o = new Aoo();
o.show();
o.show("zhangsan");
o.show(25);
o.show("zhangsan",25);
o.show(25,"zhangsan");
}
}
```
## 精华笔记：
1. 什么是类？什么是对象？
- 现实生活是由很多很多对象组成的，基于对象抽出了类
- 对象：软件中真实存在的单个个体/东西
类：类型/类别，代表一类个体
- 类是对象的模板，对象是类的具体的实例
- 类中可以包含：
- 对象的属性/特征-----------------------------成员变量
- 对象的行为/动作/功能---------------------方法
- 一个类可以创建多个对象
2. 如何创建类？如何创建对象？如何访问成员？
3. 方法的签名：方法名+参数列表
4. 方法的重载(overload/overloading)：-------------------更方便方法的调用
- 发生在同一类中，方法名相同，参数列表不同
- 编译器在编译时会根据方法的签名自动绑定方法
## 补充：
1. OO：面向对象
OOA：面向对象分析
OOD：面向对象设计
OOP：面向对象编程------------------你们所参与的
2. 高质量的代码：------------------年薪
复用性好、扩展性好、维护性好、可移植性好、健壮性好、可读性好、效率好......
3. 类是一种引用数据类型
4. ```java
// 引用
// 数据类型 引用类型变量 指向 对象
Student zs = new Student();
```
5. 默认值：
```java
byte,short,int,long,char-----------------0
float,double-----------------------------0.0
boolean----------------------------------false
引用类型----------------------------------null
```
6. 潜艇游戏需求：
- 所参与的角色：战舰、深水炸弹、侦察潜艇、鱼雷潜艇、水雷潜艇、水雷
- 角色的关系：
- 战舰发射深水炸弹
- 深水炸弹可以打潜艇(侦察潜艇、鱼雷潜艇、水雷潜艇)，若打中：
- 潜艇消失、深水炸弹消失
- 打掉侦察潜艇，玩家得10分
打掉鱼雷潜艇，玩家得40分
打掉水雷潜艇，战舰得1条命
- 水雷潜艇发射水雷
- 水雷可以打战舰，若打中：
- 水雷消失
- 战舰减1条命(命数为0时游戏结束)
作业
1. 创建战舰类、侦察潜艇类、鱼雷潜艇类、水雷潜艇类、水雷类、深水炸弹类，设计类中的成员变量和move()方法
（1）
package cn.tedu.submarine;
//战舰
public class Battleship {
int width ; //宽
int height; //高
int x; //x坐标
int y; //y坐标
int speed; //移动速度
int life; //命
void move(){
System.out.println("战舰移动");
}
}
（2）
public class ObserveSubmarine {
//侦察潜艇
int width ; //宽
int height; //高
int x; //x坐标
int y; //y坐标
int speed; //移动速度
void move(){
System.out.println("侦察潜艇向右移动");
}
}
（3）
//鱼雷潜艇
public class TorpedoSubmarine {
int width ; //宽
int height; //高
int x; //x坐标
int y; //y坐标
int speed; //移动速度
void move(){
System.out.println("鱼雷潜艇向右移动");
}
}
（4）
//水雷潜艇
public class MineSubmarine {
int width ; //宽
int height; //高
int x; //x坐标
int y; //y坐标
int speed; //移动速度
void move(){
System.out.println("水雷潜艇向右移动");
}
}
（5）
//水雷
public class Mine {
int width ; //宽
int height; //高
int x; //x坐标
int y; //y坐标
int speed; //移动速度
void move(){
System.out.println("水雷向上移动");
}
}
（6）
//深水炸弹
public class Bomb {
int width ; //宽
int height; //高
int x; //x坐标
int y; //y坐标
int speed; //移动速度
void move(){
System.out.println("深水炸弹向上移动");
}
}
2. 创建World类，在main中：创建1个战舰对象、至少2个侦察潜艇对象、2个鱼雷潜艇对象、2个水雷潜艇对象、2个水雷对象、2个深水炸弹对象，并给属性赋值，调用方法测试
//整个游戏世界
public class World {
public static void main(String[] args) {
Battleship s =new Battleship();
s.width = 50;
s.height = 20;
s.x = 100;
s.y = 200;
s.speed = 20;
s.life = 5;
System.out.println(s.width+","+s.height+","+s.x+","+s.y+","+s.speed+","+s.life);
s.move();
ObserveSubmarine os1 = new ObserveSubmarine();
os1.width = 55;
os1.height = 60;
os1.x = 100;
os1.y = 200;
os1.speed = 30;
System.out.println(s.width+","+os1.height+","+os1.x+","+os1.y+","+os1.speed);
os1.move();
TorpedoSubmarine ts1 = new TorpedoSubmarine();
ts1.width = 55;
ts1.height = 60;
ts1.x = 100;
ts1.y = 200;
ts1.speed = 30;
System.out.println(ts1.width+","+ts1.height+","+ts1.x+","+ts1.y+","+ts1.speed);
ts1.move();
TorpedoSubmarine ts2 = new TorpedoSubmarine();
ts2.width = 55;
ts2.height = 60;
ts2.x = 100;
ts2.y = 200;
ts2.speed = 30;
System.out.println(ts2.width+","+ts2.height+","+ts2.x+","+ts2.y+","+ts2.speed);
ts2.move();
MineSubmarine ms1 = new MineSubmarine();
ms1.width = 55;
ms1.height = 60;
ms1.x = 100;
ms1.y = 200;
ms1.speed = 30;
System.out.println(ms1.width+","+ms1.height+","+ms1.x+","+ms1.y+","+ms1.speed);
ms1.move();
MineSubmarine ms2 = new MineSubmarine();
ms2.width = 55;
ms2.height = 60;
ms2.x = 100;
ms2.y = 200;
ms2.speed = 30;
System.out.println(ms2.width+","+ms2.height+","+ms2.x+","+ms2.y+","+ms2.speed);
ms2.move();
Mine m1 = new Mine();
m1.width = 55;
m1.height = 60;
m1.x = 100;
m1.y = 200;
m1.speed = 30;
System.out.println(m1.width+","+m1.height+","+m1.x+","+m1.y+","+m1.speed);
ts2.move();
Mine m2 = new Mine();
m2.width = 55;
m2.height = 60;
m2.x = 100;
m2.y = 200;
m2.speed = 30;
System.out.println(m2.width+","+m2.height+","+m2.x+","+m2.y+","+m2.speed);
ts2.move();
Bomb b1 = new Bomb();
b1.width = 55;
b1.height = 60;
b1.x = 100;
b1.y = 200;
b1.speed = 30;
System.out.println(b1.width+","+b1.height+","+b1.x+","+b1.y+","+b1.speed);
b1.move();
Bomb b2 = new Bomb();
b2.width = 55;
b2.height = 60;
b2.x = 100;
b2.y = 200;
b2.speed = 30;
System.out.println(b2.width+","+b2.height+","+b2.x+","+b2.y+","+b2.speed);
b2.move();
}
}
