bl双性强迫侵犯h_国产在线观看人成激情视频_蜜芽188_被诱拐的少孩全彩啪啪漫画

關于19的java代碼的信息

求計算器Java代碼。。。

import java.awt.*;

為若羌等地區用戶提供了全套網頁設計制作服務，及若羌網站建設行業解決方案。主營業務為成都網站建設、成都網站設計、若羌網站設計，以傳統方式定制建設網站，并提供域名空間備案等一條龍服務，秉承以專業、用心的態度為用戶提供真誠的服務。我們深信只要達到每一位用戶的要求，就會得到認可，從而選擇與我們長期合作。這樣，我們也可以走得更遠！

import javax.swing.*;

import java.awt.event.*;

import javax.swing.event.*;

class JPanelEa1 extends JFrame implements MenuListener,ActionListener

{

JPanel mainp,p1,p2,p3,p4;

JTextField jt1;

JMenuItem mnuCopy;

JMenuItem mnuPaste;

JButton bM;

boolean isDouble = false;// 是否為實數

int opFlag = -1;

static double t1 = 0, t2 = 0, t3 = 0, result = 0;

static int opflag1 = -1, opflag2 = -1, flag = 0, resflag = 1;

int preOp, currentOp = 0;// 標準位

double op1 = 0, op2 = 0;// 操作數

double n3;

StringBuffer buf = new StringBuffer(20);

StringBuffer copyBoard = new StringBuffer(20);// 剪貼板

StringBuffer memory = new StringBuffer(20);// M系列

StringBuffer str = new StringBuffer();

public JPanelEa1()

{

p1=new JPanel();

p1.setLayout(new GridLayout(2,1,10,10));

JMenuBar mnuNotepad=new JMenuBar();

JMenu mnuEdit=new JMenu("編輯(E)");

mnuEdit.setMnemonic(KeyEvent.VK_E);

JMenu mnuCheck=new JMenu("查看(V)");

mnuCheck.setMnemonic(KeyEvent.VK_V);

JMenu mnuHelp=new JMenu("幫助(H)");

mnuCopy=new JMenuItem("復制(C)");

mnuPaste=new JMenuItem("粘貼(P)");

JMenuItem mnuVisit=new JMenuItem("查看幫助(V)");

JMenuItem mnuAbout=new JMenuItem("關于計算器(A)");

JSeparator sep=new JSeparator();

jt1=new JTextField("0.");

jt1.setEnabled(false);

jt1.setHorizontalAlignment(JTextField.RIGHT);

mnuEdit.addMenuListener(this);

mnuCheck.addMenuListener(this);

mnuHelp.addMenuListener(this);

mnuCopy.addActionListener(this);

mnuPaste.addActionListener(this);

mnuVisit.addActionListener(this);

mnuAbout.addActionListener(this);

mnuNotepad.add(mnuEdit);

mnuNotepad.add(mnuCheck);

mnuNotepad.add(mnuHelp);

mnuEdit.add(mnuCopy);

mnuEdit.add(mnuPaste);

mnuEdit.add(sep);

mnuHelp.add(mnuVisit);

mnuHelp.add(sep);

mnuHelp.add(mnuAbout);

p1.add(mnuNotepad);

p1.add(jt1);

p2=new JPanel();

p2.setLayout(new FlowLayout(FlowLayout.CENTER));

bM = new JButton(" ");

bM.setEnabled(false);

p2.add(bM);

Button b25=new Button("Backspace");

b25.addActionListener(this);

Button b26=new Button("CE");

b26.addActionListener(this);

Button b27=new Button("C");

b27.addActionListener(this);

p2.add(b25);

p2.add(b26);

p2.add(b27);

p3=new JPanel();

p3.setLayout(new GridLayout(4,6));

Button button1=new Button("MC");

button1.addActionListener(this);

Button button2=new Button("7");

button2.addActionListener(this);

Button button3=new Button("8");

button3.addActionListener(this);

Button button4=new Button("9");

button4.addActionListener(this);

Button button5=new Button("/");

button5.addActionListener(this);

Button button6=new Button("sqrt");

button6.addActionListener(this);

Button button7=new Button("MR");

button7.addActionListener(this);

Button button8=new Button("4");

button8.addActionListener(this);

Button button9=new Button("5");

button9.addActionListener(this);

Button button10=new Button("6");

button10.addActionListener(this);

Button button11=new Button("*");

button11.addActionListener(this);

Button button12=new Button("%");

button12.addActionListener(this);

Button button13=new Button("MS");

button13.addActionListener(this);

Button button14=new Button("1");

button14.addActionListener(this);

Button button15=new Button("2");

button15.addActionListener(this);

Button button16=new Button("3");

button16.addActionListener(this);

Button button17=new Button("-");

button17.addActionListener(this);

Button button18=new Button("1/x");

button18.addActionListener(this);

Button button19=new Button("M+");

button19.addActionListener(this);

Button button20=new Button("0");

button20.addActionListener(this);

Button button21=new Button("+/-");

button21.addActionListener(this);

Button button22=new Button(".");

button22.addActionListener(this);

Button button23=new Button("+");

button23.addActionListener(this);

Button button24=new Button("=");

button24.addActionListener(this);

p3.add(button1);p3.add(button2);

p3.add(button3);p3.add(button4);

p3.add(button5);p3.add(button6);

p3.add(button7);p3.add(button8);

p3.add(button9);p3.add(button10);

p3.add(button11);p3.add(button12);

p3.add(button13);p3.add(button14);

p3.add(button15);p3.add(button16);

p3.add(button17);p3.add(button18);

p3.add(button19);p3.add(button20);

p3.add(button21);p3.add(button22);

p3.add(button23);p3.add(button24);

setSize(250,150);

mainp=new JPanel();

mainp.setLayout(new GridLayout(3,1));

mainp.add(p1);

mainp.add(p2);

mainp.add(p3);

setContentPane(mainp);

setTitle("計算器");

setSize(300,300);

setVisible(true);

setDefaultCloseOperation(EXIT_ON_CLOSE);

}

public void actionPerformed(ActionEvent e)

{

String s= e.getActionCommand();

if (s.equals("復制(C)")) {

String temp = jt1.getText().trim();

copyBoard.replace(0, copyBoard.length(), temp);

mnuPaste.setEnabled(true);

} else if (s.equals("粘貼(p)")) {

jt1.setText(copyBoard.toString());

} else if (s.equals("CE")) {

// 如果是CE則清除文本框

jt1.setText("0.");

} else if (s.equals("Backspace")) {

if (!jt1.getText().trim().equals("0.")) {

// 如果文本框中有內容

if (str.length() != 1 str.length() != 0) {

jt1.setText(str.delete(str.length() - 1, str.length())

.toString());

} else {

jt1.setText("0.");

str.setLength(0);

}

}

op2 = Double.parseDouble(jt1.getText().trim());

} else if (s.equals("C")) {

// 如果是C刪除當前計算

jt1.setText("0.");

op1 = op2 = 0;

str.replace(0, str.length(), " ");

preOp = currentOp = 0;

} else if (s.equals("MC")) {

// 如果是MC則清除緩沖區

String temp = "";

memory.replace(0, memory.length(), temp);

bM.setText(" ");

} else if (s.equals("MR")) {

// 如果按鍵為MR則恢復緩沖區的數到文本框

jt1.setText(memory.toString());

} else if (s.equals("MS")) {

// 如果按鍵為MS則將文本框的數存入緩沖區

String s1 = jt1.getText().trim();

memory.replace(0, memory.length(), s1);

bM.setText("M");

} else if (s.equals("M+")) {

// 如果按鍵為MS則將文本框值與緩沖區的數相加但不顯示結果

String temp1 = jt1.getText().trim();

double dtemp = Double.parseDouble(temp1);

String temp2 = memory.toString();

dtemp += Double.parseDouble(temp2);

temp1 = String.valueOf(dtemp);

memory.replace(0, memory.length(), temp1);

} else if (s.equals("1/x")) {

// 如果按鍵為1/x則將文本框中的數據為它的倒數

String temp = jt1.getText().trim();

double dtemp = Double.parseDouble(temp);

jt1.setText("" + 1 / dtemp);

} else if (s.equals("sqrt")) {

// 如果按鍵為sqrt則將文本框中的內容求平方根

String temp = jt1.getText().trim();

double dtemp = Double.parseDouble(temp);

jt1.setText("" + Math.sqrt(dtemp));

} else if (s.equals("+")) {

str.setLength(0);

if (currentOp == 0) {

preOp = currentOp = 1;

op2 = 0;

jt1.setText("" + op1);

} else {

currentOp = preOp;

preOp = 1;

switch (currentOp) {

case 1:

op1 += op2;

jt1.setText("" + op1);

break;

case 2:

op1 -= op2;

jt1.setText("" + op1);

break;

case 3:

op1 *= op2;

jt1.setText("" + op1);

break;

case 4:

op1 /= op2;

jt1.setText("" + op1);

break;

}

}

} else if (s.equals("-")) {

str.setLength(0);

if (currentOp == 0) {

preOp = currentOp = 2;// op1=op2;op2=0;

jt1.setText("" + op1);

} else {

currentOp = preOp;

preOp = 2;

switch (currentOp) {

case 1:

op1 = op1 + op2;

jt1.setText("" + op1);

break;

case 2:

op1 = op1 - op2;

jt1.setText("" + op1);

break;

case 3:

op1 = op1 * op2;

jt1.setText("" + op1);

break;

case 4:

op1 = op1 / op2;

jt1.setText("" + op1);

break;

}

}

} else if (s.equals("*"))// *

{

str.setLength(0);

if (currentOp == 0) {

preOp = currentOp = 3;// op1=op2;op2=1;

jt1.setText("" + op1);// op1=op2;

} else {

currentOp = preOp;

preOp = 3;

switch (currentOp) {

case 1:

op1 = op1 + op2;

jt1.setText("" + op1);

break;

case 2:

op1 = op1 - op2;

jt1.setText("" + op1);

break;

case 3:

op1 = op1 * op2;

jt1.setText("" + op1);

break;

case 4:

op1 = op1 / op2;

jt1.setText("" + op1);

break;

}

}

} else if (s.equals("/"))// /

{

str.setLength(0);

if (currentOp == 0) {

preOp = currentOp = 4;// op2=1;

jt1.setText("" + op1);// op1=op2;

} else {

currentOp = preOp;

preOp = 4;

switch (currentOp) {

case 1:

op1 = op1 + op2;

jt1.setText("" + op1);

break;

case 2:

op1 = op1 - op2;

jt1.setText("" + op1);

break;

case 3:

op1 = op1 * op2;

jt1.setText("" + op1);

break;

case 4:

op1 = op1 / op2;

jt1.setText("" + op1);

break;

}

}

} else if (s.equals("="))// =

{

if (currentOp == 0) {

str.setLength(0);

jt1.setText("" + op2);

} else {

str.setLength(0);

currentOp = preOp;

switch (currentOp) {

case 1:

op1 = op1 + op2;

jt1.setText("" + op1);

break;

case 2:

op1 = op1 - op2;

jt1.setText("" + op1);

break;

case 3:

op1 = op1 * op2;

jt1.setText("" + op1);

break;

case 4:

op1 = op1 / op2;

jt1.setText("" + op1);

break;

}

currentOp = 0;

op2 = 0;

}

} else if (s.equals(".")) {

isDouble = true;

if (jt1.getText().trim().indexOf('.') != -1)

;

else {

if (jt1.getText().trim().equals("0")) {

str.setLength(0);

jt1.setText((str.append("0" + s)).toString());

}

// else

// if(jt1.getText().trim().equals("")){}//如果初時顯示為空則不做任何操作

else {

jt1.setText((str.append(s)).toString());

}

}

} else if (s.equals("0"))// 如果選擇的是"0"這個數字鍵

{

if (jt1.getText().trim().equals("0.")) {

} else {

jt1.setText(str.append(s).toString());

op2 = Double.parseDouble(jt1.getText().trim());

}

} else {

jt1.setText(str.append(s).toString());

op2 = Double.parseDouble(jt1.getText().trim());

if (currentOp == 0)

op1 = op2;

}

}

public static void main(String args[])

{

JPanelEa1 g=new JPanelEa1();

}

@Override

public void menuSelected(MenuEvent e) {

// TODO Auto-generated method stub

}

@Override

public void menuDeselected(MenuEvent e) {

// TODO Auto-generated method stub

}

@Override

public void menuCanceled(MenuEvent e) {

// TODO Auto-generated method stub

}

}

