java

　　　　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(){}
}