java语言基础1--面向对象，封装，继承，多态，异常

　　对象引用的赋值

public class Box {
    int width;
    int height;
    
    public static void main(String[] args) {
        Box b1 = new Box();
        b1.width=5;
        b1.height=5;
        Box b2 = b1;//对象引用赋值时，不是复制一个b1对象的副本，而是复制b1引用副本给b2,因此 修改b2 将会影响b1
        b2.width=10;
        System.out.println(b1.width);//输出 10
    }
}

方法重载时的类型自动转换，在调研重载方法时，并不需要总是精确的，有时候java会进行自动的类型转换

public class Box {
    public void test() {
        System.out.println("这是无参方法");
        System.out.println();
    }
    
    public void test(float param) {
        System.out.println("这是float方法");
        System.out.println(param);
    }
    
    public void test(double param) {
        System.out.println("这是double方法");
        System.out.println(param);
    }
    
    public static void main(String[] args) {
        Box b1 = new Box();
        int a = 1;
        b1.test(a);
        // 输出结果 这是float方法 1.0
    }
}

上个例子中 ， 当找不到 匹配方法时 java 会自动将int转化为 float 或者double 

值传递与引用传递

当方法传递的参数类型是基本类型时，使用值传递，也就是说将实参复制一个副本给形参，计算结果对原来的实参无影响，如下例子

public class Box {
    void meth(int i,int j) {
        i *=2;
        j /=2;
    }
    
    public static void main(String[] args) {
        Box b1 = new Box();
        int a = 100;
        int b = 200;
        b1.meth(a,b);
        
        System.out.println(a); //输出 100
        System.out.println(b);//输出 200
    }
}

当方法传递的参数类型是对象类型时，情况就不一样了，因为对象是通过引用来传递的，此时java也是遵循值传递的，只不过只是是将实参的内存地址赋值给形参，因此在方法内调用会影响实参。如下例子

public class Box {
    int a;
    int b;
    Box( int a,int b ) {
        this.a = a;
        this.b =b;
    }
    
    void meth(Box b) {
        b.a *=2;
        b.b /=2;
    }
    
    public static void main(String[] args) {
        Box b1 = new Box(100,200);
        b1.meth(b1);
        
        System.out.println(b1.a); //输出 200
        System.out.println(b1.b);//输出 200
    }
}

访问控制 

public 成员在任何地方都能被访问，

private 成员在类的外部不可见，

无修饰符时 只对当前包的类可见

protected 只对当前包的类或者其他包中的子类可见

数组与集合的区别是，数组的长度不可变

    public static void main(String[] args) {
        int[] a  = new int[10];
        a[0] = 1;
        a[1] = 1;
        System.out.println(a.length);//输出 10， 数组的长度与实际使用元素的个数无关，它只反映数组的容量
    }

 继承

public class Box {
    int i ;
    int j;
    
    void showIJ() {
        System.out.println(i+"----"+j);
    }
}

public class BoxT extends Box{
    int k;
    void showK() {
        System.out.println(k);
    }
    
    public static void main(String[] args) {
         BoxT b =  new BoxT();
         b.i =1;
         b.j =2;
         b.k =3;
         b.showIJ();//输出  1----2 ， BoxT包含父类Box的所有成员，所以b能访问i和j。但是子类不能访问父类的private成员。 
         b.showK();//输出3
         
         //父类引用指向子类对象
         Box b1 = b;
//         b1.showK(); // 当父类引用指向子类对象的时候 不能访问子类的特有成员（也就是说只能访问子类对象在父类定义的那部分数据） ，因为父类不知道子类添加了什么内容。
//         b1.k;
    }
}

 super关键字

　　super 的两种用途，1 是用于调用最近父类的构造函数，2 是访问父类中被子类隐藏的成员

public class Box {
    int i ;
}

public class BoxT extends Box{
    int i;
    
    BoxT (int x,int y){
        super.i = x;
        this.i = y;
    }
    void showK() {
        System.out.println(super.i+"------"+this.i); 
    }
    
    public static void main(String[] args) {
        BoxT b = new BoxT(5, 10);
        b.showK();//输出 5------10 父类成员 和子类成员同类型同名 此时父类成员被子类成员屏蔽，可以使用super来访问父类成员
    }
}

 方法重写：如果子类的方法和父类的某个方法的方法名和参数类型均一致，父类的方法就被重写了，此时调用子类对象的方法时会执行子类的方法，父类的方法就被隐藏了。

 　　继承+方法重写+父类引用指向子类对象 = 多态，多态的重要特性就是动态方法调用

public class Box {
    public void show() {
        System.out.println("父类方法");
    }
}

public class BoxT extends Box{
    
    @Override
    public void show() {
        System.out.println("子类方法");
    }
    
    public static void main(String[] args) {
        Box b = new BoxT();
        b.show();//输出 子类方法，当父类引用指向子类对象时，java在运行时根据对象类型来确定调用方法的版本，因为这里对象的类型是BoxT，所以调用BoxT的方法
    }
}

 接口

　　变量 被 public static final 修饰，方法也被public 修饰，

　　如果一个类未实现了接口的全部方法，那么类需要被声明为abstract类型，

 　　接口多态

public interface AAA {
    void show();
}

public class BBB implements AAA {

    @Override
    public void show() {
        System.out.println("BBB类实现");
    }

}

public class CCC implements AAA {
    @Override
    public void show() {
        System.out.println("CCC实现");
    }
    
    public static void main(String[] args) {
        AAA b = new BBB();
        b.show();//输出 BBB类实现
        
        AAA c = new CCC();
        c.show();//输出 CCC实现
    }
}

　　jdk8之后的接口可以定义默认的实现方法

public interface AAA {
    void test();//普通方法
    
    default void show() {//默认的实现方法需要 default关键字修饰
        System.out.println("这是默认方法");
    }
    
    
    default void showV() {//默认的实现方法需要 default关键字修饰
        System.out.println("这是默认方法");
    }
}

public class BBB implements AAA {

    @Override
    public void show() {
        System.out.println("BBB类实现");
    }

    @Override
    public void test() {//普通方法
        
    }
    
    public static void main(String[] args) {
        AAA b = new BBB();
        b.show();//BBB类实现 
        b.showV();//这是默认方法，如果实现类重写了默认方法 ， 那么将调用实现类的方法 否则调用默认方法
    }
}

 jdk8,可以为接口定义static方法 类似于类中的静态方法。

异常的层次

使用try catch 的目的：1 修复错误， 2 阻止程序终止。

在进行try catch 或者 throws Exception时 ，Error 或RuntimeException（这种未检查异常）及其子类是无需处理的，运行时 有java自动抛出