用java代碼將1到1000的奇數打出來

這是一個java基礎題

雖然基礎，但是我們練習的時候，可以加以拓展和優化，熟悉for循環 while循環, 了解運算符優先級, ? 加強對業務邏輯的分析處理，強化寫代碼的能力。

首先代碼的寫法是多樣的

1.根據奇數定義 : ? 不能被2所整除的數是奇數

根據這個定義，我們可以寫一個最基礎的版本

public?class?Odd1?{

public?static?void?main(String[]?args)?{

for?(int?i?=?1;?i??1000;?i++)?{//1~1000之間?循環1000次

if(i%2!=0){??//不能被2整除的

System.out.println(i);//就是奇數，打印出來

}

}

}

}

分析下，這個版本，我們發現這個版本性能可能比較低

因為要循環1000次，并且每次還要進行一次求余運算。所以性能低。

有沒有改進的空間？

2. ? 我們繼續對奇數進行了解（對業務進行熟悉）。還有改進的空間

然后發現：?偶數可用2k表示，奇數可用2k+1表示，這里k是整數。

代碼修改如下

public?class?Odd2?{

public?static?void?main(String[]?args)?{

for?(int?k?=?0;?k??500;?k++)?{//循環減少為500次

System.out.println(k*2+1);//按照奇數公式進行輸出

}

}

}

