小華剛剛參加了一個編譯器課程
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的