Java面向对象02

1，引用类型数组：

Student[] stus = new Student[3]; //创建Student数组对象
stus[0] = new Student("zhangsan",25,"LF"); //创建Student对象
stus[1] = new Student("lisi",26,"JMS");
stus[2] = new Student("wangwu",24,"SD"); //1)给元素赋值需要new
System.out.println(stus[0].name); //输出第1个学生的名字
stus[1].age = 23; //修改第2个学生的年龄为23
stus[2].sayHi(); //第3个学生跟大家问好      //2)访问类中的成员需要数组元素打点
for(int i=0;i<stus.length;i++){ //遍历所有学生
    System.out.println(stus[i].name); //输出每个学生的名字
    stus[i].sayHi(); //每个学生跟大家问好
}

Student[] stus = new Student[]{      //---------了解即可
    new Student("zhangsan",25,"LF"),
    new Student("lisi",26,"JMS"),
    new Student("wangwu",24,"SD")
};

 2，继承

• 作用：代码复用

• 通过extends来实现继承

• 超类/父类：派生类所共有的属性和行为

  派生类/子类：派生类所特有的属性和行为

• 派生类可以访问派生类的和超类的，超类不能访问派生类的

• 一个超类可以有多个派生类，但一个派生类只能有一个超类------单一继承

• 具有传递性

• java规定：构造派生类之前必须先构造超类

  • 在派生类构造方法中若没有调用超类的构造方法，则默认super()调用超类无参构造方法

  • 在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供

    注意：super()调用超类构造方法，必须位于派生类构造方法的第一行

public class SuperDemo {
    public static void main(String[] args) {
        Boo o = new Boo();
    }
}

class Coo{
    Coo(int a){
    }
}
class Doo extends Coo{
    Doo(){
        super(5);
    }
    /*
    //如下代码为默认的
    Doo(){
        super();
    }
    */
}

class Aoo{
    Aoo(){
        System.out.println("超类构造");
    }
}
class Boo extends Aoo{
    Boo(){
        super(); //默认的，调用超类的无参构造方法
        System.out.println("派生类构造");
    }
}

 3，super：指代当前对象的超类对象

super的用法：

• super.成员变量名--------------------------访问超类的成员变量
• super.方法名()-------------------------------调用超类的方法------------明天下午讲
• super()-----------------------------------------调用超类的构造方法

4， 向上造型：

• 超类型的引用指向派生类对象

• 能点出来什么，看引用的类型-----------------------------这是规定

public class UploadDemo {
    public static void main(String[] args) {
        Aoo o1 = new Aoo();
        o1.a = 1;
        o1.show();
        //o1.b = 2;  //编译错误
        //o1.test(); //编译错误，超类不能访问派生类的

        Boo o2 = new Boo();
        o2.b = 1;
        o2.test();
        o2.a = 2;  //正确
        o2.show(); //正确，派生类可以访问超类的

        Aoo o3 = new Boo(); //向上造型
        o3.a = 1;
        o3.show();
        //o3.b = 2;  //编译错误
        //o3.test(); //编译错误，能点出来什么，看引用的类型
    }
}

class Aoo{
    int a;
    void show(){
    }
}
class Boo extends Aoo{
    int b;
    void test(){
    }
}

 5，方法的重写(override)：重新写

• 发生在父子类中，方法名相同，参数列表相同

• 重写方法被调用时，看对象的类型-----------------------这是规定

class 餐馆{
    void 做餐(){  中餐  }
}
//1)我还是想做中餐------------不需要重写
class Aoo extends 餐馆{
}

//2)我想改做西餐--------------需要重写
class Aoo extends 餐馆{
    void 做餐(){  西餐  }
}
//3)我想在中餐之上加西餐-------需要重写
class Aoo extends 餐馆{
    void 做餐(){
        super.做餐();
        西餐
    }     
}

重写需遵循"两同两小一大"原则：-----------了解，一般都是一模一样的

• 两同：

  • 方法名相同
  • 参数列表相同