3. ?繼續優化. ? java中乘法是性能消耗比較大的運算, ?如果可以使用移位操作 , ?那么使用移位操作代替乘法

因為使用移位的操作將會更快和更有效

public?class?Odd3?{

public?static?void?main(String[]?args)?{

for?(int?k?=?0;?k??500;?k++)?{

System.out.println((k1)+1);//移位操的優先級低于四則運算,?所以用括號括起來優先計算?,?左移1位.相當于*2

}

}

}

4. ?查看奇數的特性 ?, 來探索其他寫法

奇數1、3、5、7、9、11、13、15、17、19、21、23、25、27、29、31、33.........

每個奇數的間隔是2, 第一個奇數是1

代碼如下

public?class?Odd4?{

public?static?void?main(String[]?args)?{

for?(int?i?=?1;?i??1000;?i+=2)?{//從1開始,每次自加2

System.out.println(i);

}

}

}

5. 除開for循環, ?while循環也可以寫.

public?class?Odd5?{

public?static?void?main(String[]?args)?{

int?i?=?1;

while?(true)?{

if?(i?=?1000)?{

break;//跳出循環

}

System.out.println(i);

i?=?i?+?2;

}

}

}

6 ?再次修改,如果業務邏輯 從1~1000修改成其他數字了, 那么在循環體中修改不是特別合適

