java程序设计？java编辑器手机版
各位老铁们，大家好，今天由我来为大家分享java程序设计，以及java编辑器手机版的相关问题知识，希望对大家有所帮助。如果可以帮助到大家，还望关注收藏下本站，您的支持是我们最大的动力，谢谢大家了哈，下面我们开始吧！
JAVA程序设计主要讲的是什么
第一：Java基础语法。虽然Java语言经过了多次版本迭代，但是Java语言的基础语法一直秉持着纯粹的面向对象方式，所以Java的根基始终没有变化。学习Java基础语法的关键在于理解各种抽象，包括类、抽象类、接口等，另外还需要掌握封装、继承和多态这一系列面向对象语言的特征。
第二：Web开发。Web开发是Java目前重要的开发方向之一，也是几乎每一名Java程序员都会掌握的内容。Web开发的内容包括两个大的部分，一部分是前端开发，另一部分是后端开发。随着大数据的发展，Java全栈程序员正在成为一个重要的岗位，所以前端开发知识对于Java程序员来说也比较重要。前端开发的重点在于Html、CSS和JavaScript，尤其是JavaScript要重点学习一下。后端开发要掌握的技术包括Servlet、JavaBean、JDBC以及Spring框架（SpringBoot、SpringCloud、SpringMVC）。
第三：大数据开发。在当前的大数据时代背景下，学习大数据开发方向的相关知识是不错的选择。Java语言既可以从事大数据平台研发，也可以从事大数据应用开发，对于初学者来说，从大数据应用开发开始学起是比较现实的选择，比如Hadoop开发。
java入门的程序设计..高手们解答.不甚感激!!!
【第一题】
运行出来后增加了清零按钮，可以给另外一个按钮清零，程序如下：
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class ButtonTest extends JFrame implements ActionListener
{
int i=0;
JButton jb1= new JButton("准备开始");
JButton jb2= new JButton("按钮清零");
FlowLayout fl= new FlowLayout();
ButtonTest()
{
setTitle("按钮计数器");
setSize(300,200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.getContentPane().setLayout(fl);
this.getContentPane().add(jb1);
this.getContentPane().add(jb2);
jb1.addActionListener(this);
jb2.addActionListener(this);
show();
}
public void actionPerformed(ActionEvent e)
{
Object source= e.getSource();
if(source== jb1)
{
int count=++i;
String str= Integer.toString(count);
jb1.setText(str);
}
if(source== jb2)
{
jb1.setText("0");
}
}
public static void main(String[] args)
{
ButtonTest bt= new ButtonTest();
}
}
【第二题】
也增加了一个清零按钮，可以清零进行多次运算，代码如下：
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class TextFieldTest extends JFrame implements ActionListener
{
JLabel jl= new JLabel("请输入一个数字：");
JTextField jtf= new JTextField(10);
JButton jbt1= new JButton("计算结果");
JButton jbt2= new JButton("清零按钮");
FlowLayout fl= new FlowLayout();
TextFieldTest()
{
setTitle("输入框测试");
setSize(300,200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.getContentPane().setLayout(fl);
this.getContentPane().add(jl);
this.getContentPane().add(jtf);
this.getContentPane().add(jbt1);
this.getContentPane().add(jbt2);
jbt1.addActionListener(this);
jbt2.addActionListener(this);
show();
}
public void actionPerformed(ActionEvent e)
{
int sum= 0;
Object source= e.getSource();
if(source== jbt1)
{
String str= jtf.getText();
for(int i=0; i<str.length(); i++)
{
if(str.charAt(i)>'9'|| str.charAt(i)<'0'){
jtf.setText("请输入一个数字");
return;
}
int in= Integer.parseInt(str);
for(int j= 0;j<=in;j++)
{
sum+= j;
}
String s= Integer.toString(sum);
jtf.setText(s);
}
}
if(source== jbt2)
{
jtf.setText("0");
}
}
public static void main(String[] args)
{
TextFieldTest tft= new TextFieldTest();
}
}
两段代码经测试OK，希望能对楼主有所帮助，有问题请给我纸条。
如何优化java程序设计和编码,提高java性能
下面给你提供一些在JAVA程序的设计和编码中，经常采用的一些方法和技巧，可以提高JAVA程序的性能：
1．对象的生成和大小的调整。
JAVA程序设计中一个普遍的问题就是没有好好的利用JAVA语言本身提供的函数，从而常常会生成大量的对象（或实例）。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响。
例1：关于String,StringBuffer，+和append
JAVA语言提供了对于String类型变量的操作。但如果使用不当，会给程序的性能带来影响。如下面的语句：
String name=new String("HuangWeiFeng");
System.out.println(name+"is my name");
看似已经很精简了，其实并非如此。为了生成二进制的代码，要进行如下的步骤和操作：
(1)生成新的字符串 new String（STR_1);
(2)复制该字符串;
(3)加载字符串常量"HuangWeiFeng"（STR_2);
(4)调用字符串的构架器（Constructor）;
(5)保存该字符串到数组中（从位置0开始）;
(6)从java.io.PrintStream类中得到静态的out变量;
(7)生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
(8)复制该字符串缓冲变量;
(9)调用字符串缓冲的构架器（Constructor）;
(10)保存该字符串缓冲到数组中（从位置1开始）;
(11)以STR_1为参数，调用字符串缓冲(StringBuffer)类中的append方法;
(12)加载字符串常量"is my name"(STR_3);
(13)以STR_3为参数，调用字符串缓冲(StringBuffer)类中的append方法;
(14)对于STR_BUF_1执行toString命令;
(15)调用out变量中的println方法，输出结果。
由此可以看出，这两行简单的代码，就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五个对象变量。这些生成的类的实例一般都存放在堆中。堆要对所有类的超类，类的实例进行初始化，同时还要调用类极其每个超类的构架器。而这些操作都是非常消耗系统资源的。因此，对对象的生成进行限制，是完全有必要的。
经修改，上面的代码可以用如下的代码来替换。
StringBuffer name=new StringBuffer("HuangWeiFeng");
System.out.println(name.append("is my name.").toString());
系统将进行如下的操作：
(1)生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
(2)复制该字符串缓冲变量;
(3)加载字符串常量"HuangWeiFeng"(STR_1);
(4)调用字符串缓冲的构架器（Constructor）;
(5)保存该字符串缓冲到数组中（从位置1开始）;
(6)从java.io.PrintStream类中得到静态的out变量;
(7)加载STR_BUF_1;
(8)加载字符串常量"is my name"(STR_2);
(9)以STR_2为参数，调用字符串缓冲(StringBuffer)实例中的append方法;
(10)对于STR_BUF_1执行toString命令(STR_3);
(11)调用out变量中的println方法，输出结果。
由此可以看出，经过改进后的代码只生成了四个对象变量：STR_1,STR_2,STR_3和STR_BUF_1.你可能觉得少生成一个对象不会对程序的性能有很大的提高。但下面的代码段2的执行速度将是代码段1的2倍。因为代码段1生成了八个对象，而代码段2只生成了四个对象。
代码段1：
String name= new StringBuffer("HuangWeiFeng");
name+="is my";
name+="name";
代码段2：
StringBuffer name=new StringBuffer("HuangWeiFeng");
name.append("is my");
name.append("name.").toString();
因此，充分的利用JAVA提供的库函数来优化程序，对提高JAVA程序的性能时非常重要的.其注意点主要有如下几方面；
(1)尽可能的使用静态变量（Static Class Variables）
如果类中的变量不会随他的实例而变化，就可以定义为静态变量，从而使他所有的实例都共享这个变量。
例：
public class foo
{
SomeObject so=new SomeObject();
}
就可以定义为：
public class foo
{
static SomeObject so=new SomeObject();
}
(2)不要对已生成的对象作过多的改变。
对于一些类(如：String类)来讲，宁愿在重新生成一个新的对象实例，而不应该修改已经生成的对象实例。
例：
String name="Huang";
name="Wei";
name="Feng";
上述代码生成了三个String类型的对象实例。而前两个马上就需要系统进行垃圾回收处理。如果要对字符串进行连接的操作，性能将得更差，因为系统将不得为此生成更多得临时变量，如上例1所示。
(3)生成对象时，要分配给它合理的空间和大小JAVA中的很多类都有它的默认的空间分配大小。对于StringBuffer类来讲，默认的分配空间大小是16个字符。如果在程序中使用StringBuffer的空间大小不是16个字符，那么就必须进行正确的初始化。
(4)避免生成不太使用或生命周期短的对象或变量。对于这种情况，因该定义一个对象缓冲池。以为管理一个对象缓冲池的开销要比频繁的生成和回收对象的开销小的多。
(5)只在对象作用范围内进行初始化。JAVA允许在代码的任何地方定义和初始化对象。这样，就可以只在对象作用的范围内进行初始化。从而节约系统的开销。
例：
SomeObject so=new SomeObject();
If(x==1) then
{
Foo=so.getXX();
}
可以修改为：
if(x==1) then
{
SomeObject so=new SomeObject();
Foo=so.getXX();
}
2．异常(Exceptions)
JAVA语言中提供了try/catch来发方便用户捕捉异常，进行异常的处理。但是如果使用不当，也会给JAVA程序的性能带来影响。因此，要注意以下两点：
(1)避免对应用程序的逻辑使用try/catch
如果可以用if,while等逻辑语句来处理，那么就尽可能的不用try/catch语句。
(2)重用异常
在必须要进行异常的处理时，要尽可能的重用已经存在的异常对象。以为在异常的处理中，生成一个异常对象要消耗掉大部分的时间。
3.线程(Threading)
一个高性能的应用程序中一般都会用到线程。因为线程能充分利用系统的资源。在其他线程因为等待硬盘或网络读写而时，程序能继续处理和运行。但是对线程运用不当，也会影响程序的性能。
例2：正确使用Vector类
Vector主要用来保存各种类型的对象（包括相同类型和不同类型的对象）。但是在一些情况下使用会给程序带来性能上的影响。这主要是由Vector类的两个特点所决定的。第一，Vector提供了线程的安全保护功能。即使Vector类中的许多方法同步。但是如果你已经确认你的应用程序是单线程，这些方法的同步就完全不必要了。第二，在Vector查找存储的各种对象时，常常要花很多的时间进行类型的匹配。而当这些对象都是同一类型时，这些匹配就完全不必要了。因此，有必要设计一个单线程的，保存特定类型对象的类或集合来替代Vector类.用来替换的程序如下（StringVector.java）：
public class StringVector
{
private String [] data;
private int count;
public StringVector()
{
this(10);// default size is 10
}
public StringVector(int initialSize)
{
data= new String[initialSize];
}
public void add(String str)
{
// ignore null strings
if(str== null){ return;}
ensureCapacity(count+ 1);
data[count++]= str;
}
private void ensureCapacity(int minCapacity)
{
int oldCapacity= data.length;
if(minCapacity> oldCapacity)
{
String oldData[]= data;
int newCapacity= oldCapacity* 2;
data= new String[newCapacity];
System.arraycopy(oldData, 0, data, 0, count);
}
}
public void remove(String str)
{
if(str== null){ return;// ignore null str}
for(int i= 0; i< count; i++)
{
// check for a match
if(data[i].equals(str))
{
System.arraycopy(data,i+1,data,i,count-1);// copy data
// allow previously valid array element be gc′d
data[--count]= null;
return;
}
}
}
public final String getStringAt(int index)
{
if(index< 0){ return null;}
else if(index> count){ return null;// index is># strings}
else{ return data[index];// index is good}
}
}
因此，代码：
Vector Strings=new Vector();
Strings.add("One");
Strings.add("Two");
String Second=(String)Strings.elementAt(1);
可以用如下的代码替换：
StringVector Strings=new StringVector();
Strings.add("One");
Strings.add("Two");
String Second=Strings.getStringAt(1);
这样就可以通过优化线程来提高JAVA程序的性能。用于测试的程序如下（TestCollection.java）:
import java.util.Vector;
public class TestCollection
{
public static void main(String args [])
{
TestCollection collect= new TestCollection();
if(args.length== 0)
{
System.out.println("Usage: java TestCollection [ vector| stringvector ]");
System.exit(1);
}
if(args[0].equals("vector"))
{
Vector store= new Vector();
long start= System.currentTimeMillis();
for(int i= 0; i< 1000000; i++)
{
store.addElement("string");
}
long finish= System.currentTimeMillis();
System.out.println((finish-start));
start= System.currentTimeMillis();
for(int i= 0; i< 1000000; i++)
{
String result=(String)store.elementAt(i);
}
finish= System.currentTimeMillis();
System.out.println((finish-start));
}
else if(args[0].equals("stringvector"))
{
StringVector store= new StringVector();
long start= System.currentTimeMillis();
for(int i= 0; i< 1000000; i++){ store.add("string");}
long finish= System.currentTimeMillis();
System.out.println((finish-start));
start= System.currentTimeMillis();
for(int i= 0; i< 1000000; i++){
String result= store.getStringAt(i);
}
finish= System.currentTimeMillis();
System.out.println((finish-start));
}
}
}
关于线程的操作，要注意如下几个方面：
(1)防止过多的同步
如上所示，不必要的同步常常会造成程序性能的下降。因此，如果程序是单线程，则一定不要使用同步。
(2)同步方法而不要同步整个代码段
对某个方法或函数进行同步比对整个代码段进行同步的性能要好。
(3)对每个对象使用多”锁”的机制来增大并发。
一般每个对象都只有一个”锁”，这就表明如果两个线程执行一个对象的两个不同的同步方法时，会发生”死锁”。即使这两个方法并不共享任何资源。为了避免这个问题，可以对一个对象实行”多锁”的机制。如下所示：
class foo
{
private static int var1;
private static Object lock1=new Object();
private static int var2;
private static Object lock2=new Object();
public static void increment1()
{
synchronized(lock1)
{
var1++;
}
}
public static void increment2()
{
synchronized(lock2)
{
var2++;
}
}
}
4．输入和输出(I/O)
输入和输出包括很多方面，但涉及最多的是对硬盘，网络或数据库的读写操作。对于读写操作，又分为有缓存和没有缓存的；对于数据库的操作，又可以有多种类型的JDBC驱动器可以选择。但无论怎样，都会给程序的性能带来影响。因此，需要注意如下几点：
(1)使用输入输出缓冲
尽可能的多使用缓存。但如果要经常对缓存进行刷新（flush）,则建议不要使用缓存。
(2)输出流(Output Stream)和Unicode字符串
当时用Output Stream和Unicode字符串时，Write类的开销比较大。因为它要实现Unicode到字节(byte)的转换.因此，如果可能的话,在使用Write类之前就实现转换或用OutputStream类代替Writer类来使用。
(3)当需序列化时使用transient
当序列化一个类或对象时，对于那些原子类型（atomic）或可以重建的原素要表识为transient类型。这样就不用每一次都进行序列化。如果这些序列化的对象要在网络上传输，这一小小的改变对性能会有很大的提高。
(4)使用高速缓存（Cache）
对于那些经常要使用而又不大变化的对象或数据，可以把它存储在高速缓存中。这样就可以提高访问的速度。这一点对于从数据库中返回的结果集尤其重要。
(5)使用速度快的JDBC驱动器（Driver）
JAVA对访问数据库提供了四种方法。这其中有两种是JDBC驱动器。一种是用JAVA外包的本地驱动器；另一种是完全的JAVA驱动器。具体要使用哪一种得根据JAVA布署的环境和应用程序本身来定。
5.一些其他的经验和技巧
(1)使用局部变量。
(2)避免在同一个类中动过调用函数或方法(get或set)来设置或调用变量。
(3)避免在循环中生成同一个变量或调用同一个函数（参数变量也一样）。
(4)尽可能的使用static,final,private等关键字。
(5)当复制大量数据时，使用System.arraycopy()命令。
关于本次java程序设计和java编辑器手机版的问题分享到这里就结束了，如果解决了您的问题，我们非常高兴。