一、异常捕获
packagecom.pb.demo.demo1;publicclassDemo {publicstaticvoidmain(String[] args) {try{
func();
System.out.PRintln("A");
}catch(Exception e) {//e.printStackTrace();System.out.println("C");
}
System.out.println("D");
}/*** 抛出异常
*@throwsException*/publicstaticvoidfunc()throwsException{try{thrownewException();
}finally{
System.out.println("B");
}
}
}
结果：B,C,D
二、对象的实例化过程
packagecom.pb.demo.demo2;publicclassTest {publicTest(){
System.out.println("Test");
}
}packagecom.pb.demo.demo2;/*** 继承父类test
*@authorAdministrator
**/publicclassDemoextendsTest {publicDemo(){//这里隐藏了super()System.out.println("Demo");
}publicstaticvoidmain(String[] args) {newDemo();newTest();
}
}
结果：
Test
Demo
Test
三、接口packagecom.pb.demo.demo2;publicinterfaceA {
}packagecom.pb.demo.demo2;publicclassBimplementsA {publicString func(){return"func";
}publicstaticvoidmain(String[] args) {
A a=newB();
a.func();//编译失败，因为A接口中并没有这个方法}
}
四、方法重写packagecom.pb.demo.demo3;publicclassFu {publicbooleanshow(chara){
System.out.println(a);returntrue;
}
}packagecom.pb.demo.demo3;publicclassDemoextendsFu {/*** 重写父类的方法
* 调用时会调用子类重写后的方法*/publicbooleanshow(chara){
System.out.println(a);returnfalse;
}publicstaticvoidmain(String[] args) {inti=0;
Fu f=newDemo();
Demo d=newDemo();for(f.show('A');f.show('B')&&(i<2);f.show('C')){
i++;
d.show('D');
}//结果:A，B,}
}
结果;A,B
五、接口packagecom.pb.demo.demo4;publicinterfaceA {
}packagecom.pb.demo.demo4;publicclassBimplementsA {publicString test(){return"yes";
}
}packagecom.pb.demo.demo4;publicclassDemo {staticA get(){returnnewB();
}publicstaticvoidmain(String[] args) {
A a=Demo.get();
System.out.println(a.test());//编译失败 接口中没有这个方法，这个方法是子类中特有的}
}
六、对象初始化packagecom.pb.demo.demo5;publicclassSuper {inti=0;publicSuper(String a){
System.out.println("A");
i=1;
}publicSuper(){
System.out.println("B");
i+=2;
}
}packagecom.pb.demo.demo5;publicclassDemoextendsSuper {publicDemo(String a){
System.out.println("C");
i=5;
}publicstaticvoidmain(String[] args) {inti=4;
Super d=newDemo("A");
System.out.println(d.i);
}//B,C,5}
结果：B,C,5
七、匿名内部类的使用packagecom.pb.demo.demo6;publicinterfaceInter {publicvoidshow(inta,intb);publicvoidfunc();
}packagecom.pb.demo.demo6;publicclassDemo {publicstaticvoidmain(String[] args) {//补足代码，调用两个函数，用匿名内部类实现Inter inter =newInter() {
@Overridepublicvoidshow(inta,intb) {
}
@Overridepublicvoidfunc() {
}
};
inter.show(3, 5);
inter.func();
}
}
八、packagecom.pb.demo.demo7;publicclassTD {inty = 6;classInner {staticfinalinty = 3;//内部类中如果有static成员，这个内部类必须是static的,voidshow() {
System.out.println(y);//只能调用局部中final修饰的}
}
}packagecom.pb.demo.demo7;publicclassTC {publicstaticvoidmain(String[] args) {
TD.Inner ti=newTD().newInner();
ti.show();//3}
}
非静态内部类，不能定义静态成员，
内部类如果有静态成员，则这个内部类必须是静态内部类
九、方法重写和方法重载publicclassDemo {intshow(inta,intb){return0;
}
}/*** 下列哪里方法可以存在Demo的子类中*/publicintshow(inta,intb){return0;
}//可以方法重写privateintshow(inta,intb){return0;
}//权限不够privateintshow(inta,longb){return0;
}//可以，和父类不是同一个方法，方法重载publicshortshow(inta,intb){return0;
}//不可以，不是方法重载，不可以和给定的函数出现在同一类中，或者其子类publicstaticintshow(inta,intb){return0;
}//不可以，静态方法，只能覆盖静态
十、this,finalthis：代表本类对象，哪个对象调用this所有的函数，this就代表哪个对象
final:
1.修饰类，变量（成员变量，静态变量，局部变量），函数
2.修饰的类不可以被继承
3.修饰的函数不可以被重写
4.修饰的变量是一个常量，只能赋值一次
5.内部类只能访问局部中的final变量
十一、继承对象初始化packagecom.pb.demo.demo8;publicclassFu {intnum=4;voidshow(){
System.out.println("show Fu");
}
}packagecom.pb.demo.demo8;publicclassZiextendsFu {intnum=5;voidshow(){
System.out.println("show Zi");
}
}packagecom.pb.demo.demo8;publicclassT {publicstaticvoidmain(String[] args) {
Fu f=newZi();
Zi z=newZi();
System.out.println(f.num);//4System.out.println(z.num);//5f.show();//方法已经重写，执行子类的方法z.show();
}
}
结果：
4
5
show Zi
show Zi
十二、接口的实现packagecom.pb.demo.demo8;publicinterfaceA {voidshow();
}packagecom.pb.demo.demo8;publicinterfaceB {voidadd(inta,intb);
}packagecom.pb.demo.demo7;importcom.pb.demo.demo8.A;importcom.pb.demo.demo8.B;publicclassCimplementsA,B{privateintx;privateinty;//private int sum;@Overridepublicvoidadd(inta,intb) {this.x=a;this.y=b;//sum=a+b;}
@Overridepublicvoidshow() {
System.out.println(x+y);//System.out.println(sum);}publicstaticvoidmain(String[] args) {
C c=newC();
c.add(4, 2);
c.show();//通过函数打印以上2个数的和}
}
十三、异常执行packagecom.pb.demo.demo8;publicclassDemo {publicstaticvoidmain(String[] args) {try{
showExce();
System.out.println("A");
}catch(Exception e) {
System.out.println("B");
}finally{
System.out.println("C");
}
System.out.println("D");//B,C,D}publicstaticvoidshowExce()throwsException{thrownewException();
}
}
结果：B,C,D
十四、继承，子类重写父类packagecom.pb.demo.demo8;publicclassSuper {inti=0;
Super(){
};publicSuper(String s){
i=1;
}
}packagecom.pb.demo.demo8;publicclassDemo1extendsSuper {publicDemo1(String s){
i=2;
}publicstaticvoidmain(String[] args) {
Demo1 d=newDemo1("yes");
System.out.println(d.i);//2}
}
结果：2
十五、方法重写
packagecom.pb.demo.demo9;publicclassSuper {publicintget(){return4;
}
}packagecom.pb.demo.demo9;publicclassDemo1extendsSuper {publiclongget(){//方法重写不能改变返回值类型和参数return4;
}publicstaticvoidmain(String[] args) {
Super s=newDemo1();
System.out.println(s.get());
}
}
结果：编译失败：方法重写不能改变方法的返回值 和参数
十六、异常
packagecom.day10.demo2;publicclassDemo {publicstaticvoidmain(String[] args) {try{
func();
}catch(Exception e) {
System.out.println("C");
}
System.out.println("D");
}publicstaticvoidfunc(){try{thrownewException();
System.out.println("A");//抛出异常下方代码不会被执行}catch(Exception e) {
System.out.println("B");
}
}
}
结果:throw下方的代码不能被执行到
删除后，执行结果：B,D
十七、匿名内部类
packagecom.day10.demo2;publicclassDemo1 {publicvoidfunc(){//位置1：}publicstaticvoidmain(String[] args) {
Demo d=newDemo();//位置2}/*** A、在位置1写new Inner(); //OK
* B、在位置2写new Inner(); //主函数是静态的,如果要访问，需要被静态包修
* C、在位置2写new d.Inner();//格式错误 new new Demo1().Inner();
* D、在位置2写new Demo.Inner(); //错误因为inner不是静态的*/}
结果
十八、多重catch顺序
packagecom.day10.demo2;publicclassExc0extendsException {
}packagecom.day10.demo2;publicclassDemo2 {publicstaticvoidmain(String[] args) {try{thrownewExc1();
}catch(Exception e) {
System.out.println("Exception");/** Exception是最大的异常父类，
* 在最前面的后，下面的catch永远不会被执行到*/}catch(Exc0 e) {
System.out.println("Exc0");
}
}
}
结果:在最前面的后，下面的catch永远不会被执行到，父类的catch要放在最下面
十九、静态调用非静态，匿名内部类实现
packagecom.day10.demo2;publicinterfaceTest {publicvoidfunc();
}
packagecom.day10.demo2;publicclassDemo3 {publicvoidshow(Test t){
t.func();
}publicstaticvoidmain(String[] args) {//补足代码：匿名内部类newDemo3().show(newTest(){
@Overridepublicvoidfunc() {
}
});
}
}
二十、异常带return
packagecom.day10.demo3;publicclassTest {publicstaticString output="";publicstaticvoidfoo(inti){try{if(i==1)thrownewException();
output+="1";
}catch(Exception e) {
output+="2";return;
}finally{
output+="3";
}
output+="4";
}publicstaticvoidmain(String[] args) {
foo(0);
System.out.println(output);//1,3,4foo(1);
System.out.println(output);//134,2,3}
}
结果
二十一、补全代码对象数组求最大值
packagecom.day10.demo3;publicclassCircle {privatestaticdoublepi=3.14;privatedoubleradius;//半径publicCircle(doubler){this.radius=r;
}publicstaticdoublecompare(Circle[] cir){//程序代码，就是求数组中的最大值intmax=0;for(intx=1;x<cir.length;x++){if(cir[x].getRadius()>cir[max].radius){
max=x;
}
}returncir[max].getRadius();
}publicdoublegetRadius() {returnradius;
}publicvoidsetRadius(doubleradius) {this.radius =radius;
}
}packagecom.day10.demo3;publicclassTC {publicstaticvoidmain(String[] args) {
Circle cir[]=newCircle[3];//创建了个类类型的数组cir[0]=newCircle(2.0);
cir[1]=newCircle(3.0);
cir[2]=newCircle(5.0);
System.out.println("最大半径值是："+Circle.compare(cir));
}
}
二十二、方法调用
packagecom.day10.demo3;publicclassDemo {privatestaticintj = 0;privatestaticbooleanmethodB(intk) {
j+=k;returntrue;
}publicstaticvoidmethodA(inti) {booleanb;
b= i < 10 | methodB(4);
b= i < 10 ||methodB(8);
}publicstaticvoidmain(String[] args) {
methodA(0);
System.out.println(j);
}
}
结果：4
二十三、对象中值的比较
packagecom.day10.demo4;publicclassCircle {privatedoubleradius;publicCircle(doubler){this.radius=r;
}publicCircle compare(Circle cir){//补足代码if(this.radius>cir.getRadius()){returnthis;
}else{returncir;
}//return (this.radius>cir.getRadius()?this:cir);}publicdoublegetRadius() {returnradius;
}publicvoidsetRadius(doubleradius) {this.radius =radius;
}
}packagecom.day10.demo4;publicclassTC {publicstaticvoidmain(String[] args) {
Circle cir1=newCircle(1.0);
Circle cir2=newCircle(2.0);
Circle cir;
cir=cir1.compare(cir2);if(cir1==cir){
System.out.println("圆1的半径比较大");
}else{
System.out.println("圆2的半径比较大");
}
}
}