小华刚刚参加了一个编译器课程
1. java中显示特殊的数学字符
还有两天,由于时间关系,尽量帮你答哈,呵呵你也太小气了吧,5分不如不给呵呵开个玩笑
1.不存在的,基本单位:类
2.一般是从main()方法开始的
3.构造函数在类创建对像时无条件调用,而一般方法则要要对像去才可以调用,当然static方法直接用类名也可以调用
4.print()或println()两个方法,如System.out.println();
5.和你主类名必需完全相同,注意大小写,也就是public类的类名
6.javac 文件名.java
7.是.class文件
8.java 文件名(没有.java)
9.
public class HelloWorld{
public static void main(String]
args){
System.out.println("Helloworld");
}
}
第二部分:
1.标识符就是用户自己启的名字,有类名,方法名,变量名,要求:1.区分大小写,2.不能以数字开头3.不能要关键字
顺便说一哈在java中 还有一个不成文的约定那就是:类名可以用若干个单词组合起来,第个单词的第一个字母要大小,变量名一般用小写,方法名的第一个字母用小写,常量名全用大写,可用下划线___分开
2.
有六个:byte(1) short(2) int(4) long(8) float(4) double(8) 括号里表示其占的字节数
3.类和方法的前面不加关键字,编译器会给它一个默认的关键字default或friendly表示在同一个包在可以访问它.
4.不是很清,不过你可以用StringBuffer类的append()方法追加
5.这两个都是一个位移运算符,都表示右移一位,不同的是">>"若被移动的数为正数,则最左填为0,否则填为1,而">>>"不管正数负数最左为0,(请注意:这都是在二进制的情况下进行的,了解一下就行了,用得不多)
6.
public class Max{
static int max=0,min=0;
static void swap(int a,int b,int c){
max=a>b?a:b;
max=max>c?max:c;
min=a<b?a:b;
min=c<min?c:min;
System.out.println(a+" "+b+" "+c+"这三个数的最大值是:"+max);
System.out.println("最小的数是:"+min);
}
public static void main(String[] args){
swap(-1,0,1);//你可以在这里改变它的参数,比较别的数
}
}
7.
public class Factorial{
public static void main(String[] args){
int factorial=10;
for(int i=factorial-1;i>0;i--){
factorial=factorial*i;
}
System.out.println("10!="+factorial);
}
}
8.
public class EatPeach
{
public static void main(String[] args)
{
int n=1;
for(int i=10;i>0;i--)
{
System.out.println("第"+i+"天吃了"+n+"个桃子");
n=(n+1)*2;
}
}
}
第三部分:
1.类就是整个java程序执行的模块,由成员变量和成员方法(也叫函数)组成
2.修饰符你说的是关键字吧:
public(共用访问符,无能什么地方都可以访问),
private 只能同一个包可以访问
protected 允许子类继承并修改
static 静态存偖区,在程序执行完后才释放内存
final 常量,不能改改的量
主要的就是这几个,当然你的题议还有int double long boolean float 等等这些你应该知道的就不用说了
3.类的构造函数将会在创建类的对像的第一时间得到调用,而普通方法要用对像才能调用,(当然如果是static方法的话也可以用类然直接调用)
4.Math类和Random类
5.
public(共用访问符,无能什么地方都可以访问),
private 只能同一个包可以访问
protected 允许子类继承并修改
final 用在类的前面不能继承它
6.静太成员一般是在程序执行完后才释放内存,反之则是在当前方法完毕就释放,而main就是这个性质来的,要加static
7.抽像类是不能完成某个具体的动作的,也就是一个接口,(注意只要有一个抽像方法在内的类必定定义为抽像类)
非抽像类刚刚相反
8.抽像方法没有方法体,如abstract void f();非抽像方法有方法体如void f(){}
9..(最终类，最终方法，最终属性就是在类,方法和变量的前加final)
含义就是:当放在类前,降低了此类的访问权限,重要的是别的类不能继承它
当放在方法前:表示这个方法不可以修改,更不得覆盖它
当放到变量前:也就是我们讲的常量,你一定晓得是不变的量,这我就不用多说了
10.
class Employee{
private String name;
private int salary,hireDay;
Employee(String name,int salary,int hireDay){
this.name=name;
this.salary=salary;
this.hireDay=hireDay;
}
public String getName(){
return name;
}
public int getSalary(){
return salary;
}
public int getHireDay(){
return hireDay;
}
}
//注:你说的三个私有方法用一个构造器完成要简单一些,如果你一定要那么做,只要把三个参数改成//三个方法就可以了
//11.
public class EmployeeTest{
public static void main(String[] args){
Employee[] e={
new Employee("小明",800,10),
new Employee("小强",600,15),
new Employee("小华",900,12)
};
System.out.println("name "+" salary"+" hireDay");
for(int i=0;i<e.length;i++)
System.out.println(e[i].getName()+" "+e[i].getSalary()+
" "+e[i].getHireDay());
}
}
注意你要先编译第一个，第二个才能运行
第四部分:
1.这个题不是很好,意思不够明确,这里我说两种吧多态和覆盖都是继承.当然接口也可以继承,所以我说这个题出得不好!
2.当我们使用关键字extends时就表示一个类继承了另一个类,也就是子类和父类,对于方法来说有下面三种:
(1).方法继承,在子类中不需定义就拥有的父类在的方法
(2).方法的覆盖:是指返回的类型,形式参数和方法名都相同,改变其方法体.
(3).方法的重载:则是方法名相同,形式参数不同的几个方法,如:洗车,洗衣服,有一个是相同的,就是洗这个属性(方法名),不同的是车,衣服(参数),所以我们不必这样说(用洗车的方法来洗车,用洗衣服的方法来洗衣服)就能分开洗车是做什么和洗衣服是做什么,正是如此编译器是通过这种方式来识别调用哪个方法的
(4.abstract class Employee{
abstract int getSalary();
}
class CommonEmployee extends Employee{
private int salary;
CommonEmployee(int salary){
this.salary=salary;
}
public int getSalary(){
return salary;
}
}
class Manager extends Employee{
private int salary;
Manager(int salary){
this.salary=salary;
}
public int getSalary(){
return salary;
}
}
public class SimpleTest1{
public static void main(String[] args){
Employee com=new CommonEmployee(1200);
Employee man=new Manager(2000);
System.out.println("职工的工次是:"+com.getSalary());
System.out.println("经理的工资是:"+man.getSalary());
}
}
5.java的多态性是指:许多类它们有一个共同的特点,我们如果每个特征我们都去写的话会用很多的代码也很麻烦,那么解决这一问题的正是多态性,
那如何解决呢??我们可以把这些相同的特点写成一个接口或抽像类,然后只要有这个特征的类继承它就可以了,其中有一个很经典的例子:画图,我们可以创建一个图形的抽像类,因为三角形啊,正方形啊,都是图形,于是可以继承这个类,于是我们可以用这些图形来继承上面所创建的图形类,如果你不是很理解的话我把这个例子写到下面你仔细看就会明白的:
import java.util.*;
class Shape{
void draw(){}
void erase(){}
}
class Circle extends Shape{
void draw(){
System.out.println("Circle.draw()");
}
void erase(){
System.out.println("Circle.erase");
}
}
class Square extends Shape{
void draw(){
System.out.println("Square.draw()");
}
void erase(){
System.out.println("Square.erase()");
}
}
class Triangle extends Shape{
void draw(){
System.out.println("Triangle.draw()");
}
void erase(){
System.out.println("Triangle.erase()");
}
}
//和以上是组合的关系
class RandomShapeGenerator{
private Random rand=new Random();
public Shape next(){//反回一个对像
switch(rand.nextInt(3)){
default:
case 0:return new Circle();
case 1:return new Square();
case 2:return new Triangle();
}
}
}
public class Shapes{
private static RandomShapeGenerator gen=
new RandomShapeGenerator();
public static void main(String[] args){
Shape[] s=new Shape[9];
for(int i=0;i<s.length;i++)
s[i]=gen.next();//给引用填对像
for(int i=0;i<s.length;i++)
s[i].draw();//能过动态帮定调用哪一个方法
}
}
如果还是看不会的话,那么请你打开书好好看抽像类,然后再看看接口,你不会看不懂的,去试试!!!!
6.this和super有一个最易理解的就是this表示当前对像,super表示可以引用父类中的构造函数,
当然它们的功能远远不止这些!这我就不多说了
7.
如果把子类的对像转化为父类中的对像,我们称为向上转型,一般这个好实现也很重要,用得也多,可以创建一个子类对像,然后传给父类的引用,这种说法我不知道科不科学,也很不好理解,但事实就是如此,如上面的图形例子中:
Shape next={ new Circle(),
new Square(),
new Triangle()
};
这看起来每个类的对像都给了同一个父类(Shape),这有一个问题它们表示同一对像吗?你看以把它们看成同一引用,然后事不是你想的这样,next[1].draw(),next[1].draw(),next[2].draw()它们调的并不是同一个方法,而分别调用的是Circle Square Triangle的中的draw()方法,你可以亲自运行上面的事例就知道了,好了有点说得多了,如果有问题的话加我QQ吧460566995
8.默认构造函数是指在我们没有构造函数时编译器自动帮我们加上一个构造函数一般为:类(){},它没有任何参数,也没有方法体
好了,我手都写软了,就给你答这么多吧,还有没有答完的希望后者能补上谢谢,我这两天也没有时间了,
如果没有人答你又一定要要的话可以加我的QQ问我好了,好好看里面有我的QQ的
2. 时钟问题
教学目标
时钟问题可以看做是一个特殊的圆形轨道上2人追及或相遇问题，不过这里的两个“人”分别是时钟的分针和时针。
时钟问题有别于其他行程问题是因为它的速度和总路程的度量方式不再是常规的米每秒或者千米每小时，而是2个指针“每分钟走多少角度”或者“每分钟走多少小格”。对于正常的时钟，
具体为：整个钟面为360度，上面有12个大格，每个大格为30度；60个小格，每个小格为6度。
分针速度：每分钟走1小格，每分钟走6度
时针速度：每分钟走十二分之一小格，每分钟走0.5度
注意：但是在许多时钟问题中，往往我们会遇到各种“怪钟”，或者是“坏了的钟”，它们的时针和分针每分钟走的度数会与常规的时钟不同，这就需要我们要学会对不同的问题进行独立的分析。
要把时钟问题当做行程问题来看，分针快，时针慢，所以分针与时针的问题，就是他们之间的追及问题。另外，在解时钟的快慢问题中，要学会十字交叉法。
例如：时钟问题需要记住标准的钟，时针与分针从一次重合到下一次重合，所需时间为65又11分之5 分。
总结
基本思路：
1、按照行程问题中的思维方法解题；
2、不同的表当成速度不同的运动物体；
3、路程的单位是分格（表一周为60分格）；
4、时间是标准表所经过的时间；
合理利用行程问题中的比例关系；
解题技巧/思路：
数量关系技巧包含了数学运算技巧和数字推理技巧两大部分，公务员考试数学运算是最为考生所头疼，其所占分值高并且难度也高。
时钟问题常见的考查形式是钟面追及。钟面追及问题通常是研究时针、分针之间的位置的问题，如“分针和时针的重合、垂直、成一直线、成多少度角”等。时针、分针朝同一方向运动，但速度不同，类似于行程问题中的追及问题。解决此类问题的关键在于确定时针、分针的速度或速度差。
具体的解题过程中可以用分格法，即时钟的钟面圆周被均匀分成60小格，每小格我们称为1分格。分针每小时走一圈，即60分格，而时针每小时只走5分格，因此分针每分钟走1分格，时针每分钟走1/12分格。速度差为11/12分格。也可以用度数法，即从角度观点看，钟面圆周一周是360°，分针每分钟转360/60度，即分针速度为6°/min，时针每小时转360/12=30度，所以每分钟的速度为30°/60，即0.5°/min。分针与时针的速度差为5.5°/min。
例题精讲
模块一、时针与分针的追及与相遇问题
【例 1】 王叔叔有一只手表，他发现手表比家里的闹钟每小时快 30 秒.而闹钟却比标准时间每小时慢 30 秒，那么王叔叔的手表一昼夜比标准时间差多少秒？
【解析】 闹钟比标准的慢 那么它一小时只走（3600-30）÷3600个小时，手表又比闹钟快 那么它一小时走（3600+30）/3600个小时，则标准时间走1小时 手表则走（3600-30）÷3600X（3600+30）÷3600个小时，则手表每小时比标准时间慢1—【（3600-30）÷3600X（3600+30）÷3600】=1—14399÷14400=1÷14400个小时，也就是1÷14400X3600=四分之一秒，所以一昼夜24小时比标准时间慢四分之一乘以24等于6秒
【解析2】由题干可得手表：闹钟=（3600+30）：3600，闹钟：标准=（3600-30）：3600，可以得到手表：标准=（3600+30）*（3600-30）：3600*3600，则标准时间走1小时（3600秒），手表走（3600+30）*（3600-30）/3600/3600*3600秒，那么1昼夜24小时手表共走了（3600+30）*（3600-30）/3600/3600*24*3600=86394秒，而一昼夜共有24*3600=86400秒，故相差86400-86394=6秒
【巩固】 小强家有一个闹钟，每时比标准时间快3分。有一天晚上10点整，小强对准了闹钟，他想第二天早晨6∶00起床，他应该将闹钟的铃定在几点几分？
【解析】 6：24
【巩固】 小翔家有一个闹钟，每时比标准时间慢3分。有一天晚上8:30，小翔对准了闹钟，他想第二天早晨6∶30起床，于是他就将闹钟的铃定在了6∶30。这个闹钟响铃的时间是标准时间的几点几分？
【解析】 7点
【巩固】 当时钟表示1点45分时，时针和分针所成的钝角是多少度？
【解析】 142.5度
【例 2】 有一座时钟现在显示10时整．那么，经过多少分钟，分针与时针第一次重合；再经过多少分钟，分针与时针第二次重合?
【解析】分针每小时走一圈12格，时针走1格，分针每小时比时针多走12－1=11格，每分钟多走11/60格。10时整的时候，时针与分针相距10格，第一次重合，分针要在相同的时间里比时针多走10格，所用时间是：10÷11/60=54又6/11（分钟）第二次重合，分针要比时针多走12格，所用时间是：12÷11/60=65又5/11（分钟）
【巩固】 钟表的时针与分针在4点多少分第一次重合？
【解析】 此题属于追及问题，追及路程是20格，速度差是12/60-1/60 ，所以追及时间是：20/（12/60-1/60 ） （分）。
也可以用度数算：4*30/5.5=240/11分钟
【巩固】 现在是3点，什么时候时针与分针第一次重合？
【解析】 根据题意可知，3点时，时针与分针成90度，第一次重合需要分针追90度， （分）
【例 3】 钟表的时针与分针在8点多少分第一次垂直？
【解析】 此题属于追及问题，但是追及路程是4 格（由原来的40格变为15格），速度差是 ，所以追及时间是： （分）。
【例 4】 2点钟以后，什么时刻分针与时针第一次成直角？
【解析】 根据题意可知，2点时，时针与分针成60度，第一次垂直需要90度，即分针追了90+60=150（度）， （分）
【例 5】 8时到9时之间时针和分针在“8”的两边，并且两针所形成的射线到“8”的距离相等．问这时是8时多少分?
【解析】 8点整的时候，时针较分针顺时针方向多40格，设在满足题意时，时针走过x格，那么分针走过40-x格，所以时针、分针共走过x+(40-x)=40格．于是，所需时间为 分钟，即在8点 分钟为题中所求时刻．
【例 6】 现在是10点，再过多长时间，时针与分针将第一次在一条直线上？
【解析】 时针的速度是 360÷12÷60=0.5(度/分),分针的速度是 360÷60=6(度/分),即 分针与时针的速度差是 6-0.5=5.5(度/分),10点时，分针与时针的夹角是60度， ,第一次在一条直线时，分针与时针的夹角是180度，,即 分针与时针从60度到180度经过的时间为所求。,所以 答案为 (分)
【巩固】 在9点与10点之间的什么时刻，分针与时针在一条直线上？
【解析】 根据题意可知，9点时，时针与分针成90度，第一次在一条直线上需要分针追90度，第二次在一条直线上需要分针追270度，答案为 （分）和 （分）
【例 7】 晚上8点刚过，不一会小华开始做作业，一看钟，时针与分针正好成一条直线。做完作业再看钟，还不到9点，而且分针与时针恰好重合。小华做作业用了多长时间？
【解析】 根据题意可知， 从在一条直线上追到重合，需要分针追180度， （分）
【例 8】 某人下午六时多外出买东西，出门时看手表，发现表的时针和分针的夹角为110°，七时前回家时又看手表，发现时针和分针的夹角仍是110°．那么此人外出多少分钟?
【解析】 如下示意图，开始分针在时针左边110°位置，后来追至时针右边110°位置．
于是，分针追上了110°+110°=220°，对应 格．所需时间为 分钟．所以此人外出40分钟．
评注：通过上面的例子，看到有时是将格数除以 ，有时是将格数除以 ，这是因为有时格数是时针、分针共同走过的，对应速度和；有时格数是分针追上时针的，对应速度差．对于这个问题，大家还可以将题改为:“在9点多钟出去，9点多钟回来，两次的夹角都是110°,答案还是40分钟．
【例 9】 上午9点多钟，当钟表的时针和分针重合时，钟表表示的时间是9点几分？
【解析】 时针与分针第一次重合的经过的时间为： （分），当钟表的时针和分针重合时，钟表表示的时间是9点 分。
【例 10】 小红上午8点多钟开始做作业时，时针与分针正好重合在一起。10点多钟做完时，时针与分针正好又重合在一起。小红做作业用了多长时间？
【解析】 8点多钟时,时针和分针重合的时刻为： （分）10点多钟时,时针和分针重合的时刻为： （分） ，小红做作业用了 时间
【例 11】 小红在9点与10点之间开始解一道数学题，当时时针和分针正好成一条直线，当小红解完这道题时，时针和分针刚好第一次重合，小红解这道题用了多少时间？
【解析】 9点和10点之间分针和时针在一条直线上的时刻为： （分），时针与分针第一次重合的时刻为： （分），所以这道题目所用的时间为： （分）
【例 12】 一部动画片放映的时间不足1时，小明发现结束时手表上时针、分针的位置正好与开始时时针、分针的位置交换了一下。这部动画片放映了多长时间？
【解析】 根据题意可知，时针恰好走到分针的位置，分针恰好走到时针的位置，它们一共走了一圈，即 （分）
【例 13】 有一座时钟现在显示10时整。那么，经过多少分钟，分针与时针第一次重合；再经过多少分钟，分针与时针第二次重合？
【解析】 根据题意可知，10点时，时针与分针成60度，第一次重合需要分针追360-60=300（度）， （分）第二次重合需要追360度，即 分。
模块二、时间标准及闹钟问题
【例 14】 钟敏家有一个闹钟，每时比标准时间快2分。星期天上午9点整，钟敏对准了闹钟，然后定上铃，想让闹钟在11点半闹铃，提醒她帮助妈妈做饭。钟敏应当将闹钟的铃定在几点几分上？
【解析】 闹钟与标准时间的速度比是62:60=31:30, 11点半与9点相差 150分， 根据十字交叉法，闹钟走了 150×31÷30=155(分),所以 闹钟的铃应当定在11点35分上。
【例 15】 小翔家有一个闹钟，每时比标准时间慢2分。有一天晚上9点整，小翔对准了闹钟，他想第二天早晨6∶40起床，于是他就将闹钟的铃定在了6∶40。这个闹钟响铃的时间是标准时间的几点几分？
【解析】 闹钟与标准时间的速度比是 58:60=29:30 晚上9点与次日早晨6点40分相差580分， 即 标准时间过了 580×30÷29=600(分),所以 标准时间是7点。
【例 16】 有一个时钟每时快20秒，它在3月1日中午12时准确，下一次准确的时间是什么时间？
【解析】 时钟与标准时间的速度差是 20秒/时，因为经过12小时，时钟的指针回到起始的位置，所以到下一次准确时间时，时钟走了 12×3600÷20=2160(小时) 即 90天， 所以 下一次准确的时间是5月30日中午12时。
【例 17】 小明家有两个旧挂钟，一个每天快20分，另一个每天慢30分。现在将这两个旧挂钟同时调到标准时间，它们至少要经过多少天才能再次同时显示标准时间？
【解析】 快的挂钟与标准时间的速度差是 20分/天,慢的挂钟与标准时间的速度差是 30分/天,快的每标准一次需要 12×60÷30=24(天),慢的每标准一次需要 12×60÷20=36(天),24与36的最小公倍数是 72,所以 它们至少要经过72天才能再次同时显示标准时间。
【例 18】 某科学家设计了只怪钟，这只怪钟每昼夜10时，每时100分（如右图所示）。当这只钟显示5点时，实际上是中午12点；当这只钟显示6点75分时，实际上是什么时间？
【解析】 标准钟一昼夜是24×60=1440（分）,怪钟一昼夜是100×10=1000（分）,怪钟从5点到6点75分，经过175分，根据十字交叉法，1440×175÷1000=252（分）,即4点12分。
【例 19】 手表比闹钟每时快60秒，闹钟比标准时间每时慢60秒。8点整将手表对准，12点整手表显示的时间是几点几分几秒？
【解析】 按题意，闹钟走3600秒手表走3660秒，而在标准时间的一小时中，闹钟走了3540秒。所以在标准时间的一小时中手表走3660÷3600×3540 = 3599（秒）即手表每小时慢1秒，所以12点时手表显示的时间是11点59分56秒。
模块三
【例 20】 某人有一块手表和一个闹钟，手表比闹钟每时慢30秒，而闹钟比标准时间每时快30秒。问：这块手表一昼夜比标准时间差多少秒？
【解析】 根据题意可知，标准时间经过60分，闹钟走了60.5分，根据十字交叉法，可求闹钟走60分，标准时间走了60×60÷60.5分，而手表走了59.5分，再根据十字交叉法，可求一昼夜手表走了59.5×24×60÷（60×60÷60.5）分，所以答案为24×60-59.5×24×60÷（60×60÷60.5）=0.1（分）0.1分=6秒
【例 21】 高山气象站上白天和夜间的气温相差很大，挂钟受气温的影响走的不正常，每个白天快30秒，每个夜晚慢20秒。如果在10月一日清晨将挂钟对准，那么挂钟最早在什么时间恰好快3分？
【解析】 根据题意可知，一昼夜快10秒，（3×60-30）÷10=15（天），所以挂钟最早在第15+1=16（天）傍晚恰好快3分钟，即10月16日傍晚。
【例 22】 一个快钟每时比标准时间快1分，一个慢钟每时比标准时间慢3分。将两个钟同时调到标准时间，结果在24时内，快钟显示9点整时，慢钟恰好显示8点整。此时的标准时间是多少？
【解析】 根据题意可知，标准时间过60分钟，快钟走了61分钟，慢钟走了57分钟，即标准时间每60分钟，快钟比慢钟多走4分钟，60÷4=15（小时）经过15小时快钟比标准时间快15分钟，所以现在的标准时间是8点45分。
【例 23】 小明上午 8点要到学校上课，可是家里的闹钟早晨 6点10分就停了，他上足发条但忘了对表就急急忙忙上学去了，到学校一看还提前了10分。中午12点放学，小明回到家一看钟才11点整。如果小明上学、下学在路上用的时间相同，那么，他家的闹钟停了多少分？
【解析】 根据题意可知，小明从上学到放学一共经过的时间是290分钟（11点减去6点10分）,在校时间为250分钟（8点到12点，再加上提前到的10分钟）所以上下学共经过290-250=40（分钟），即从家到学校需要20分钟，所以从家出来的时间为7：30（8：00-10分-20分）即他家的闹钟停了1小时20分钟，即80分钟。
3. java新手求关于局部变量初始化问题的指导，switch中的default语句让我困惑。
default是指前面的所有case都不匹配
默认项
LZ你想想
你不手动初始化
但是你有默认值
他没有匹配值就匹配default了
最后打印grade会用default的grade
当你没有defualt的时候
你又不手动初始化
System.out.print("小华是"+grade+"的学生");
编译器是找不到grade值的
肯定不会通过编译的
4. 关于java的基本概念的小问题1
还有两天,由于时间关系,尽量帮你答哈,呵呵你也太小气了吧,5分不如不给呵呵开个玩笑
1.不存在的,基本单位:类
2.一般是从main()方法开始的
3.构造函数在类创建对像时无条件调用,而一般方法则要要对像去才可以调用,当然static方法直接用类名也可以调用
4.print()或println()两个方法,如System.out.println();
5.和你主类名必需完全相同,注意大小写,也就是public类的类名
6.javac 文件名.java
7.是.class文件
8.java 文件名(没有.java)
9.
public class HelloWorld{
public static void main(String]
args){
System.out.println("Helloworld");
}
}
第二部分:
1.标识符就是用户自己启的名字,有类名,方法名,变量名,要求:1.区分大小写,2.不能以数字开头3.不能要关键字
顺便说一哈在java中 还有一个不成文的约定那就是:类名可以用若干个单词组合起来,第个单词的第一个字母要大小,变量名一般用小写,方法名的第一个字母用小写,常量名全用大写,可用下划线___分开
2.
有六个:byte(1) short(2) int(4) long(8) float(4) double(8) 括号里表示其占的字节数
3.类和方法的前面不加关键字,编译器会给它一个默认的关键字default或friendly表示在同一个包在可以访问它.
4.不是很清,不过你可以用StringBuffer类的append()方法追加
5.这两个都是一个位移运算符,都表示右移一位,不同的是">>"若被移动的数为正数,则最左填为0,否则填为1,而">>>"不管正数负数最左为0,(请注意:这都是在二进制的情况下进行的,了解一下就行了,用得不多)
6.
public class Max{
static int max=0,min=0;
static void swap(int a,int b,int c){
max=a>b?a:b;
max=max>c?max:c;
min=a<b?a:b;
min=c<min?c:min;
System.out.println(a+" "+b+" "+c+"这三个数的最大值是:"+max);
System.out.println("最小的数是:"+min);
}
public static void main(String[] args){
swap(-1,0,1);//你可以在这里改变它的参数,比较别的数
}
}
7.
public class Factorial{
public static void main(String[] args){
int factorial=10;
for(int i=factorial-1;i>0;i--){
factorial=factorial*i;
}
System.out.println("10!="+factorial);
}
}
8.
public class EatPeach
{
public static void main(String[] args)
{
int n=1;
for(int i=10;i>0;i--)
{
System.out.println("第"+i+"天吃了"+n+"个桃子");
n=(n+1)*2;
}
}
}
第三部分:
1.类就是整个java程序执行的模块,由成员变量和成员方法(也叫函数)组成
2.修饰符你说的是关键字吧:
public(共用访问符,无能什么地方都可以访问),
private 只能同一个包可以访问
protected 允许子类继承并修改
static 静态存偖区,在程序执行完后才释放内存
final 常量,不能改改的量
主要的就是这几个,当然你的题议还有int double long boolean float 等等这些你应该知道的就不用说了
3.类的构造函数将会在创建类的对像的第一时间得到调用,而普通方法要用对像才能调用,(当然如果是static方法的话也可以用类然直接调用)
4.Math类和Random类
5.
public(共用访问符,无能什么地方都可以访问),
private 只能同一个包可以访问
protected 允许子类继承并修改
final 用在类的前面不能继承它
6.静太成员一般是在程序执行完后才释放内存,反之则是在当前方法完毕就释放,而main就是这个性质来的,要加static
7.抽像类是不能完成某个具体的动作的,也就是一个接口,(注意只要有一个抽像方法在内的类必定定义为抽像类)
非抽像类刚刚相反
8.抽像方法没有方法体,如abstract void f();非抽像方法有方法体如void f(){}
9..(最终类，最终方法，最终属性就是在类,方法和变量的前加final)
含义就是:当放在类前,降低了此类的访问权限,重要的是别的类不能继承它
当放在方法前:表示这个方法不可以修改,更不得覆盖它
当放到变量前:也就是我们讲的常量,你一定晓得是不变的量,这我就不用多说了
10.
class Employee{
private String name;
private int salary,hireDay;
Employee(String name,int salary,int hireDay){
this.name=name;
this.salary=salary;
this.hireDay=hireDay;
}
public String getName(){
return name;
}
public int getSalary(){
return salary;
}
public int getHireDay(){
return hireDay;
}
}
//注:你说的三个私有方法用一个构造器完成要简单一些,如果你一定要那么做,只要把三个参数改成//三个方法就可以了
//11.
public class EmployeeTest{
public static void main(String[] args){
Employee[] e={
new Employee("小明",800,10),
new Employee("小强",600,15),
new Employee("小华",900,12)
};
System.out.println("name "+" salary"+" hireDay");
for(int i=0;i<e.length;i++)
System.out.println(e[i].getName()+" "+e[i].getSalary()+
" "+e[i].getHireDay());
}
}
注意你要先编译第一个，第二个才能运行
第四部分:
1.这个题不是很好,意思不够明确,这里我说两种吧多态和覆盖都是继承.当然接口也可以继承,所以我说这个题出得不好!
2.当我们使用关键字extends时就表示一个类继承了另一个类,也就是子类和父类,对于方法来说有下面三种:
(1).方法继承,在子类中不需定义就拥有的父类在的方法
(2).方法的覆盖:是指返回的类型,形式参数和方法名都相同,改变其方法体.
(3).方法的重载:则是方法名相同,形式参数不同的几个方法,如:洗车,洗衣服,有一个是相同的,就是洗这个属性(方法名),不同的是车,衣服(参数),所以我们不必这样说(用洗车的方法来洗车,用洗衣服的方法来洗衣服)就能分开洗车是做什么和洗衣服是做什么,正是如此编译器是通过这种方式来识别调用哪个方法的
(4.abstract class Employee{
abstract int getSalary();
}
class CommonEmployee extends Employee{
private int salary;
CommonEmployee(int salary){
this.salary=salary;
}
public int getSalary(){
return salary;
}
}
class Manager extends Employee{
private int salary;
Manager(int salary){
this.salary=salary;
}
public int getSalary(){
return salary;
}
}
public class SimpleTest1{
public static void main(String[] args){
Employee com=new CommonEmployee(1200);
Employee man=new Manager(2000);
System.out.println("职工的工次是:"+com.getSalary());
System.out.println("经理的工资是:"+man.getSalary());
}
}
5.java的多态性是指:许多类它们有一个共同的特点,我们如果每个特征我们都去写的话会用很多的代码也很麻烦,那么解决这一问题的正是多态性,
那如何解决呢??我们可以把这些相同的特点写成一个接口或抽像类,然后只要有这个特征的类继承它就可以了,其中有一个很经典的例子:画图,我们可以创建一个图形的抽像类,因为三角形啊,正方形啊,都是图形,于是可以继承这个类,于是我们可以用这些图形来继承上面所创建的图形类,如果你不是很理解的话我把这个例子写到下面你仔细看就会明白的:
import java.util.*;
class Shape{
void draw(){}
void erase(){}
}
class Circle extends Shape{
void draw(){
System.out.println("Circle.draw()");
}
void erase(){
System.out.println("Circle.erase");
}
}
class Square extends Shape{
void draw(){
System.out.println("Square.draw()");
}
void erase(){
System.out.println("Square.erase()");
}
}
class Triangle extends Shape{
void draw(){
System.out.println("Triangle.draw()");
}
void erase(){
System.out.println("Triangle.erase()");
}
}
//和以上是组合的关系
class RandomShapeGenerator{
private Random rand=new Random();
public Shape next(){//反回一个对像
switch(rand.nextInt(3)){
default:
case 0:return new Circle();
case 1:return new Square();
case 2:return new Triangle();
}
}
}
public class Shapes{
private static RandomShapeGenerator gen=
new RandomShapeGenerator();
public static void main(String[] args){
Shape[] s=new Shape[9];
for(int i=0;i<s.length;i++)
s[i]=gen.next();//给引用填对像
for(int i=0;i<s.length;i++)
s[i].draw();//能过动态帮定调用哪一个方法
}
}
如果还是看不会的话,那么请你打开书好好看抽像类,然后再看看接口,你不会看不懂的,去试试!!!!
6.this和super有一个最易理解的就是this表示当前对像,super表示可以引用父类中的构造函数,
当然它们的功能远远不止这些!这我就不多说了
7.
如果把子类的对像转化为父类中的对像,我们称为向上转型,一般这个好实现也很重要,用得也多,可以创建一个子类对像,然后传给父类的引用,这种说法我不知道科不科学,也很不好理解,但事实就是如此,如上面的图形例子中:
Shape next={ new Circle(),
new Square(),
new Triangle()
};
这看起来每个类的对像都给了同一个父类(Shape),这有一个问题它们表示同一对像吗?你看以把它们看成同一引用,然后事不是你想的这样,next[1].draw(),next[1].draw(),next[2].draw()它们调的并不是同一个方法,而分别调用的是Circle Square Triangle的中的draw()方法,你可以亲自运行上面的事例就知道了,好了有点说得多了,如果有问题的话加我QQ吧460566995
8.默认构造函数是指在我们没有构造函数时编译器自动帮我们加上一个构造函数一般为:类(){},它没有任何参数,也没有方法体
好了,我手都写软了,就给你答这么多吧,还有没有答完的希望后者能补上谢谢,我这两天也没有时间了,
如果没有人答你又一定要要的话可以加我的QQ问我好了,好好看里面有我的QQ的