A. java有哪些相關書籍
市面上關於Java的書令人眼花繚亂，很多人完全不知道該看哪本書。整理Java的4本必讀書籍給大家分享。
1.《Java從入門到精通》
這本書主要針對Java基礎，對於沒有學過Java的人才說，是一個不錯的選擇。通過這本書，大家可以從零開始，慢慢來學習，而且實操很多，不會讓你看到最後出現只會理論的情況。
2.《Java編程思想》
在有了一定的Java編程經驗之後，你需要「知其所以然」了。這個時候《Java編程思想》是一本讓你知其所以然的好書，它對於基本的面向對象知識有比較清楚的交待，對Java基本語法，基本類庫有比較清楚的講解，可以幫你打一個良好的Java編程基礎。這本書的缺點是實在太厚，也比較羅嗦，不適合現代人快節奏學習，因此看這本書要懂得取捨，不是每章每節都值得一看的，挑重點的深入看就可以了。
3.《重構:改善既有代碼的設計》
出自於 Martin Fowler 的大作，寫出優秀代碼的必經之路。這本書名氣很大，不用多介紹，可以在閑暇的時候多翻翻，多和自己的實踐相互印證。這本書對你產生影響是潛移默化的。
4.《Java開發實戰經典》
這本書比較適合自學者學習，裡面有很多小案例，可以邊學邊練，鞏固知識。
B. 請教為什麼java net包打不開 eclipse
兄弟你是不是在看<Thking in java>這本書啊，
這個包要自己編寫的
寫好以後的代碼放在和你寫的代碼的同一個包裡面
不要打成jar包了，我也是過了，打成jar包引入也沒成功
C. javafx怎麼實現頁面的跳轉
1. 後台
public class Check {
public static boolean checkreturn(String account,String password){
boolean checkbool = false;
if("account".equals(account)&&"password".equals(password)){
checkbool = true;
}
return checkbool;
}
}
import java.net.URL;
import java.util.ResourceBundle;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.control.PasswordField;
import javafx.scene.control.TextField;
public class LoginController implements Initializable {
@FXML private TextField account;
@FXML private PasswordField password;
private FXMLTest application;
public void setApp(FXMLTest application){
this.application = application;
}
@FXML
public void LOGIN_M(ActionEvent event) {
application.userlogin(account.getText(), password.getText());
}
@FXML
private void CLEAR_M(ActionEvent event) {
account.setText(null);
password.setText(null);
}
@Override
public void initialize(URL url, ResourceBundle rb) {
// TODO
}
}
import java.net.URL;
import java.util.ResourceBundle;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
public class MainController implements Initializable{
private FXMLTest application;
public void setApp(FXMLTest application){
this.application = application;
}
@FXML
private void OUT_M(ActionEvent event) {
application.useroutmain();
}
@Override
public void initialize(URL url, ResourceBundle rb) {
}
}
import check.Check;
import java.io.InputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.fxml.Initializable;
import javafx.fxml.JavaFXBuilderFactory;
import javafx.scene.Scene;
import javafx.scene.layout.AnchorPane;
import javafx.stage.Stage;
public class FXMLTest extends Application {
private Stage stage;
private final double MINIMUM_WINDOW_WIDTH = 400.0;
private final double MINIMUM_WINDOW_HEIGHT = 250.0;
@Override
public void start(Stage primaryStage) throws Exception {
stage = primaryStage;
stage.setTitle("FXML Login Sample");
stage.setMinWidth(MINIMUM_WINDOW_WIDTH);
stage.setMinHeight(MINIMUM_WINDOW_HEIGHT);
gotologin();
stage.show();
}
public void gotologin(){
try {
LoginController login = (LoginController) replaceSceneContent("FXML_LOGIN.fxml");
login.setApp(this);
} catch (Exception ex) {
Logger.getLogger(FXMLTest.class.getName()).log(Level.SEVERE, null, ex);
}
}
public void gotomain(){
try {
MainController main = (MainController) replaceSceneContent("FXML_MAIN.fxml");
main.setApp(this);
} catch (Exception ex) {
Logger.getLogger(FXMLTest.class.getName()).log(Level.SEVERE, null, ex);
}
}
public void userlogin(String account,String password){
if(Check.checkreturn(account,password)){
gotomain();
}
}
public void useroutmain(){
gotologin();
}
private Initializable replaceSceneContent(String fxml) throws Exception {
FXMLLoader loader = new FXMLLoader();
InputStream in = FXMLTest.class.getResourceAsStream(fxml);
loader.setBuilderFactory(new JavaFXBuilderFactory());
loader.setLocation(FXMLTest.class.getResource(fxml));
AnchorPane page;
try {
page = (AnchorPane) loader.load(in);
} finally {
in.close();
}
Scene scene = new Scene(page, 800, 600);
stage.setScene(scene);
stage.sizeToScene();
return (Initializable) loader.getController();
}
public static void main(String[] args) {
launch(args);
}
}
2. xml配置
<?xml version="1.0" encoding="UTF-8"?>
<?import java.lang.*?>
<?import java.util.*?>
<?import javafx.geometry.*?>
<?import javafx.scene.control.*?>
<?import javafx.scene.effect.*?>
<?import javafx.scene.layout.*?>
<?import javafx.scene.paint.*?>
<?import javafx.scene.text.*?>
<AnchorPane id="AnchorPane" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="250.0" prefWidth="400.0"
xmlns:fx="http://javafx.com/fxml" fx:controller="fxmltest.LoginController">
<children>
<VBox layoutX="3.0" layoutY="0.0" prefHeight="250.0" prefWidth="390.0" spacing="20.0">
<children>
<HBox minHeight="37.0" prefHeight="37.0" prefWidth="411.0">
<children>
<Label text="登陸界面">
<effect>
<DropShadow height="7.845238095238096" radius="4.1815476190476195" width="10.880952380952381" />
</effect>
<font>
<Font name="System Bold" size="30.0" />
</font>
<HBox.margin>
<Insets left="140.0" />
</HBox.margin>
</Label>
</children>
</HBox>
<GridPane alignment="TOP_RIGHT" prefWidth="380.0">
<children>
<Label alignment="TOP_RIGHT" text="Account" GridPane.columnIndex="0" GridPane.halignment="RIGHT" GridPane.rowIndex="0">
<effect>
<DropShadow blurType="TWO_PASS_BOX" height="7.845238095238096" radius="3.675595238095238" width="8.857142857142858" />
</effect>
<font>
<Font size="25.0" fx:id="x1" />
</font>
<GridPane.margin>
<Insets right="8.0" fx:id="x2" />
</GridPane.margin>
</Label>
<Label font="$x1" text="password" GridPane.columnIndex="0" GridPane.halignment="RIGHT" GridPane.margin="$x2" GridPane.rowIndex="1">
<effect>
<DropShadow blurType="TWO_PASS_BOX" height="7.845238095238094" radius="3.6755952380952372" width="8.857142857142854" />
</effect>
</Label>
<TextField fx:id="account" prefHeight="26.0" prefWidth="268.0" promptText="please input your account" GridPane.columnIndex="1" GridPane.rowIndex="0" />
<PasswordField fx:id="password" prefWidth="223.0" promptText="please input your password" GridPane.columnIndex="1" GridPane.rowIndex="1" />
<Button id="btn_login" mnemonicParsing="false" onAction="#LOGIN_M" prefWidth="80.0" text="登陸" GridPane.columnIndex="0" GridPane.halignment="RIGHT" GridPane.rowIndex="2">
<effect>
<DropShadow />
</effect>
<GridPane.margin>
<Insets top="15.0" />
</GridPane.margin>
</Button>
<Button id="btn_clear" mnemonicParsing="false" onAction="#CLEAR_M" prefWidth="80.0" text="清除" GridPane.columnIndex="1" GridPane.rowIndex="2">
<effect>
<DropShadow />
</effect>
<GridPane.margin>
<Insets left="80.0" top="15.0" />
</GridPane.margin>
</Button>
</children>
<columnConstraints>
<ColumnConstraints hgrow="SOMETIMES" maxWidth="205.0" minWidth="10.0" prefWidth="147.0" />
<ColumnConstraints hgrow="SOMETIMES" maxWidth="318.0" minWidth="10.0" prefWidth="243.0" />
</columnConstraints>
<rowConstraints>
<RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
<RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
<RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
</rowConstraints>
</GridPane>
</children>
<padding>
<Insets top="30.0" />
</padding>
</VBox>
</children>
</AnchorPane>
<?xml version="1.0" encoding="UTF-8"?>
<?import java.lang.*?>
<?import java.util.*?>
<?import javafx.scene.control.*?>
<?import javafx.scene.layout.*?>
<?import javafx.scene.paint.*?>
<?import javafx.scene.text.*?>
<AnchorPane id="AnchorPane" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="400.0" prefWidth="600.0"
xmlns:fx="http://javafx.com/fxml" fx:controller="fxmltest.MainController">
<children>
<Hyperlink layoutX="86.0" layoutY="111.0" text="退出登錄！" onAction="#OUT_M">
<font>
<Font size="45.0" />
</font>
</Hyperlink>
</children>
</AnchorPane>
D. 關於effect的片語
cause and ~ 因果 curative ~s 療效 with no ~沒有作用 sound ~s音響效果
personal~s 個人財產 ~ a cure 治癒 ~ a policy 取得保險單
E. 在Java中，final修飾的類有什麼特點
關於Java中的final(2010-09-09 14:19:48)轉載▼標簽： javafinal 分類： Java知識學習
Java中的final共有三種用法:
final成員變數
當你在類中定義變數時，在其前面加上final關鍵字，那便是說，這個變數一旦被初始化便不可改變，這里不可改變的意思對基本類型來說是其值不可變，而對於對象變數來說其引用不可再變，但引用變數所指向的對象中的內容還是可以改變的。
其初始化可以在三個地方，
一是其定義處，也就是說在final變數定義時直接給其賦值，
二是在構造函數中。而且在Java1.1以前，只能是在定義時給值。
三是在初如化代碼塊中{} 或者static{}
下面這段代碼演示了這一點：更加詳細的探討請參考關於final變數的初始化探討
import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;
public class Bat {
final double PI = 3.14; // 在定義時便給址值
final int i; // 因為要在構造函數中進行初始化，所以此處便不可再給值
final List list; // 此變數也與上面的一樣
Bat() {
i = 100;
list = new LinkedList();
}
Bat(int ii, List l) {
i = ii;
list = l;
}
public static void main(String[] args) {
Bat b = new Bat();
b.list.add(new Bat());//引用不可變，但引用指向的內容是可以變的
// b.i=25; syntax error i是不可變的
//b.list=new ArrayList();錯誤，對象引用是不可變的
System.out.println("I=" + b.i + " List Type:" + b.list.getClass());
b = new Bat(23, new ArrayList());
b.list.add(new Bat());
System.out.println("I=" + b.i + " List Type:" + b.list.getClass());
}
}
再例如，對於如下語句：
final StringBuffer a=new StringBuffer("immutable");
執行如下語句將報告編譯期錯誤：
a=new StringBuffer("");
但是，執行如下語句則可以通過編譯：
a.append(" broken!");
有人在定義方法的參數時，可能想採用如下形式來阻止方法內部修改傳進來的參數對象：
public void method(final StringBuffer param)
{
}
實際上，這是辦不到的，在該方法內部仍然可以增加如下代碼來修改參數對象，其它對象亦如此：
param.append("a");
在看一個例子
//: FinalData.java
//The effect of final on fields
class Value {
int i = 1;
}
public class FinalData {
// Can be compile-time constants
final int i1 = 9;
static final int I2 = 99;
// Typical public constant:
public static final int I3 = 39;
// Cannot be compile-time constants:
final int i4 = (int) (Math.random() * 20);
static final int i5 = (int) (Math.random() * 20);
Value v1 = new Value();
final Value v2 = new Value();
static final Value v3 = new Value();
// ! final Value v4; // Pre-Java 1.1 Error:for no initializer
// Arrays:
final int[] a = { 1, 2, 3, 4, 5, 6 };
public void print(String id) {
System.out.println(id + ": " + "i4 = " + i4 + ", i5 = " + i5);
}
public static void main(String[] args) {
FinalData fd1 = new FinalData();
// ! fd1.i1++; // Error: can't change value,因為i1是final的
fd1.v2.i++; // Object isn't constant!這個可以是因為類Value中的i是普通變數
fd1.v1 = new Value(); // OK -- not final
for (int i = 0; i < fd1.a.length; i++)
fd1.a[i]++; // Object isn't constant!
//下面三個犯同樣的錯誤 Error: Can'tchange handle
// ! fd1.v2 = new Value();
// ! fd1.v3 = new Value(); //
// ! fd1.a = new int[3];
fd1.print("fd1");
System.out.println("Creating new FinalData");
FinalData fd2 = new FinalData();
fd1.print("fd1");
fd2.print("fd2");
}
}
輸出結果（由於上面用了隨機函數，所以輸出結果可能不一樣，但是規律是一樣的）：
fd1: i4 = 4, i5 = 6
Creating new FinalData
fd1: i4 = 4, i5 = 6
fd2: i4 = 10, i5 = 6
結果分析：fd1與fd2的i4發現值總是不一樣，但i5的值卻是一樣的，這是為什麼呢？
我們可以發現定義i4與i5惟一的區別是後者多了一個static，由於final變數和static變數可以說
都只能存一個數據，他們惟一的區別是static變數是屬於類的，是類變數，只會被載入一次。
請參考該文章：Java_父類與子類的載入原理
而i4雖然是final的，但是它仍是個普通變數，屬於實例變數，每創建一個對象還是會被載入一次，又
由於是個隨機函數，所以最終的結果不一樣。
所以：一定要區分final與static final的細微差別。
使用final關鍵字修飾一個變數時，是指引用變數不能變，引用變數所指向的對象中的內容還是可以改變的。
此程序很簡單的演示了final的常規用法。在這里使用在構造函數中進行初始化的方法，這使你有了一點靈活性。如Bat的兩個重載構造函數所示，第一個預設構造函數會為你提供默認的值，重載的那個構造函數會根據你所提供的值或類型為final變數初始化。然而有時你並不需要這種靈活性，你只需要在定義時便給定其值並永不變化，這時就不要再用這種方法。在main方法中有兩行語句注釋掉了，如果你去掉注釋，程序便無法通過編譯，這便是說，不論是i的值或是list的類型，一旦初始化，確實無法再更改。然而b可以通過重新初始化來指定i的值或 list的類型，輸出結果中顯示了這一點：
I=100 List Type:class java.util.LinkedList
I=23 List Type:class java.util.ArrayList
還有一種用法是定義方法中的參數為final，對於基本類型的變數，這樣做並沒有什麼實際意義，因為基本類型的變數在調用方法時是傳值的，也就是說你可以在方法中更改這個參數變數而不會影響到調用語句，然而對於對象變數，卻顯得很實用，因為對象變數在傳遞時是傳遞其引用，這樣你在方法中對對象變數的修改也會影響到調用語句中的對象變數，當你在方法中不需要改變作為參數的對象變數時，明確使用final進行聲明，會防止你無意的修改而影響到調用方法。
另外方法中的內部類在用到方法中的參變數時，此參變也必須聲明為final才可使用，如下代碼所示：
public class INClass {
void innerClass(final String str) {
class IClass {
IClass() {
System.out.println(str);
}
}
IClass ic = new IClass();
}
public static void main(String[] args) {
INClass inc = new INClass();
inc.innerClass("Hello");
}
}
final方法
將方法聲明為final，那就說明你已經知道這個方法提供的功能已經滿足你要求，不需要進行擴展，並且也不允許任何從此類繼承的類來覆寫這個方法，但是繼承仍然可以繼承這個方法，也就是說可以直接使用。
另外有一種被稱為inline的機制，它會使你在調用final方法時，直接將方法主體插入到調用處，而不是進行例行的方法調用，例如保存斷點，壓棧等，這樣可能會使你的程序效率有所提高，然而當你的方法主體非常龐大時，或你在多處調用此方法，那麼你的調用主體代碼便會迅速膨脹，可能反而會影響效率，所以你要慎用final進行方法定義。
類中所有的private方法從某種意義上講都是屬於final的，因為他們在其它地方沒法覆蓋，你可以在一個private方法前加final修飾符，但沒什麼意義。
final類
當你將final用於類身上時，你就需要仔細考慮，因為一個final類是無法被任何人繼承的，那也就意味著此類在一個繼承樹中是一個葉子類，並且此類的設計已被認為很完美而不需要進行修改或擴展。對於final類中的成員變數，你可以定義其為final，也可以不是final。而對於方法，由於所屬類為final的關系，自然也就成了final型的。你也可以明確的給final類中的方法加上一個final，但這顯然沒有意義。
下面的程序演示了final方法和final類的用法：
final class finals {
final String str = "final Data";
public String str1 = "non final data";
final public void print() {
System.out.println("final method.");
}
public void what() {
System.out.println(str + "\n" + str1);
}
}
public class FinalDemo { // extends final 無法繼承
public static void main(String[] args) {
finals f = new finals();
f.what();
f.print();
}
}
從程序中可以看出，final類與普通類的使用幾乎沒有差別，只是它失去了被繼承的特性。final方法與非final方法的區別也很難從程序行看出，只是記住慎用。
附註：
final在設計模式中的應用
在設計模式中有一種模式叫做不變模式，在Java中通過final關鍵字可以很容易的實現這個模式，在講解final成員時用到的程序Bat.java就是一個不變模式的例子。如果你對此感興趣，可以參考閻宏博士編寫的《Java與模式》一書中的講解。
F. 在的話幫忙看下這段JAVA注釋，用翻譯器翻譯過來的根本不容易理解，
ChangeGroup encompases是一個表示在org.davidmorgan.jinn.上影響單用戶改變的實體對象的有序集合，一旦一個ChangeGroup 對象被創建，它就可以應用於一個SessionState對象改變，也可以與之相反地撤銷改變。
G. 如何從java菜鳥變為高手
以下是我在另外一個地方寫得，那個想精通，在我看來精通比高手更難，所以如果你想成為高手的話，只需要做到 1 2 4 就可以了，還能找份java的工作。。
大概寫一下個人的感覺吧，這樣的問題，網上的答案很多的，
1 初學的話，從java的本身語法開始。很多人覺得這些東西很簡單，可能一天或者一個上午就完事了。但是，所有的東西，最關鍵的細節，god in details.你看完以後，去做一下scjp的試題目，看看自己的水平，深深反省一下。不是需要去考這個認證，是讓你真正意識到自己對於java的認識。這個階段可以看一些java培訓教程，好像有一個叫張孝詳的，比較適合沒有其他語言基礎的人，如果有基礎的，可以看看thinking in java
2 然後一些提高階段，對於java的語法熟悉以後，就是熟悉java語言，對語言最好的熟悉方法是熟悉他的類庫，這個部分，個人推薦最好的書是core java，現在到7還是8版了，我看是的時候是6版本。這本書是我所知道認可程序最高的一本java書了。
3 在對語法和語言都有一定程度的熟悉以後，就要知其然後知其所以然(前提是你想真正精通這個語言，不然這個時個就可以去搞jsp了)，這個時候站的角度要高一些，先看看jvm，現在國內這個方法據我看的，沒有什麼特別好的書，因為也沒有幾本，了解了整個java是如何運行的以後。想像一下，如果自己需要實現一個java的話，如何做，帶著這個問題去jdk的源代碼，你會收獲很大的。有一本書，叫effect java，本來應該是關於最基礎的東西，但是很難的，在這個階段看的話，收獲會很不一樣的。
4 在真正花時間在前三個階段以後，打一個真正扎實的java基礎以後，就可以開始真正面java最流行的領域了，從servlet,jsp開始，然後是J2EE那些東西。那些東西在本質上考慮的更多的設計理念和設計模式的東西了。有一個叫java與模式的書，好像叫閻宏寫的，是java設計模式很不錯的一本入門的書。在看書的時候，想法要開闊一些，不妨想一下，如果我自己要實現個tomcat，應該從哪裡開始，如果有這樣的想法，對於tomcat這些東西的理解，肯定要比大多數的人深刻一些。
5 在以上的東西都學到一定程度以後，那個時間就更應該關注的是方法論的東西了。包括軟體開發模式，程序設計的方法學，這個階段比較高了，我本人研究不深入，不能提供過多的東西，只能提供一些名詞，例如重構，敏捷開發等等。國外好像一個martin, Robert等什麼的在這方面比較有研究。
以上所有的過程就需要很多的動手實踐，沒有實踐，所有的編程語言的學習都只是水中花，鏡中月，練拳還要練功。如果你有良好的心態(這個最重要了)，不要在別人開始學習J2ee等東西的時候，受不住誘惑，偏離了這個方向，要知道，玄門的功夫都是開始入門極難，然後越來越快的，九陰白骨爪之類的就剛好相反了。學習的過程，別的什麼都不重要，最重要的一點，是勤奮， 天道酬勤。
H. 有哪些關於JAVA的好書
Java核心編程（Core Java）
java編程思想（Thinking in Java）
java解惑（Java puzzles）
OK了，不過相關的，如java相關設計模式的書另說。
I. JAVA的構造器和C++的構造函數有什麼區別
Java和C++在構造函數中調用虛函數的區別
首先可以認為，Java所有instance函數都是虛函數。
C++類的構造函數中調用虛函數，並不能有多態效果。
這樣設計的理由是：
在基類的構造函數中，派生類的成員尚未初始化，而派生類的虛函數定義可以使用派生類的成員，C++強制必須先初始化對象然後才能使用【這是C++設計new和構造函數的初衷】，所以不可以調用派生類的虛函數定義。
C++虛函數的實現機制也可以解釋這一現象：
對象的虛函數表指針在調用構造函數前更新，指向該類的虛函數表。所以當調用基類的構造函數時，對象的虛函數表指針指向該基類的虛函數表，而不是指向派生類的虛函數表，所以虛函數調用沒有多態效果。
但是
Java類的構造函數中調用虛函數，依然有多態效果。
我是在看《The Java Programming Language, fourth edition》5.5 Inheriting Nested Types 這一節時看到了在Field initializer中調用【虛】函數，仍然有多態的效果，大吃一驚，經驗證屬實。
《Thinking in Java, fourth edition》 Behavior of polymorphic methods inside constructors 這一節對此進行了評論：
If you call a dynamically-bound method inside a constructor, the overridden definition for that method is used. However, the effect of this call can be rather unexpected because the overridden method will be called before the object is fully constructed. This can conceal some difficult-to-find bugs.
總之，這是一把雙刃劍，有利有弊，且弊大於利，要小心使用。《The Java Programming Language, fourth edition》5.5 Inheriting Nested Types 這一節舉的例子可以使用兩步初始化的方法解決，也可以使用延遲創建的方法解決，延遲創建是更好的辦法。
C++ 的不懂..幫你找了一下
J. java數據類型的問題
java中boolean類型佔一個位元組，佔八位，但是內存中，boolean只要0 1表示false true，所以 一個位就行啦