所以需要定義成2個變量. 來記錄開始的數字和結束的數字. ?并且如果輸出太多的數字, 不方便查看, ?那么需要美化下輸出的格式

public?class?Odd6?{

public?static?void?main(String[]?args)?{

int?start?=?1;?//開始的數

int?end?=?1000;?//結束的數

int?index?=0;//用于換行處理的計算

for?(int?n?=?start;?n??end;?n?+=?2)?{

index++;

System.out.print(n+"\t");//??\t表示制表符??,這樣數字看起來排列比較整齊

if(index%10==0){//每10個數字,換一行

System.out.println();

}

}

}

}

java中的單例模式的代碼怎么寫

我從我的博客里把我的文章粘貼過來吧，對于單例模式模式應該有比較清楚的解釋：

單例模式在我們日常的項目中十分常見，當我們在項目中需要一個這樣的一個對象，這個對象在內存中只能有一個實例，這時我們就需要用到單例。

一般說來，單例模式通常有以下幾種：

1.饑漢式單例

public class Singleton {

private Singleton(){};

private static Singleton instance = new Singleton();

public static Singleton getInstance(){

return instance;

}

}

這是最簡單的單例，這種單例最常見，也很可靠！它有個唯一的缺點就是無法完成延遲加載——即當系統還沒有用到此單例時，單例就會被加載到內存中。

在這里我們可以做個這樣的測試：

將上述代碼修改為：

public class Singleton {

private Singleton(){

System.out.println("createSingleton");

};

private static Singleton instance = new Singleton();

public static Singleton getInstance(){

return instance;

}

public static void testSingleton(){

System.out.println("CreateString");

}

}

而我們在另外一個測試類中對它進行測試（本例所有測試都通過Junit進行測試）

public class TestSingleton {

@Test

public void test(){

Singleton.testSingleton();

}

}

輸出結果：

createSingleton

CreateString

我們可以注意到，在這個單例中，即使我們沒有使用單例類，它還是被創建出來了，這當然是我們所不愿意看到的，所以也就有了以下一種單例。

2.懶漢式單例

public class Singleton1 {

private Singleton1(){

System.out.println("createSingleton");

}

private static Singleton1 instance = null;

public static synchronized Singleton1 getInstance(){

return instance==null?new Singleton1():instance;

}

public static void testSingleton(){

System.out.println("CreateString");

}

}

上面的單例獲取實例時，是需要加上同步的，如果不加上同步，在多線程的環境中，當線程1完成新建單例操作，而在完成賦值操作之前，線程2就可能判

