对象引用的赋值
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自动抛出