黑马程序员_日记8_JavaSE阶段性习题练习及复习
——- android培训、java培训、期待与您交流！ ———-
JAVASE阶段性习题练习及复习
这篇博客主要是把毕老师出的前四大练习题全部做了一遍，经我反复测试和修改后写得一些JAVASE基础总结。我的代码都是可以直接编译运行的。
练习一（4题）
原题带我的代码
注意：练习一是一个题目+一个我的代码
- 已知学生成绩以100分为满分，共分5个等级：A,B,C,D,E。 90～100为等级A，80～89为等级B，70～79为等级C， 60～69为等级D，0～59为等级E。 要求定义一个成绩变量，当成绩变化时，可直接知道该成绩对应的等级。
例如：当成绩为100时，该学生的等级时A。
需求分析：
1.定义一个功能，通过给定的分数，获得对应的等级
2.明确功能的结果：等级。char。
3.有没有未知的内容：分数。int
//解法一：
class Demo
{
public static void main(String[] args)
{
graceDegree(100);
graceDegree(0);
graceDegree(-100);
}
static void graceDegree(int grace)
{
if(grace < 0|| grace >100)
System.out.println("Wrong ");
else if(grace >=90 &&grace <= 100)
System.out.println("A");
else if(grace >=80 &&grace <= 89)
System.out.println("B");
else if(grace >=70 &&grace <= 79)
System.out.println("C");
else if(grace >=60 &&grace <= 69)
System.out.println("D");
else
System.out.println("E");
}
}//解法二
class Demo
{
public static void main(String[] args)
{
char ch =getLevel(10);
//char ch1 =getLevel(60);
//char ch2 =getLevel(70);
//char ch3 =getLevel(80);
//char ch4 =getLevel(90);
//char ch5 =getLevel(-10);
System.out.println("level = "+ch);
// System.out.println("level = "+ch1);
// System.out.println("level = "+ch2);
// System.out.println("level = "+ch3);
// System.out.println("level = "+ch4);
//System.out.println("level = "+ch5);
}
public static char getLevel(int grace)//不可以返回String类型，编译无法通过
{
char level;
if(grace >=90 && grace <=100)
level = 'A';
else if(grace >=80 && grace <=89)
level = 'B';
else if(grace >=70 && grace <=79)
level = 'C';
else if(grace >=60 && grace <=69)
level = 'D';
else if(grace >=0 && grace <=59)
level = 'E';
else
level = 'M';//无意义，但是少了这一句，当grace小于0或者大于100的时候，编译无法通过
return level;
}
}
2.求出1～100之间，即使3又是7的倍数出现的次数？
class Demo2
{
public static void main(String[] args)
{
System.out.println(Mod());
}
//明确功能实现的结果，返回次数。int
//有没有未知的变量。没有.
public static int Mod()
{
int count = 0;
for(int i=1; i<= 100; i++)
{
if(i%3==0&&i%7==0)
count++;
}
return count;
}
}*5.
用程序的方式显示出下列结果。
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25class Demo3
{
public static void main(String[] args)
{
d.printTable(5);
}
//明确功能输出的结果，没有返回值类型。
//有没有未知变量，有输出打表的行数.int
}
class d
{
public static void printTable(int num)
{
for(int i =1;i<=num;i++)
{
for(int j = 1;j<=i;j++)
System.out.print(i+"*"+j+"="+i*j+"\t");
System.out.println();
}
}
}打印程序结果
class Demo4
{
public static void main(String[] args)
{
int x = 1;
for(show('a'); show('b') && x<3; show('c'))//a b d c a b d c a b
{
show('d');
x++;
}
}
public static boolean show(char ch)
{
System.out.println(ch);
return true;
}
}
小结
练习一比较简单，注重基础语法。
for循环的嵌套使用
if else的嵌套
switch语句的使用
练习二（6题）
原题带答案
注意：本段练习仅给出第二题和第五题的代码
// 第一题
int x = 1,y=1;
if(x++==2 & ++y==2)
{
x =7;
}
System.out.println("x="+x+",y="+y);//x=2,y=2
//第二题
int x = 1,y = 1;
if(x++==2 && ++y==2)
{
x =7;
}
System.out.println("x="+x+",y="+y);//x=2,y=1
//第三题
int x = 1,y = 1;
if(x++==1 | ++y==1)
{
x =7;
}
System.out.println("x="+x+",y="+y);x=7,y=2//第四题
int x = 1,y = 1;
if(x++==1 || ++y==1)
{
x =7;
}
System.out.println("x="+x+",y="+y);//x=7,y=1//第五题
boolean b = true;
if(b=false) //如果写成if(b=false)有结果吗？如果有，结果是？
System.out.println("a");
else if(b)
System.out.println("b");
else if(!b)
System.out.println("c");
else
System.out.println("d");
//b
if(b=false)
//c//第六题
int x = 2,y=3;
switch(x)
{
default:
y++;
case 3:
y++;
case 4:
y++;
}
System.out.println("y="+y);//y=6我的代码
//第二题
class Demo
{
public static void main(String[] args)
{
int x = 1,y=1;
if(x++==2 && ++y==2)
{
x =7;
}
System.out.println("x="+x+",y="+y);//x=2,y=1
}
}
class Demo
{
public static void main(String[] args)
{
int x = 1,y=1;
if(x++==2 & ++y==2)
{
x =7;
}
System.out.println("x="+x+",y="+y);//x=2,y=2
}
}
//第五题
class Demo2
{
public static void main(String[] args)
{
boolean b = true;
if(b==false) //如果写成if(b=false)有结果吗？如果有，结果是？
System.out.println("a");
else if(b)
System.out.println("b");
else if(!b)
System.out.println("c");
else
System.out.println("d");
}
}
//当b==false时，结果为b
//当b=false时，结果为c小结
主要考察&和&&的区别：
&是按位与，即使左边为假，右边仍要继续运算；
但是&&是逻辑与，当左边为假，右边就不需要判断了。
还考察了|和||的区别：
|是按位或，即使左边为真，右边仍要继续运算；
但是||是逻辑与，当左边为真，右边就不在继续运算了。
还考察了自增x++和++x的区别
j=x++;是先进行j=x复制操作，再进行x=x+1；操作哦
j=++x;是先进行x=x+1;再进行j=x;复制操作。
练习三（14题）
原题带答案
本段练习先给出所有的题目
注：按Java规范书写程序代码，如果你认为程序有错误，请指出，并说明程序错误原因。
//1.
class Demo
{
void show(int a,int b,float c){}
}
A.void show(int a,float c,int b){}//yes
B,void show(int a,int b,float c){}//一模一样。不可以出现在同一个类中。
C.int show(int a,float c,int b){return a;}//yes。
D.int show(int a,float c){return a;}//yes
哪个答案和show函数重载。//2.写出结果。
class Demo
{
public static void main(String[] args)
{
int x=0,y=1;
if(++x==y--&x++==1||--y==0)
System.out.println("x="+x+",y="+y);
else
System.out.println("y="+y+",x="+x);
}
}
//3.写出输出结果。
class Demo
{
public static void main(String[] args)
{
int a=3,b=8;
int c=(a>b)?a++:b++;
System.out.println("a="+a+"\tb="+b+"\tc="+c); //3 9 8
int d=(a>b)?++a:++b;
System.out.println("a="+a+"\tb="+b+"\td="+d); //3 10 10
int e=(aout.println("a="+a+"\tb="+b+"\te="+e); //4 10 3
int f=(aout.println("a="+a+"\tb="+b+"\tf="+f); //5 10 5
}
} //4.写出结果。
class Demo
{
public static void main(String[] args)
{
int m=0,n=3;
if(m>0)
if(n>2)
System.out.println("A");
else
System.out.println("B");
}
}
//没有结果。//5.写出结果。
public class Demo
{
public static void main(String []args)
{
int i = 0, j = 5;
tp: for (;;)
{
i++;
for(;;)
{
if(i > j--)
break tp;
}
}
System.out.println("i = " + i + ", j = "+ j); i=1,j=-1;
}
}
//6.写出结果。
class Demo
{
public static void main(String[] args)
{
String foo="blue";
boolean[] bar=new boolean[2];
if(bar[0])//boolean类型的数组默认初始化值是false。
{
foo="green";
}
System.out.println(foo);
}
}
//7.写出结果。
public class Test
{
public static void leftshift(int i, int j)
{
i+=j;
}
public static void main(String args[])
{
int i = 4, j = 2;
leftshift(i, j);
System.out.println(i); //4 和leftShift函数没关系。
}
} //8.写出结果。
public class Demo
{
public static void main(String[] args)
{
int[] a=new int[1];
modify(a);
System.out.println(a[0]); //1
}
public static void modify(int[] a)
{
a[0]++;
}
} //9.
class Test
{
public static void main(String[] args)
{
String foo=args[1];
String bar=args[2];
String baz=args[3];
}
}
/*d:\>java Test Red Green Blue
what is the value of baz?
A. baz has value of ""
B. baz has value of null
C. baz has value of "Red"
D. baz has value of "Blue"
E. baz has value of "Green"
F. the code does not compile
G. the program throw an exception
*/11.简述：函数在程序中的作用以及运行特点。。
12.打印99乘法表
13.打印下列图形
*
* *
* * *
* * * *
* * * * *
14.
下面哪个数组定义是错误的。
并对错误的答案加上单行注释，写出错误的原因。
A，float[]=new float[3];//没有数组引用名称。
B, float f2[]=new float[];//数组没有长度。
C, float[] f1=new float[3];//yes。
D, boolean[] b={"true","false","true"};// 错误，数据类型不匹配。”true”这是字符串类型。
E, double f4[]={1,3,5};//yes double d = 1; s.o.p(d);//1.0;
F, int f5[]=new int[3]{2,3,4}; //错，右边中括号不能写具体数值，因为数据的元素和个数都在大括号体现了。
G, float f4[]={1.2,3.0,5.4};//错误。因为数组中的元素值都是double，加上f就对了。
我的代码
序号对应题号
//3.
class Demo
{
public static void main(String[] args)
{
int a=3,b=8;
int c=(a>b)?a++:b++;
System.out.println("a="+a+"\tb="+b+"\tc="+c); //3 9 8
int d=(a>b)?++a:++b;
System.out.println("a="+a+"\tb="+b+"\td="+d); //3 10 10
int e=(aout.println("a="+a+"\tb="+b+"\te="+e); //4 10 3
int f=(aout.println("a="+a+"\tb="+b+"\tf="+f); //5 10 5
}
}
//4.
class Demo2
{
public static void main(String[] args)
{
int m=0,n=3;
if(m>0)
if(n>2)
System.out.println("A");
else
System.out.println("B");
}
}
//没有结果//5.
public class Demo3
{
public static void main(String []args)
{
int i = 0, j = 5;
tp: for (;;)
{
i++;
for(;;)//i=1
{
if(i > j--)//当1>0时，j=-1
break tp; //跳出tp
}
}
System.out.println("i = " + i + ", j = "+ j); //i=1,j=-1;
}
}
//6.
class Demo4
{
public static void main(String[] args)
{
String foo="blue";
boolean[] bar=new boolean[2];
if(bar[0])//boolean类型的数组默认初始化值是false。
{
foo="green";
}
System.out.println(foo);
}
}
//打印结果b//7.
public class Demo5
{
public static void leftshift(int i, int j)
{
i+=j;
}
public static void main(String args[])
{
int i = 4, j = 2;
leftshift(i, j);
System.out.println(i); //4 和leftShift函数没关系。这里打印的i是在堆内存中的i，leftShift函数中的i在栈内存中
}
}
//9.
class Demo6
{
public static void main(String[] args)
{
String foo=args[1];
String bar=args[2];
String baz=args[3];
System.out.println(baz);
}
}
/*
d:\>java Test Red Green Blue
what is the value of baz?
A. baz has value of ""
B. baz has value of null
C. baz has value of "Red"
D. baz has value of "Blue"
E. baz has value of "Green"
F. the code does not compile
G. the program throw an exception
*/
//java.lang.ArrayIndexOutOfBoundsException: 3越界了
11.
/**
*
13.打印下列图形
*
* *
* * *
* * * *
* * * * *
*
*
*
*/
class Demo7
{
public static void main(String[] args)
{
printStar(10);
}
//明确功能的结果，打印图形，没有返回值
//位置变量有吗？？行数int。
public static void printStar(int num)
{
for(int i = 1;i<= num;i++)
{
for(int k=num;k>i;k--)
System.out.print(" ");
for(int j =1;j<=i;j++)
System.out.print("* ");
System.out.println();
}
}
}
小结
考察了for循环，函数的作用及特点，函数的重载和覆盖，自增，if else，数组脚标越界，数组。
练习四（26题）
原题带答案
注意：本段代码先给出所有题目
注：按Java规范书写程序代码，如果你认为程序有错误，请指出，并说明程序错误原因。
//1.写出程序结果
class Demo
{
public static void func()//throws Exception
{
try
{
throw new Exception();
}
finally
{
System.out.println("B");
}
}
public static void main(String[] args)
{
try
{
func();
System.out.println("A");
}
catch(Exception e)
{
System.out.println("C");
}
System.out.println("D");
}
}
/*编译失败：
如果func放上声明了该异常。结果是？B C D
*/====================================================================
//2.写出程序结果
class Test
{
Test()
{
System.out.println("Test");
}
}
class Demo extends Test
{
Demo()
{
//super();
System.out.println("Demo");
}
public static void main(String[] args)
{
new Demo();
new Test();
}
}
/*
Test
Demo
Test
*/分析：本题考的子类的实例化过程。
子类的实例化过程。
结论： 子类的所有的构造函数，默认都会访问父类中空参数的构造函数。 因为子类每一个构造函数内的第一行都有一句隐式super();
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。 子类中至少会有一个构造函数会访问父类中的构造函数。
====================================================================
//3.写出程序结果
interface A{}
class B implements A
{
public String func()
{
return "func";
}
}
class Demo
{
public static void main(String[] args)
{
A a=new B();//多态
System.out.println(a.func());
}
}编译失败：因为A接口中并未定义func方法。
在多态中非静态成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。在多态中，静态成员函数的特点： 无论编译和运行，都参考做左边。
====================================================================
//4.写出程序结果
class Fu
{
boolean show(char a)
{
System.out.println(a);
return true;
}
}
class Demo extends Fu
{
public static void main(String[] args)
{
int i=0;
Fu f=new Demo();
Demo d=new Demo();
for(f.show('A'); f.show('B')&&(i<2);f.show('C'))
{
i++;
d.show('D');
}
}
boolean show(char a)
{
System.out.println(a);
return false;
}
}
//A B在多态中非静态成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：非静态成员函数在多态调用时，编译看左边，运行看右边。在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。在多态中，静态成员函数的特点： 无论编译和运行，都参考做左边。
如果自定义类中也有比较相同的功能，没有必要重新定义。 只要沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。
====================================================================
//5.写出程序结果
interface A{}
class B implements A
{
public String test()
{
return "yes";
}
}
class Demo
{
static A get()
{
return new B();
}
public static void main(String[] args)
{
A a=get();
System.out.println(a.test());
}
}
//编译失败，因为A接口中没有定义test方法。
====================================================================
//6.写出程序结果:
class Super
{
int i=0;
public Super(String a)
{
System.out.println("A");
i=1;
}
public Super()
{
System.out.println("B");
i+=2;
}
}
class Demo extends Super
{
public Demo(String a)
{
//super();
System.out.println("C");
i=5;
}
public static void main(String[] args)
{
int i=4;
Super d=new Demo("A");
System.out.println(d.i);
}
}
//B C 5在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。
考的子类的实例化过程。
子类的实例化过程。
结论： 子类的所有的构造函数，默认都会访问父类中空参数的构造函数。 因为子类每一个构造函数内的第一行都有一句隐式super();
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。 子类中至少会有一个构造函数会访问父类中的构造函数。
====================================================================
//7.
interface Inter
{
void show(int a,int b);
void func();
}
class Demo
{
public static void main(String[] args)
{
//补足代码；调用两个函数，要求用匿名内部类
in.show(4,5);
in.func();
}
}内部类的访问规则：
1，内部类可以直接访问外部类中的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
2，外部类要访问内部类，必须建立内部类对象。访问格式：
1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。 可以直接建立内部类对象。
格式 外部类名.内部类名
变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();2,当内部类在成员位置上，就可以被成员修饰符所修饰。
比如
private：将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。在外部其他类中，如何直接访问static内部类的非静态成员呢？ `new Outer.Inner().function();` 在外部其他类中，如何直接访问static内部类的静态成员呢？ `Outer.Inner.function();`注意：当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static的。当描述事物时，事物的内部还有事物，该事物用内部类来描述。 因为内部事务在使用外部事物的内容。
直接访问内部类中的成员。
Outer.Inner in = new Outer().new Inner();
in.function();内部类定义在局部时，
1，不可以被成员修饰符修饰
2，可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
匿名内部类:
1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提： 内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。
===============================================================
//8.写出程序结果
class TD
{
int y=6;
class Inner
{
static int y=3;
void show()
{
System.out.println(y);
}
}
}
class TC
{
public static void main(String[] args)
{
TD.Inner ti=new TD().new Inner();
ti.show();
}
}编译失败，非静态内部类中不可以定义静态成员。
内部类中如果定义了静态成员，该内部类必须被静态修饰。
====================================================================
9.选择题，写出错误答案错误的原因，用单行注释的方式。
class Demo
{
int show(int a,int b){return 0;}
}下面那些函数可以存在于Demo的子类中。
A.public int show(int a,int b){return 0;}//可以，覆盖。
B.private int show(int a,int b){return 0;}//不可以，权限不够。
C.private int show(int a,long b){return 0;}//可以，和父类不是一个函数。没有覆盖，相当于重载。
D.public short show(int a,int b){return 0;}//不可以，因为该函数不可以和给定函数出现在同一类中，或者子父类中。
E.static int show(int a,int b){return 0;}//不可以，静态只能覆盖静态。
9.（我的答案）
选择题，写出错误答案错误的原因，用单行注释的方式。
class Demo
{
int show(int a,int b){return 0;}
}下面那些函数可以存在于Demo的子类中。
A.public int show(int a,int b){return 0;}//可以
B.private int show(int a,int b){return 0;}//不可以，子类的权限必须大于父类
C.private int show(int a,long b){return 0;}//可以，子类重载了父类的方法
D.public short show(int a,int b){return 0;}//不可以，子类中不可以存在返回值不确定的函数
E.static int show(int a,int b){return 0;}//可以，相当于覆盖×
====================================================================
10.
写出this关键字的含义，final有哪些特点？
this：代表本类对象，哪个对象调用this所在函数，this就代表哪个对象。
final: 1,修饰类，变量(成员变量，静态变量，局部变量)，函数。
2，修饰的类不可以被继承。
3，修饰的函数不可以被覆盖。
4，修饰的变量是一个常量，只能赋值一次。
5，内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。
====================================================================
//11.写出程序结果：
class Fu
{
int num=4;
void show()
{
System.out.println("showFu");
}
}
class Zi extends Fu
{
int num=5;
void show()
{
System.out.println("showZi");
}
}
class T
{
public static void main(String[] args)
{
Fu f=new Zi();
Zi z=new Zi();
System.out.println(f.num);
System.out.println(z.num);
f.show();
z.show();
}
}4
5
showZi
showZi
在多态中非静态成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：非静态成员函数在多态调用时，编译看左边，运行看右边。在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。在多态中，静态成员函数的特点： 无论编译和运行，都参考做左边。
====================================================================
12.
interface A
{
void show();
}
interface B
{
void add(int a,int b);
}
class C implements A,B
{
//程序代码
private int a,b;
//private int sum;
public void add(int a,int b)
{
this.a =a;
this.b = b;
//sum = a+b;
}
public void show()
{
System.out.println(a+b);
//System.out.println(sum);
}
}
class D
{
public static void main(String[] args)
{
C c=new C();
c.add(4,2);
c.show();//通过该函数打印以上两个数的和。
}
}====================================================================
13.
写出程序结果
class Demo
{
public static void main(String[] args)
{
try
{
showExce();
System.out.println("A");
}
catch(Exception e)
{
System.out.println("B");
}
finally
{
System.out.println("C");
}
System.out.println("D");
}
public static void showExce()throws Exception
{
throw new Exception();
}
}
// B C D====================================================================
14.
写出程序结果
class Super
{
int i=0;
public Super(String s)
{
i=1;
}
}
class Demo extends Super
{
public Demo(String s)
{
i=2;
}
public static void main(String[] args)
{
Demo d=new Demo("yes");
System.out.println(d.i);
}
}
//编译失败，因为父类中缺少空参数的构造函数。
//或者子类应该通过super语句指定要调用的父类中的构造函数。====================================================================
15.
写出程序结果
class Super
{
public int get(){return 4;}
}
class Demo15 extends Super
{
public long get(){return 5;}
public static void main(String[] args)
{
Super s=new Demo15();
System.out.println(s.get());
}
}编译失败，因为子类父类中的get方法没有覆盖。但是子类调用时候不能明确返回的值是什么类型。
所以这样的函数不可以存在子父类中。
====================================================================
16.
写出程序结果：
class Demo
{
public static void func()
{
try
{
throw new Exception();
System.out.println("A");
}
catch(Exception e)
{
System.out.println("B");
}
}
public static void main(String[] args)
{
try
{
func();
}
catch(Exception e)
{
System.out.println("C");
}
System.out.println("D");
}
}
//编译失败。 因为打印“A”的输出语句执行不到。记住：throw单独存在，下面不要定义语句，因为执行不到。
====================================================================
17.
class Demo
{
public void func()
{
//位置1；
new Inner();
}
class Inner{}
public static void main(String[] args)
{
Demo d=new Demo();
// 位置2
new Inner();//不可以，因为主函数是静态的。如果访问inner需要被static修饰。
}
}A.在位置1写 new Inner();//ok
B.在位置2写new Inner();
C.在位置2写 new d.Inner();//错误，格式错误。 new new Demo().Inner();
D.在位置2写new Demo.Inner();//错误，因为inner不是静态的。
内部类的访问规则：
1，内部类可以直接访问外部类中的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
2，外部类要访问内部类，必须建立内部类对象。访问格式：
1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。 可以直接建立内部类对象。
格式 外部类名.内部类名
变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();2,当内部类在成员位置上，就可以被成员修饰符所修饰。
比如
private：将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。在外部其他类中，如何直接访问static内部类的非静态成员呢？ `new Outer.Inner().function();` 在外部其他类中，如何直接访问static内部类的静态成员呢？ `Outer.Inner.function();`注意：当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static的。当描述事物时，事物的内部还有事物，该事物用内部类来描述。 因为内部事务在使用外部事物的内容。
直接访问内部类中的成员。
Outer.Inner in = new Outer().new Inner();
in.function();内部类定义在局部时，
1，不可以被成员修饰符修饰
2，可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
匿名内部类:
1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提： 内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。
====================================================================
18.
写出程序结果
class Exc0 extends Exception{}
class Exc1 extends Exc0{}
class Demo
{
public static void main(String[] args)
{
try
{
throw new Exc1();
}
catch(Exception e)
{
System.out.println("Exception");
}
catch(Exc0 e)
{
System.out.println("Exc0");
}
}
}
//编译失败.多个catch时，父类的catch要放在下面。====================================================================
19.
interface Test
{
void func();
}
class Demo
{
public static void main(String[] args)
{
//补足代码；(匿名内部类)
new Demo().show(new Test()
{
public void func(){}
});
}
void show(Test t)
{
t.func();
}
}====================================================================
20.
写出程序结果
class Test
{
public static String output="";
public static void foo(int i)
{
try
{
if(i==1)
throw new Exception();
output+="1";
}
catch(Exception e)
{
output+="2";
return;
}
finally
{
output+="3";
}
output+="4";
}
public static void main(String args[])
{
foo(0);
System.out.println(output);//134
foo(1);
System.out.println(output); //13423
}
} ====================================================================
21.
建立一个图形接口，声明一个面积函数。圆形和矩形都实现这个接口，并得出两个图形的面积。
注：体现面向对象的特征，对数值进行判断。用异常处理。不合法的数值要出现“这个数值是非法的”提示，不再进行运算。
====================================================================
22.
补足compare函数内的代码，不许添加其他函数。
class Circle
{
private static double pi=3.14;
private double radius;
public Circle(double r)
{
radius=r;
}
public static double compare(Circle[] cir)
{
//程序代码//其实就是在求数组中的最大值。
int max = 0;//double max = cir[0].radius;
for(int x=1; xif(cir[x].radius>cir[max].radius)
max = x;
}
return cir[max].radius;
}
}
class TC
{
public static void main(String[] args)
{
Circle cir[]=new Circle[3];//创建了一个类类型数组。
cir[0]=new Circle(1.0);
cir[1]=new Circle(2.0);
cir[2]=new Circle(4.0);
System.out.println("最大的半径值是："+Circle.compare(cir));
}
} ====================================================================
23.
写出程序结果
public class Demo
{
private static int j = 0;
private static boolean methodB(int k)
{
j += k;
return true;
}
public static void methodA(int i)
{
boolean b;
b = i < 10 | methodB (4);
b = i < 10 || methodB (8);
}
public static void main (String args[] )
{
methodA (0);
System.out.println(j); //4
}
}====================================================================
24.
假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。
====================================================================
25.
在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，
如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），
否则，返回-1。要搜索的字符数组和字符都以参数形式传递传递给该方法，
如果传入的数组为null，应抛出IllegalArgumentException异常。
在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确，
例如，字符不存在，字符存在，传入的数组为null等。
getIndex(null,'a');
public int getIndex(char[] arr,char key)
{
if(arr==null)
throw new IllegalArgumentException("数组为null");
for(int x=0; xif(arr[x]==key)
return x;
}
return -1;
}
====================================================================
26.
补足compare函数内的代码，不许添加其他函数。
class Circle
{
private double radius;
public Circle(double r)
{
radius=r;
}
public Circle compare(Circle cir)
{
//程序代码
/*
if(this.radius>cir.radius)
return this;
return cir;
*/
return (this.radius>cir.radius)?this: cir;
}
}
class TC
{
public static void main(String[] args)
{
Circle cir1=new Circle(1.0);
Circle cir2=new Circle(2.0);
Circle cir;
cir=cir1.compare(cir2);
if(cir1==cir)
System.out.println("圆1的半径比较大");
else
System.out.println("圆2的半径比较大");
}
}我的代码
注意：本段代码Demo7就对应第7题，Demo22就对应第22题，其他同理
class Demo
{
public static void func()throws Exception
{
try
{
throw new Exception();
}
finally
{
System.out.println("B");
}
}
public static void main(String[] args)
{
try
{
func();
System.out.println("A");
}
catch(Exception e)
{
System.out.println("C");
}
System.out.println("D");
}
}
//编译失败了
/*Demo.java:8: 错误: 未报告的异常错误Exception; 必须对其进行捕获或声明以便抛出
throw new Exception();
*/
//如果func放上声明了该异常。结果是？B C D
class Test
{
Test()
{
System.out.println("Test");
}
}
class Demo2 extends Test
{
Demo2()
{
//super();
System.out.println("Demo");
}
public static void main(String[] args)
{
new Demo2();
new Test();
}
}class Test
{
Test()
{
System.out.println("Test");
}
}
class Demo2 extends Test
{
Demo2()
{
//super();
System.out.println("Demo");
}
public static void main(String[] args)
{
new Demo2();
new Test();
}
}interface A{ }
class B implements A
{
public String func()
{
return "func";
}
}
class Demo3
{
public static void main(String[] args)
{
A a=new B();//多态
System.out.println(a.func());
}
}
/*Demo3.java:14: 错误: 找不到符号
System.out.println(a.func());
^
符号: 方法 func()
位置: 类型为A的变量 a
1 个错误*/class Fu
{
boolean show(char a)
{
System.out.println(a);
return true;
}
}
class Demo4 extends Fu
{
public static void main(String[] args)
{
int i=0;
Fu f=new Demo4();
Demo4 d=new Demo4();
for(f.show('A'); f.show('B')&&(i<2);f.show('C'))
{
i++;
d.show('D');
}
}
boolean show(char a)
{
System.out.println(a);
return false;
}
}//interface A{String test();}
interface A{}
class B implements A
{
public String test()
{
return "yes";
}
}
class Demo5
{
static A get()
{
return new B();
}
public static void main(String[] args)
{
A a=get();
System.out.println(a.test());
}
}
/*Demo5.java:18: 错误: 找不到符号
System.out.println(a.test());
^
符号: 方法 test()
位置: 类型为A的变量 a
1 个错误*/class Super
{
int i=0;
public Super(String a)
{
System.out.println("A");
i=1;
}
public Super()
{
System.out.println("B");
i+=2;
}
}
class Demo6 extends Super
{
public Demo6(String a)
{
//super();//注意这条是隐式的
System.out.println("C");
i=5;
}
public static void main(String[] args)
{
int i=4;
Super d=new Demo6("A");
System.out.println(d.i);
}
}interface Inter
{
void show(int a,int b);
void func();
}
class Demo7
{
public static void main(String[] args)
{
//补足代码；调用两个函数，要求用匿名内部类
Inter in = new Inter()
{
public void show(int a,int b)
{
System.out.println(a+b);
}
public void func()
{
System.out.println("匿名内部类已经实现");
}
};
in.show(3,4);
in.func();
}
}
/*Demo7.java:23: 错误: 从内部类中访问本地变量b; 需要被声明为最终类型
System.out.println(a+b);
*/
interface A
{
void show();
}
interface B
{
void add(int a,int b);
}
class C implements A,B
{
//程序代码
private int a,b;
//private int sum;
public void add(int a,int b)
{
this.a =a;
this.b = b;
//sum = a+b;
}
public void show()
{
System.out.println(a+b);
//System.out.println(sum);
}
}
class Demo12
{
public static void main(String[] args)
{
C c=new C();
c.add(4,2);
c.show();//通过该函数打印以上两个数的和。
}
}class Super
{
int i=0;
public Super(String s)
{
//i=1;
}
}
class Demo14 extends Super
{
public Demo14(String s)
{
super(s);
//i=2;
}
public static void main(String[] args)
{
int i =2;
Super s=new Demo14("yes");
System.out.println(s.i);
}
}
/*Demo14.java:12: 错误: 无法将类 Super中的构造器 Super应用到给定类型;
{
^
需要: String
找到: 没有参数
原因: 实际参数列表和形式参数列表长度不同
1 个错误
*/class Super
{
public int get(){return 4;}
}
class Demo15 extends Super
{
public int get(){return 5;}
public static void main(String[] args)
{
Super s=new Demo15();
System.out.println(s.get());
}
}
/*
Demo15.java:7: 错误: Demo15中的get()无法覆盖Super中的get()
public long get(){return 5;}
^
返回类型long与int不兼容
1 个错误
*/class Demo16
{
public static void func()
{
try
{
throw new Exception();
//System.out.println("A");
}
catch(Exception e)
{
System.out.println("B");
}
}
public static void main(String[] args)
{
try
{
func();
}
catch(Exception e)
{
System.out.println("C");
}
System.out.println("D");
}
}
/*Demo16.java:8: 错误: 无法访问的语句
System.out.println("A");
^
1 个错误
*/
//改正后输出B Dclass Exc0 extends Exception{}
class Exc1 extends Exc0{}
class Demo18
{
public static void main(String[] args)
{
try
{
throw new Exc1();
}
catch(Exc0 e)
{
System.out.println("Exc0");
}
catch(Exception e)
{
System.out.println("Exception");
}
}
}
interface Test
{
void func();
}
class Demo19
{
public static void main(String[] args)
{
//补足代码；(匿名内部类)
//在外部其他类中，如何直接访问static内部类的非静态成员呢？
//new Outer.Inner().function();
new Demo19().show(new Test()
{
public void func()
{
System.out.println("匿名内部类已经实现");
}
});
}
void show(Test t)
{
t.func();
}
}
class Demo20
{
public static String output="";
public static void foo(int i)
{
try
{
if(i==1)
throw new Exception();
output+="1";
}
catch(Exception e)
{
output+="2";
//return; //return不能结束finally，可以结束最后一条语句
//System.exit(0);这条语句可以结束finally
}
finally
{
output+="3";
}
output+="4";
}
public static void main(String args[])
{
foo(0);
System.out.println(output);//134
foo(1);
System.out.println(output); //13423
}
}
/**
*21.
建立一个图形接口，声明一个面积函数。圆形和矩形都实现这个接口，并得出两个图形的面积。
注：体现面向对象的特征，对数值进行判断。用异常处理。不合法的数值要出现“这个数值是非法的”提示，不再进行运算。
*
*
*
*
*
*/
interface Shape
{
double getArea();
}
class IllegalException extends RuntimeException
{
IllegalException(String message)
{
super(message);
}
}
class Circle implements Shape
{
private double radius;
private final static double PI = 3.1415926;
Circle(double radius)
{
if(radius<0)
throw new IllegalException("非法数据：数据为负数，不符合实际，请不要再进行运算了");
this.radius = radius;
}
public double getArea()
{
return PI*radius*radius;
}
}
class Rec implements Shape
{
private double length;
private double width;
Rec(double length,double width)
{
if(length < 0|| width < 0)
throw new IllegalException("非法数据：数据为负数，不符合实际，请不要再进行运算了");
this.length = length;
this.width = width;
}
public double getArea()
{
return length*width;
}
}
class Demo21
{
public static void main(String[] args)
{
Circle c = new Circle(3.0);
System.out.println(c.getArea());
Rec r= new Rec(-2.0,3.0);
System.out.println(r.getArea());
}
}/**
*22.
补足compare函数内的代码，不许添加其他函数。
*
*
*/
class DemoCircle
{
private static double pi=3.14;
private double radius;
public DemoCircle(double r)
{
radius=r;
}
public static double compare(DemoCircle[] cir)
{
//程序代码//其实就是在求数组中的最大值。
//定义max=0，为数组脚标
/*
int max = 0;
for( int i = 1; i < cir.length; i++)
{
if(cir[max].radius < cir[i].radius)
max=i;
}
return cir[max].radius;
*/
//方法二，定义double max = cir[0].radius;
double max = cir[0].radius;
for(int i = 1; i< cir.length; i++)
{
if(cir[i].radius > max)
max = cir[i].radius;
}
return max;
}
}
class Demo22
{
public static void main(String[] args)
{
DemoCircle cir[]=new DemoCircle[3];//创建了一个类类型数组。
cir[0]=new DemoCircle(1.0);
cir[1]=new DemoCircle(2.0);
cir[2]=new DemoCircle(4.0);
System.out.println("最大的半径值是："+DemoCircle.compare(cir));
}
}
/*Xs先读主函数，判断所需函数的功能
主函数创建了一个类型为DemoCircle的数组（类类型数组）
然后数组cir元素存放的是DemoCircle初始化后对象的地址值
最后要求输出的是最大的半径值。
所以，compare就是求数组中元素所指对象的成员变量的半径值的最大值
求数组中的最大值：既可以定义一个max=cir[0].radius；
也可以换一种思维，定义数组的脚标，那么max=0;然后对脚标进行操作。
*/
public class Demo23
{
private static int j = 0;
private static boolean methodB(int k)
{
j += k;
return true;
}
public static void methodA(int i)
{
boolean b;
b = i < 10 | methodB (4);
b = i < 10 || methodB (8);
}
public static void main (String args[] )
{
methodA (0);
System.out.println(j); //4
}
}/*
*24.
假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。
分析：
名词提炼法：员工，姓名，工号，工资；经理，奖金；
要求：用继承设计两个类，员工类和经理类。
类：员工，经理。经理继承员工。
方法：进行属性访问。参数是属性（姓名，工号，工资，奖金）
步骤：
先建立个一个员工类，包含三个属性：姓名，工号，工资；一个构造函数，一个访问属性的方法。
再建立一个经理类，继承员工类，并增加奖金属性，重载构造函数，覆盖访问属性的方法。
最后测试。
*/
/*
class Employee
{
String name;
String id;
double salary;
Employee(String name ,String id,double salary)
{
this.name = name;
this.id = id;
this.salary = salary;
}
public void show()
{
System.out.println("员工姓名："+name+" 工号："+id+"工资"+salary+"\t");
}
}
class Manager extends Employee
{
double bonus;
Manager(String name, String id,double salary,double bonus)
{
super(name,id,salary);
this.bonus = bonus;
}
public void show()
{
System.out.println("员工姓名："+name+" 工号："+"工资"+salary+"奖金："+bonus+"\t");
}
}
class Demo24
{
public static void main(String[] args)
{
Employee e = new Employee("张三","YG2015001",3000);
Manager m = new Manager("李四","JL2015002",6000,1000);
e.show();
m.show();
}
}
*/
/*上面的设计出现了一些错误。
员工分为普通员工和经理。
所以要定义的类有三个。
此外，要特别注意的地方是，员工类的属性应该是默认修饰，千万不要用private私有了。
私有化之后子类就继承不到该属性了，这是很危险的，特别是在与数据库进行操作的时候！
*/
//修正后的代码
class Employee
{
String name;
String id;
double salary;
Employee(String name ,String id,double salary)
{
this.name = name;
this.id = id;
this.salary = salary;
}
public void show()
{
System.out.println("员工姓名："+name+" 工号："+id+"工资："+salary+"\t");
}
}
class CommonEmployee extends Employee
{
CommonEmployee (String name,String id,double salary)
{
super(name,id,salary);
}
}
class Manager extends Employee
{
private double bonus;//在这里是经理私有的
Manager(String name, String id,double salary,double bonus)
{
super(name,id,salary);
this.bonus = bonus;
}
public void show()
{
System.out.println("经理姓名："+name+" 工号："+id+"工资："+salary+"奖金："+bonus+"\t");
}
}
class Demo24
{
public static void main(String[] args)
{
CommonEmployee e = new CommonEmployee("张三","YG2015001",3000);
Manager m = new Manager("李四","JL2015002",6000,1000);
e.show();
m.show();
}
}/*在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，
如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），
否则，返回-1。要搜索的字符数组和字符都以参数形式传递传递给该方法，
如果传入的数组为null，应抛出IllegalArgumentException异常。
在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确，
例如，字符不存在，字符存在，传入的数组为null等。
*/
/*分析：
方法：
明确功能返回的结果：返回字符在数组的位置。int
有没有未知变量：字符数组char[],字符char
异常处理：
自定义异常：如果传入的数组为null，应抛出IllegalArgumentException异常。
要求测试数据要多，要覆盖全面的情况。
*/
class Demo25
{
public static void main(String[] args)
{
char[] array = new char[]{'a','b','c','d','e'};
char[] a=null;
System.out.println(getChar(array,'a'));
System.out.println(getChar(array,'e'));
System.out.println(getChar(a,'e'));
System.out.println(getChar(array,'f'));
}
public static int getChar(char[] array,char c )
{
if(array==null)
throw new IllegalArgumentException("数组为空");
for(int i =0;iif(c==array[i])
return i;//找到就返回，结束函数
}
return -1;//m没找到就返回-1
}
} /*26.
补足compare函数内的代码，不许添加其他函数。
*/
class Circle
{
private double radius;
public Circle(double r)
{
if(r<0)
throw new IllegalArgumentException("非法数据，请不要输入负数");
this.radius=r;
}
public Circle compare(Circle cir)//因为IllegalArgumentException instanceof RuntimeException 所以这里不用声明
{
//程序代码
/*if(radius>cir.radius)
return this;
return cir;*/
return (radius>cir.radius)?this:cir;
}
}
class Demo26
{
public static void main(String[] args)
{
Circle cir1=new Circle(1.0);
Circle cir2=new Circle(2.0);
Circle cir;
cir=cir1.compare(cir2);//返回最大半径的圆
if(cir1==cir)
System.out.println("圆1的半径比较大");
else
System.out.println("圆2的半径比较大");
}
}
小结
考的子类的实例化过程。。
结论： 子类的所有的构造函数，默认都会访问父类中空参数的构造函数。 因为子类每一个构造函数内的第一行都有一句隐式super();
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。 子类中至少会有一个构造函数会访问父类中的构造函数。
在多态中非静态成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。在多态中，成员变量的特点： 无论编译和运行，都参考左边(引用型变量所属的类)。
在多态中，静态成员函数的特点： 无论编译和运行，都参考做左边。
如果自定义类中也有比较相同的功能，没有必要重新定义。 只要沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。
内部类的访问规则：
1，内部类可以直接访问外部类中的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
2，外部类要访问内部类，必须建立内部类对象。访问格式：
1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。 可以直接建立内部类对象。
格式 外部类名.内部类名
变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();2,当内部类在成员位置上，就可以被成员修饰符所修饰。
比如
private：将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。在外部其他类中，如何直接访问static内部类的非静态成员呢？ `new Outer.Inner().function();` 在外部其他类中，如何直接访问static内部类的静态成员呢？ `Outer.Inner.function();`注意：当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static的。当描述事物时，事物的内部还有事物，该事物用内部类来描述。 因为内部事务在使用外部事物的内容。
直接访问内部类中的成员。
Outer.Inner in = new Outer().new Inner();
in.function();内部类定义在局部时，
1，不可以被成员修饰符修饰
2，可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
匿名内部类:
1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提： 内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。this：代表本类对象，哪个对象调用this所在函数，this就代表哪个对象。
final:
1,修饰类，变量(成员变量，静态变量，局部变量)，函数。
2，修饰的类不可以被继承。
3，修饰的函数不可以被覆盖。
4，修饰的变量是一个常量，只能赋值一次。
5，内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。