• 两小：

  • 派生类方法的返回值类型小于或等于超类方法的

    • void和基本类型时，必须相等
    • 引用类型时，小于或等于

  • 派生类方法抛出的异常小于或等于超类方法的

• 一大：

  • 派生类方法的访问权限大于或等于超类方法的

6， 重写与重载的区别：

• 重写(override/overriding)：发生在父子类中，方法名相同，参数列表相同
• 重载(overload/overloading)：发生在同一类中，方法名相同，参数列表不同

补充：

/*
1.向上造型：
  1)超类型的引用指向派生类的对象
  2)能点出来什么，看引用的类型----------------这是规定
2.方法的重写(override)：
  1)发生在父子类中，方法名相同，参数列表相同
  2)重写方法被调用时，看对象的类型-------------这是规定
3.重写与重载的区别：
  1)重写:发生在父子类中，方法名相同，参数列表相同
  2)重载:发生在同一类中，方法名相同，参数列表不同

潜艇游戏案例:
1.将三种潜艇统一组合为SeaObject数组，并测试
2.在6个类中重写move()，并测试
3.画窗口
 */

/*
常见面试题:
1.重写与重载的区别：
  1)重写:发生在父子类中，方法名相同，参数列表相同
    ----用于在派生类中修改超类中所声明的方法
  2)重载:发生在同一类中，方法名相同，参数列表不同
    ----完全不同的方法，只是方法名正好相同
 */

/*
1.
  class Aoo{
    void show(){}
  }
  class Boo extends Aoo{ //发生重载了(继承了超类无参show，还有个有参show)
    void show(int a){}
  }
  class Boo{ //没有重载，也没有重写
    void show(int a){}
  }
  class Boo extends Aoo{ //发生了重写
    void show(){}
  }
  class Boo{ //没有重载，也没有重写
    void show(){}
  }

2.继承要符合is(是)的关系，不能为了复用代码就乱继承
  继承意味着代码虽然我没有写，但也属于我，只是没有写在一起而已
3.继承的是超类中的成员变量和普通方法，而不包括构造方法
  超类的构造方法是被派生类通过super来调用的
  class Aoo{
    int a;
    Aoo(){
    }
    void show(){
    }
  }
  class Boo extends Aoo{
    //继承的是Aoo中的a和show()方法，而不包括Aoo的无参构造方法
    //超类的无参构造方法是被派生类通过super来调用的
  }

4.成员变量:写在类中，方法外的。可以在整个类中访问。有默认值。
  局部变量:写在方法中的(包括方法的参数)。只能在当前方法中访问。没有默认值。
  Boo o = new Boo(); //------------------a=0
  o.show(5); //--------------------------b=5

  class Boo{
    int a;
    void show(int b){
      int c;
      System.out.println(a); //0
      System.out.println(b); //5
      System.out.println(c); //编译错误
    }
  }




  class Aoo{
    int a; //-------------------成员变量(整个类中访问)
    void show(int b){ //--------局部变量(当前方法中访问)
      int c; //-----------------局部变量(当前方法中访问)
    }
  }
 */





//类间关系有很多种:关联、继承、组成、聚合...
//继承只是其中的一种而已

1. if()语句如果没有{ }，则默认下一条语句是if内的语句，如果是if()；加了；号，则if语句结束了。

if后面可以跟赋值语句，结果就是被赋值的值，例如：if（b2=true），则这样if里面的逻辑成立。

2. 不用第三个变量，交换两个变量的值：

int a = 5;
int b = 6;
a = a+b;
b = a-b;
a = a-b;

3. 变量使用之前先声明再初始化（相当于局部变量），成员变量默认就有默认值，局部变量没有默认的初始值。

4. 基本类型的默认值：

byte：0

short：0

int：0

long：0L

double：0.0d  （d可加可不加）

char：\u0000（空）

boolean：false

float：0.0f

5.  case后面必须是具体的值，不能是变量，值的数据类型和switch后面的数据类型一致。

如果switch后面是String，则case后面是 “xxx”形式。

6. y%x  不管y和x是正是负，结果的正负号和y的正负号相同。