01.java课复习

1.数组传递会改变原来的值,调用函数传递了地址给他,所以里面可以改

int a[]={1,2,3,4,5,6,7}
func(a);//传数组地址给他初始化
//打印出来{2,2,3,4,5,6,7}
//这个数组是引用类型

func(int b[]){
    b[0]=2;

}
1
2
3
4
5
6
7
8
9

2.可变参数
//相当于数组,只能放在后面

  public int  add(int a,int ...b){
               int sum=0;
	for(int e: b){
                      sum+=e;
                }
   }
1
2
3
4
5
6

3.包(文件夹)避免重命名冲突

   package a; //当前包
   import xx.*/类名//导包
1
2

4.权限

private 只能在当前类中,不能被继承
缺省 没有修饰符 友好的,当前包(一个文件夹)可以访问,其他包不可以访问
public 公共的,所有包可以访问
protected 子类才有得访问,其他没有 father->son //类只有是 public 和缺省的 ,protected只要有继承关系都可以相互访问,不管同不同包
private<缺省

5.继承性extends(私有成员不能继承,)
子类继承父类 父类派生子类
super(); //调用父类构造方法

1.子类构造方法没有就调用父类(超类)构造方法super(); //一定存在 先调用 super(); 后调用子类构造方法

2.子类会报错 ,如果父类构造方法 覆盖了无参变成有参数 // 改super(参数) 即可 //父类构造方法不会被继承,但是默认调用

3.如果父类子类有相同方法
-1.方法的重载(同一个类)(参数不一样,名字一样)
- 2.方法的重写(覆盖) 父类有out(){}子类也有,输出子类的方法(个性)
(必须一模一样)

6.传递继承(传宗接代,多层继承)

7.多个继承不存在,只支持单继承,接口就可以

class c extends a,b{} (x)
1

8.super调用父类方法不是构造方法

   super.out();
   super.name;
1
2

9.final关键字

   final  int a=10;//不可以变,当常量
   final class aa{ //不可以被继承,绝育

   }
1
2
3
4

   final void out(){ //不能被重写覆盖,我的孩子不能有这个缺点

   }
1
2
3

10.继承 多态 强转子类变父类 用父亲的变量,用子类的方法(失去子类新增的方法和变量)改写可以

1.上转型对象
 如果父类有这个方法就会覆盖,变量不会覆盖
1
2

   class Parent {
    int i = 20;
    int j = 30;
    void f() {
        System.out.print(" " + i);
    }
}
1
2
3
4
5
6
7

class Child extends Parent {
    int i = 30;
    int k = 40;
    void f() {
        System.out.print(" " + i);
    }
    void g() {
        System.out.print(" " + k);
    }
    public static void main(String args[]) {
        Parent x = new Child();
        System.out.print(x.i);//20 ,直接被父亲的值覆盖
        x.f();// 30
        Child x1 = (Child) x; //30
        System.out.print(" " + x1.i);//30
        x1.f();
    }	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

11.super放在构造方法的第一行(隐式看不见的)