斷instance為空，此時，線程2也將啟動新建單例的操作，那么多個就出現了多個實例被新建，也就違反了我們使用單例模式的初衷了。

我們在這里也通過一個測試類，對它進行測試，最后面輸出是

CreateString

可以看出，在未使用到單例類時，單例類并不會加載到內存中，只有我們需要使用到他的時候，才會進行實例化。

這種單例解決了單例的延遲加載，但是由于引入了同步的關鍵字，因此在多線程的環境下，所需的消耗的時間要遠遠大于第一種單例。我們可以通過一段測試代碼來說明這個問題。

public class TestSingleton {

@Test

public void test(){

long beginTime1 = System.currentTimeMillis();

for(int i=0;i100000;i++){

Singleton.getInstance();

}

System.out.println("單例1花費時間："+(System.currentTimeMillis()-beginTime1));

long beginTime2 = System.currentTimeMillis();

for(int i=0;i100000;i++){

Singleton1.getInstance();

}

System.out.println("單例2花費時間："+(System.currentTimeMillis()-beginTime2));

}

}

最后輸出的是：

單例1花費時間：0

單例2花費時間：10

可以看到，使用第一種單例耗時0ms，第二種單例耗時10ms，性能上存在明顯的差異。為了使用延遲加載的功能，而導致單例的性能上存在明顯差異，

是不是會得不償失呢？是否可以找到一種更好的解決的辦法呢？既可以解決延遲加載，又不至于性能損耗過多，所以，也就有了第三種單例：

3.內部類托管單例

public class Singleton2 {

private Singleton2(){}

private static class SingletonHolder{

private static Singleton2 instance=new Singleton2();

}

private static Singleton2 getInstance(){

return SingletonHolder.instance;

}

}

在這個單例中，我們通過靜態內部類來托管單例，當這個單例被加載時，不會初始化單例類，只有當getInstance方法被調用的時候，才會去加載

SingletonHolder，從而才會去初始化instance。并且，單例的加載是在內部類的加載的時候完成的，所以天生對線程友好，而且也不需要

synchnoized關鍵字，可以說是兼具了以上的兩個優點。

4.總結

一般來說，上述的單例已經基本可以保證在一個系統中只會存在一個實例了，但是，仍然可能會有其他的情況，導致系統生成多個單例，請看以下情況：

public class Singleton3 implements Serializable{

private Singleton3(){}

private static class SingletonHolder{

private static Singleton3 instance = new Singleton3();

}

public static Singleton3 getInstance(){

return SingletonHolder.instance;

}

}

通過一段代碼來測試：

@Test

public void test() throws Exception{

Singleton3 s1 = null;

Singleton3 s2 = Singleton3.getInstance();

//1.將實例串行話到文件

FileOutputStream fos = new FileOutputStream("singleton.txt");

ObjectOutputStream oos =new ObjectOutputStream(fos);

oos.writeObject(s2);

oos.flush();

oos.close();

//2.從文件中讀取出單例

FileInputStream fis = new FileInputStream("singleton.txt");

ObjectInputStream ois = new ObjectInputStream(fis);

s1 = (Singleton3) ois.readObject();

if(s1==s2){

System.out.println("同一個實例");

}else{

System.out.println("不是同一個實例");

}

}

輸出：

不是同一個實例

可以看到當我們把單例反序列化后，生成了多個不同的單例類，此時，我們必須在原來的代碼中加入readResolve()函數，來阻止它生成新的單例

public class Singleton3 implements Serializable{

private Singleton3(){}

private static class SingletonHolder{

private static Singleton3 instance = new Singleton3();

}

public static Singleton3 getInstance(){

return SingletonHolder.instance;

}

//阻止生成新的實例

public Object readResolve(){

return SingletonHolder.instance;

}

}

再次測試時，就可以發現他們生成的是同一個實例了。

這個JAVA程序的運行結果為什么是20不是19？ class Student{ static in

因為year 是static 靜態類型，靜態變量無論你new 多少個對象，值是共用的，先S1.year=19；后你又S2.year=20， 所以 無論是 輸出S1.year還是S2.year都是20，你要是不S2.year=20 那么 S2.year 輸出的就是19了

新聞名稱：關于19的java代碼的信息
標題來源：http://vcdvsql.cn/article26/hpgpcg.html

成都網站建設公司_創新互聯，為您提供標簽優化、移動網站建設、外貿建站、品牌網站建設、商城網站、網站改版

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯

外貿網站制作