java - 第一阶段总结
递归
递归:能不用就不用，因为效率极低
package over;
//递归
public class Fi {
public static void main(String[] args) {
int num = f(7);
System.out.println(num);
}
public static int f(int n){
if(n==1 || n==2){
return 1;
}else{
return f(n-1)+f(n-2);
}
}
/*
* f7=f6(8)+f5(5)---------------------13
* f6=f5(5)+f4(3)------------------8
* f5=f4(3)+f3(2)---------------5
* f4=f3(2)+f2(1)------------3
* f3=f2(1)+f1(1)---------2
* f2------------------1
* f1------------------1
*/
}
不借助于第3个数，来交换两个数
package test.tang;
public class Test {
public static void main(String[] args) {
//------只适用于数字类型(整数类型),小数结果不准确
int a=5,b=8;
a = a+b; //a=13
b = a-b; //b=5
a = a-b; //a=8
System.out.println("a="+a);
System.out.println("b="+b);
}
}
关于a++， ++a 的循环
/*
* 练习:
* 1.声明整型变量a并赋值为0
* a=a++，输出a的值-------0
* 2.声明整型变量b并赋值为0
* b=++b，输出b的值-------1
* 3.声明整型变量c并赋值为0
* for(int i=1;i<=100;i++){
* c=c++;
* }
* System.out.println(c);
* 4.声明整型变量d并赋值为0
* for(int i=1;i<=100;i++){
* d=++d;
* }
* System.out.println(d);
*/ /*
int a = 0;
//1.记录++a的值1
//2.a自增1变为1
//3.将记录++a的值1赋值给a
a = ++a;
System.out.println(a);
*/ /*
int a = 0;
//1.记录了a++的值0
//2.a自增1变为1
//3.将记录a++的值0赋值给a
a = a++;
System.out.println(a);
*/ /*
int a = 0;
for(int i=1;i<=100;i++){
a=++a;
}
System.out.println(a);
*/
/*
* a=++a;
* a=0
* i=1 a=1
* i=2 a=2
* i=3 a=3
* i=4 a=4
* ...
* i=100 a=100
*/ /*
* a=a++;
* a=0
* i=1 a=0
* i=2 a=0
* i=3 a=0
* i=4 a=0
* ...
* i=100 a=0
*/
注意的地方：
short s = 5;
s += 10; //系统自动帮助咱们做了强制类型转换
//s = s+10; //编译错误，必须自己强转
面向对象的设计思想:
1)对象、类:
1.1)数据的封装--成员变量
1.2)方法(操作数据)的封装
2.构造方法:给数据(成员变量)赋初值
实例方法:操作对象的数据---与对象有关
静态方法:操作参数的数据---与对象无关
抽象方法:方法体没法写-----只能父类/接口中
3.继承:
1)作用:代码复用
2)很多类中有重复的代码时，设计父类来继承
2.1)普通父类:没有抽象方法时
2.2)抽象类:有抽象方法时
2.3)接口:完全抽象方法时
4.设计规则:
1)将公共的属性和行为，抽象到父类中
2)所有子类方法的实现都一样-----普通方法
所有子类方法的实现都不一样---抽象方法
3)所有子类共有的，抽到父类中
部分子类共有的，抽到接口中
符合既是也是时，使用接口
接口是对继承的单根性的扩展
1.何时需要Debug?
程序的运行结果，与你的预期结果不同时
Debug的目的是找错误，而不是改错误
2.最早期调试就是打桩:
System.out.println(???);
3.Debug调试步骤:
1)先添加断点
2)以调试模式来运行程序
3)F5:单步调试(会进到方法中)
F6:逐方法调试(不进到方法中)
F7:结束方法的调试
F8:直接跳到下一个断点
若后面没有断点了则结束调试
4.看变量
添加监视
在记事本中自己顺Shoot游戏中的类的结构
FlyingObject,Enemy,Award,
Airplane,Bee,Bullet,Hero abstract class FlyingObject{
image,width,height,x,y
abstract void step(){}
abstract boolean outOfBounds(){} }
interface Enemy{
int getScore();
}
interface Award{
int getType();
}
class Airplane extends FlyingObject implements Enemy{
speed
Airplane(){}
boolean shootBy(){}
}
class Bee extends FlyingObject implements Award{
xSpeed,ySpeed,awardType
Bee(){}
boolean shootBy(){}
}
class Bullet extends FlyingObject{
speed
Bullet(){}
}
class Hero extends FlyingObject{
life,doubleFire,images,index
Hero(){}
Bullet[] shoot(){}
boolean hit(){}
}