JAVA基础
经典三层结构：逻辑层 DAO DB
修饰符: private 私有 public 公共 static 静态的
Eclipse快捷键
- Ctrl+1 快速修复，可修复import类，try catch包围等
- Ctrl+z 后退一步
- Ctrl+y 重做，与撤销ctrl+z相反
- Ctrl+/ 注释选中的语句
- Alt+？或Alt+/ 自动补全代码或者提示代码
- Ctrl+o 快速outline视图
- Ctrl+m 当前编辑页面窗口最大化
- Ctrl+shift+/ 自动注释掉选择的代码块
- Ctrl+shift+o 自动引入包和删除无用包
- Ctrl+s 保存
- ctrl+f 查找界面中的成员
- alt +/ 重写方法
JAVA常见语句
定义字符串
String s;
s=new String(“Hello World”);main入口语句
Public static void main(String[] args)
{
}输出语句
System.out.println(“这是一条输出语句”+变量);
键盘输入命令
- 第一种方法
Int a; String name; Scanner reader=new Scanner(System.in); System.out.print(“请输入：”); a=reader.nextInt();//这是输入数字的方法 name=reader.nextLine();//这是输入字符串方法 - 第二种方法
Int a; String name; String str; public void getinfo() throws IOException{ //需要处理IOException异常，不然不能运行，会出错 BufferedReader buf; buf=new BufferedReader(new InputStreamReader(System.in)); studentNumber=buf.readLine();//输入字符串 str= buf.readLine(); a=Integer.parseInt(str);//此方法输入字符串后，需要将其转换为数字。 }
switch语句
int a;
switch(a)
{
case 1:
case 2:
case 3:
System.out.print(“这是一个输出”);
break;
default:
System.out.print(“这是第二个输出”);
}子类的继承
- 继承不是缩小，而是拓展。子类不可以有多个父类，父类可以有多个子类。继承是单继承。
class SubClass extends SuperClass { }数组的定义
- 动态定义
Int[] i=new int[4]; - 静态定义
Int[] i=new int[]{1,2,3,4};
冒泡排序
int temp=0;
int[] arr=new int[]{3,8,45,9,1,-9};
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++)
{
if(arr[j]>arr[j+1])
{
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
for(int a=0;a<arr.length;a++)
{
System.out.println(arr[a]);
}For-Each循环：可直接输出数组
int[] arr={8,9,7,6,5,1,2};
for(int element:arr)
{
System.out.println(element);
}对象的创建和调用
- 对象文件，没有对象就new一个
创建对象
package toolpackage;
public class student {
String name;
int age;
String adress;
public void showinfo(){
System.out.println("我的名字为："+name+",年龄："+age+",家庭住址："+adress);
}
public void value1(){
name="zhangsan";
age=13;
adress="chongqingyubei";
}
public String study(){
adress="chongqing";
int age=23;
return adress;
}
}调用对象
student student1=new student();
student1.value1();
student1.showinfo();
String a=student1.study();
System.out.println(a);以数组为形参的方法
public void printInfo(String[] args){
for(int i=0;i<args.length;i++)
System.out.println(args[i]);
}调用方法
student s=new student();
String[] ss=new String[]{"zhangsan","11"};
s.printInfo(ss);以…为形参的方法，Java特有
public void printInfo1(String... args){
for(int i=0;i<args.length;i++)
System.out.println(args[i]);
}调用方法
student s=new student();
String[] ss1=new String[]{"北京XXXXXX","123442442","5002345555"};
s.printInfo(ss1);
s.printInfo1("zhangsan","22","1599455555","想你");JVM的内存模型
方法的参数传递，有参和对象传递
对属性的封装和隐藏的实例
- 在同一个包下的类，import可以忽略，只需实例化。
- 对不能让调用者随意调用的属性进行封装和影藏。用private进行封装和隐藏。
private封装属性
package toolpackage.text;
public class text01 {
/**
* 可将易出现错误的age封装成私有的，如age=-200;
* setAge()方法可通过判断是否将值赋给age，不满足条件就不予赋值.
* getAge()方法可将private属性的age的值传递出来，便于使用
*/
private int age=15;
public void setAge(int a){
if(a<=150&&a>=0){
age=a;
}else
System.out.println("输入的年龄:"+a+"不在0到150");
}
private void printAge(){
System.out.println("年龄为:"+age);
}
public int getAge(){
return age;
}
}package toolpackage.text;
public class text02 {
public static void main(String[] args){
text01 a=new text01();
a.setAge(193);
int age1=a.getAge();
//a.printAge();
System.out.println("年龄为:"+age1);
}
}JDK中主要的包
四种访问权限修饰符
- Private只能在同一个类下使用
- （缺省）可以在同一个类下和同一个包下使用，不用import
//private 运用 /*private int age=15; public void setAge(int a){ if(a<=150&&a>=0){ age=a; }else System.out.println("输入的年龄:"+a+"不在0到150"); } private void printAge(){ System.out.println("年龄为:"+age); } public int getAge(){ return age; } */ //缺省的运用 /*int age; void getAge(){ System.out.println("年龄："+age); } public void test() { getAge(); }*/ public static void main(String[] args){ //private运用 /*text01 a=new text01(); a.setAge(193); int age1=a.getAge(); //a.printAge(); System.out.println("年龄为:"+age1);*/ //缺省运用 /*text01 a=new text01(); a.age=1; a.getAge();*/ }
package toolpackage.text;
import toolpackage.student;
//这是class text02的之类，用关键字extends
//子类可以使用protected和public的变量和方法，注意虽然创建的方法调用变量和发法时，不需要实例化，但在main方法中需要实例化才能使用。
public class text02Child extends student {
//子类在方法中不需要实例化，但在main函数方法中需要对方法和属性实例化。
public void text(){
name="zhanannsh";
showinfo();
value1();}
public static void main(String[] args){
text02Child a=new text02Child();
a.text();
}
}This 关键字
- 为了区分实参和虚参，需要用到this关键字。用this修饰的属性是实参。
String love; public String getLove() { return love; } public void setLove(String love) { this.love = love; }
JavaBean（set和get方法）
- 通过eclipse快速写set和get方法，右键>选择source>选择Generate Getters and Setters>选择需要set和get的属性
多态性(继承和实现关系、要有覆盖操作)
- 方法的重载（overload） 方法的重写（overwrite）
- Person p=new person();调用的是父类person的属性和方法。
- Student s=new student();调用的是子类student的属性和方法。
- Person e=new student();调用的是父类的属性，子类的方法。简言之就是子类的升级成虚拟父类。
- 虚拟方法调用：父类引用子类的对象，父类只能使用子类的方法，属性只能使用父类的，因为程序- 先编译后运行，方法是在运行的时候进站出站的，而成员变量是提前编译好不可改变的。
理解编译时和运行时的关系:
Instanceof操作符
- X instanceof a 作用检测x是否为类a的对象，返回值为boolean型。
例如：student s=new student(); person p=new person(); person e=new student(); System.out.println(e instanceof person);//instanceof检验某个对象是不是类person的子类
Object类
- Object类是所有Java类的根父类，基类。多层继承，处于最高层的父类一定是object类。
System.out.println(p.equals(e));//结果是false，在编译时，堆内存有P的实例化，还有e的实例化，两者是不一样的。 Object o=new person(); System.out.println(o.hashCode()); //p.hashCode();//虽然hashCode()属于object的方法，但object是所有类的父类，所以hashCode()方法其它类也是可以用的。 System.out.println(p.hashCode()); System.out.println(p.toString());
对象类型的转换
- 对象类型转化跟数据类型转换本质是一样的，子类转化成父类，自动转换，父类转换成子类，需要强制转换。
student t=(student) p;//强制转换 person d=s;//自动转换 对象类型转换的应用： t.method(new student()); public void method(person e){ if(e instanceof student){ student s1=(student) e; s1.text2(); }else e.text1(); }
==和equals的区别
/**
* ==和equals方法的区别：对于对象来说，特殊的类，如String、File、Date，使用==比较的是对象（对象的地址）
* equals比较的内容，除了特殊类之外的其他普通的类对象，==和equals比较的都是对象（对象的内存地址）
* 如果你想改变某一个类的equals，不想用equals来比较对象的内存地址，就需要重写equals方法
*/
student s=new student();
person e=new student();
String s1=new String("abc");
String s2=new String("abc");
System.out.println(s==e);//结果false
System.out.println(s1.equals(s2));//结果true包装类（Wrapper）、parseXxx()静态方法、valueOf()方法和toString方法
Integer i=new Integer(112);
int i0=i.intValue();
System.out.println(i0);
Integer i1=123;//自动装箱
int i2=i1;//自动拆箱
System.out.println(i2);
ParseXxx()静态方法
int i=Integer.parseInt("asd");//将字符串类型转化成其他数据类型
float f=Float.parseFloat("aws");
boolean boo=Boolean.parseBoolean("false");
String istr=String.valueOf(i);//将其他数据类型转化成字符串
父类Object的toString方法就输出当前对象的内存地址，如果要你想要输出类的其他信息，重写toString方法关键字static
- Static 静态的
- 用static修饰的变量是类变量，类变量不需要实例化，直接类名.属性名就可以使用，是类的一部分，被所有这个类的实例化对象所共享。
- 实例变量，只有实例化之后才能使用，属于实例化对象的一部分，不能共用。
- 类方法，直接类名.方法名调用，一般工具类需要类方法
单例（Singleton）设计模式
- 设计模式就是在我们实际编程过程中，逐渐总结出的一些解决问题的套路。
- 单例就是只有一个实例（实例化对象），在整个软件系统运行过程中，这个类只被实例化一次，以后不论在哪都只调用这一个实例。例如：实例化对象的创建要消耗大量的时间和资源.
- 饿汉式单例设计模式：就是一开始就确定调用的实例，后面也一直使用这个实例。
- 单例模式，软件的运行有且仅有一个实例化对象（只会new一次）
- 第一步：//构造方法私有化，调用这个类的人，不能直接使用new来创建对象
private Single(){} - 第二步：//私有的Single类型的变量
`private static Single single=new Single();
public static Single getInstance(){return single;}` - 第三步：Single s1=Single.getInstance();//调用
- 懒汉式单例设计模式：一开始为空，调用后才实例化，后面也一直使用这个实例。
- 第一步：//私有化构造方法，让外类不能直接new对象
private Single1(){} - 第二步：private static Single1 s1=null;
`public static Single1 getInstance(){
}`if(s1==null){ s1=new Single1(); } return s1; - 第三步：
Single1 s2=Single1.getInstance();//调用 - 懒汉式和饿汉式的区别，就是什么时候new这个对象，懒汉式，是在第一次有人调用getInstance方法时来new对象，以后再有人调用getInstance方法直接就返回之前第一次new好的对象。
- 饿汉式，是在类加载之后，还没有人调用的时候，就先new好一个对象，以后无论谁来调用getInstance方法，都是直接返回之前new好的那个对象。
- 暂时懒汉式还存在线程安全问题，讲到多线程时，可修复。
初始代码块
public class Person {
String name;
int age;
static String address;
public Person(){
this.name="张三";
this.age=25;
System.out.println("这是类下构造器的方法name"+name+"age"+age);
}
public void showperson(String name,int age){
this.name=name;
this.age=age;
System.out.println("这是类下的方法"+"name:"+name+"age:"+age);
}
{//可以有静态属性，也可以是非静态代码块
System.out.println("这是非静态的代码块");
}
static {//静态代码块中的成员是静态的属性和方法，不然就会报错
address="123";
System.out.println("这是静态的代码块");
}
}public class text {
public static void main(String[] args){
Person ps=new Person();
//在new Person();执行的时候，第一步：类属性的默认初始化和显式初始化。第二步：执行代码块的代码。第三步：执行构造器的代码
ps.showperson("李书记", 45);
/*结果：这是静态的代码块
这是非静态的代码块
这是类下构造器的方法name张三age25
这是类下的方法name:李书记age:45
结论：静态代码块优于非静态代码块
不论new几次对象，静态代码块只执行一次，非静态代码每次new都会重新执行
在实际开发中，static静态代码块用在初始化类的静态属性（static类型属性）
*/
}
}匿名内部类
- 匿名内部类：可以重写类中的方法，实际上是构建了一个没有类名Person的子类，也就是匿名的Person的子类。
- 这种类没有类名，就不能通过new的方法创建对象，如果要是还在构造器中初始化属性就没有办法了，这样情况就要用代码块{}初始化的工作。
Person ps1=new Person(){ {//在匿名内部类中，用代码块代替构造方法 super.name="程翔"; System.out.println("=-====="); System.out.println(name); } //在匿名内部类中，可重写super类的方法 @Override public void showperson(String name, int age) { // TODO Auto-generated method stub super.showperson(name, age); } };
关键字：final
- Final修饰的方法不能被重写，final修饰的类不能被继承，final表示最终类。Final修饰的变量就是常量，常量必须显示赋值，final static 修饰的变量就是全局常量，常量最好写成大写。
抽象类（abstract class）和final关键字
- 只要类中有一个抽象方法，类就必须是一个抽象类。
- 抽象化处理不写具体实现，继承的时候才写。
public abstract class animal { public abstract void text(); public abstract void move(); public static void main(String[] args){ dog d=new dog(); d.move(); fish f=new fish(); f.move(); } } class dog extends animal{ @Override public void text() { // TODO Auto-generated method stub } @Override public void move() { // TODO Auto-generated method stub System.out.println("狗的移动方式是跑"); } } class fish extends animal{ @Override public void text() { // TODO Auto-generated method stub } @Override public void move() { // TODO Auto-generated method stub System.out.println("鱼的移动方式是游"); } } abstract class bird extends animal{ @Override public void move() { // TODO Auto-generated method stub } public abstract void text();//类中有抽象方法，那么类必须是一个抽象类 } - Final是最终，它修饰的类是最终的类，不能被继承，抽象类，如果想要使用，必须继承抽象类，实现那些抽象的方法。
模板方法设计模式（TemplateMethod）
- 抽象类就像一个大纲，里面的抽象方法就是每个章节的标题，子类根据这些标题把每个章节细化出来。
public abstract class TemplateMethod { public abstract void code(); public final void gettime(){ long start =System.currentTimeMillis(); code(); long end =System.currentTimeMillis(); System.out.println("code方法执行时间："+(end-start)); } } class TestTmp extends TemplateMethod{ @Override public void code() { int k=0; for(int i=0;i<500000;i++){ k+=1; } System.out.println(k); } }public class showtext { public static void main(String[] args){ TestTmp tm=new TestTmp(); tm.gettime(); } }
接口（interface）
- 因为Java不支持多重继承，而接口可以实现多重继承的效果。一个类可以实现多个接口，接口也可以继承其它接口。
- 接口中的所有成员变量都默认是由public static final修饰的。接口中的所有方法都默认是由public abstract修饰的。接口没有构造器，接口采用多层继承机制。
- 接口可以继承接口
public interface textIn {//接口1 int ID=1;//等同于 public static final ID=1; void test();//等同于public abstract test(); } public interface textId1 {//接口2 void test1(); } //接口的实现 public class textImpl implements textIn,textId1 { @Override public void test() { // TODO Auto-generated method stub } @Override public void test1() { // TODO Auto-generated method stub } } public interface textIn2 extends textIn{ //可以接口继承接口 } - 抽象类是对于一类事物的高度抽象，其中既有属性也有方法。接口是对方法的抽象，也是对一系列动作的抽象。当需要对一类事物抽象的时候，应该是使用抽象类，好形成一个父类。当需要对一系列的动作抽象，就使用接口，需要使用这些动作的类去是实现相应的接口即可。
工厂方法（FactoryMethod）
- FactoryMethod模式通过面向对象的手法，将要创建的具体对象的创建工作延迟到了子类，从而提供了一种扩展的策略，较好的解决了这种紧耦合的关系。在真正开发中，利用工厂方法，可以将大家写的代码集合成一个项目。
- 程序员A的工作：
public interface BWM { void showInfo(); } class BWM3i implements BWM{ public void showInfo() { System.out.println("这个是宝马3系车"); } } class BWM5 implements BWM{ public void showInfo() { System.out.println("这个是宝马5系车"); } } class BWM7 implements BWM{ public void showInfo() { System.out.println("这个是宝马7系车"); } } public interface BWMFactory { BWM productBWM(); } class BWM3Factory implements BWMFactory{ public BWM productBWM() { System.out.println("生产宝马3系车"); return new BWM3i(); } } class BWM5Factory implements BWMFactory{ public BWM productBWM() { System.out.println("生产宝马5系车"); return new BWM5(); } } class BWM7Factory implements BWMFactory{ public BWM productBWM() { System.out.println("生产宝马7系车"); return new BWM7(); } } - 程序员B的工作：
public class text { public static void main(String[] args){ BWM b3=new BWM3Factory().productBWM(); b3.showInfo(); BWM b5=new BWM5Factory().productBWM(); b5.showInfo(); BWM b7=new BWM7Factory().productBWM(); b7.showInfo(); } } - 总结:通过工厂把new对象给隔离，通过产品的接口可以接受不同实际的实现类，实例的类名的改变不影响其他合作开发人员的编程。
内部类
- 在一个类中再写一个类，好处：内部类可以使用类的私有变量。内部类主要解决Java不能多重继承的问题。
前期总结
异常处理
- Java中的异常用于处理非预期的情况，如文件没找到，网络错误，非法的参数。Java程序运行过程中所发生的异常事件可分为两类：Error：JVM系统内部错误、资源耗尽等严重情况；Exception：其它因编程错误或偶然的外在因素导致的一致性问题。
异常处理机制
防止因代码异常，中断程序运行。
第一种方法:try catch （Exception e ）是所有错误的父类
格式：try{有可能出现错误的代码块}catch(Exception e){如果不知道捕获的是什么类型的异常时，可以直接使用异类的父类Exception。如果代码块出现错误，则输出该语句}finally{可写可不写，它是捕获异常的体系中最终一段会执行的部分，我了学习IO操作和JDBC都会接触}
getMessage()方法，用来得到有关异常事件的信息
printStackTrace()用来跟踪异常事件发生时执行堆栈的内容。
抛出异常
throw Exception 抛出异常，在调用方法中捕获异常。
子类重写父类的方法时，子类不能抛出比父类方法更大范围的异常。
Java提供的异常的类一般是够用的，只有特殊的情况可能需要自己编写异常类，这种情况很少见。
Java集合概述
HashSet
TreeSet
List与ArrayList
Map
操作集合的工具类：Collections
查找、替换
图形用户界面GUI
- 构建GUI的类包括：容器类（Component class）、辅助类（helper class）、组件类（component class）
- 容器包括：顶层容器（Swing的JFrame、JApplet、JDialog等）和非顶层容器（JPanel、JScrollPane、JToolBar）要放在窗口内才能显示。
- 辅助类包括：绘图类（Graphics）、颜色类（Color）、字体类（Font）、字体属性类（FontMetrics）、布局管理类（LayoutManager）
这是一个jframe的窗体运用
import java.awt.Dimension;
import java.awt.Toolkit;
import javax.swing.*;
public class gui1 {
/*java使用的图形界面主要使用两个包java.awt/javax.swing
* java.awt和javax.swing的区别
* java.awt中使用的图形类都是依赖于系统的图形库的。
* javax.swing使用到的图形类都是sun公司实现的，不需要依赖系统的图形库
*AWT组件通常称为重型组件，Swing组件是用纯Java编写，通常称为轻型组件
* 之所以要保留java.awt包，是因为里面还有很多的事件类。
* 在Java中所有的图形类都称作组件类
* 组件的类型:容器组件和非容器组件，首先应该学习容器组件
*/
public static void main(String[] args){
JFrame frame=new JFrame("图形化界面的栏题");//JFrame创建的图形化界面是不可见的，需要设置其为可见性
/*设置窗体的大小
frame.setSize(300,400);*/
/*frame.setBounds((1920-300)/2,(1080-400)/2,300,400);
//不同的显示器，分辨率不同，需要一个工具类Toolkit获取其分辨率 */
guiTool a=new guiTool();
a.intoJFrame(frame,300,400);
}
}- 这是一个jframe窗体工具，处理窗体可见、显示位置、大小、关闭窗口程序。改进有：获取系统的分辨率，使运用时都显示在屏幕中间。
public static void intoJFrame(JFrame jframe,int width,int height){ jframe.setVisible(true);//setVisible设置窗体的可见性 Toolkit toolkit=Toolkit.getDefaultToolkit();//获取一个与系统相关的工具类对象 //获取屏幕的分辨率 Dimension d=toolkit.getScreenSize(); int x=(int)d.getWidth(); int y=(int)d.getHeight(); jframe.setBounds((x-width)/2,(y-height)/2,width,height); System.out.println("屏幕的宽度"+x+"屏幕的高度"+y); jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭图形化界面并退出程序 }
四种关闭窗口的方法
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭窗口并结束程序
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);//点击无任何反应
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);//释放资源，然后关闭程序
setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);//影藏窗口，不关闭程序这是一个对话框Dialog
JDialog(Dialog owner,String title,Boolean modal)
owner:所有者，用于指明母窗口
title:标题，对话框的框题
model：模式，如果为true则不可操作母窗口，为false则可以操作母窗口。
JDialog dialog=new JDialog(frame,"对话框",true);
dialog.setBounds(500,400,100,200);//setBounds(a,b,c,d)中a,b表示对话框左上角出现的点，c,d表示对话框大小。
dialog.setVisible(true);这是另一个对话框JOptionPane
JOptionPane(对话框)
JOptionPane.showMessageDialog(parentComponent, message, title, messageType);
parentComponent表示所有者，即母框，message显示内容，title对话框框题，messageType对话框的性质
消息对话框：
JOptionPane.showMessageDialog(frame, "明天不用上课", "通知", JOptionPane.INFORMATION_MESSAGE); //JOptionPane.INFORMATION_MESSAGE表明为消息对话框
警告对话框
JOptionPane.showMessageDialog(frame, "警告不能干坏事", "警告", JOptionPane.WARNING_MESSAGE);
错误对话框
JOptionPane.showMessageDialog(frame, "扣分", "错误", JOptionPane.ERROR_MESSAGE);
输入对话框
String str=JOptionPane.showInputDialog(frame, "请输入金额($)");
System.out.println("需要的金额："+str);
确认对话框利用JLabel标签添加图片：
JLabel l=new JLabel("这里可以添加文字，与图片一起显示出来");
c.add(l);
Icon icon=new
//图片路径需要在项目文件下
ImageIcon("src/practiceLayout/123.jpg") ;
l.setIcon(icon);复选框JCheckBox和单选框JRadioButton
static JCheckBox jchk1=new JCheckBox("粗体",true);//创建复选框jchk1,初始状态为选中
static JCheckBox jchk2=new JCheckBox("斜体");
static JCheckBox jchk3=new JCheckBox("下划线");
static JRadioButton jrb1=new JRadioButton("红色");
static JRadioButton jrb2=new JRadioButton("绿色",true);//创建单选按钮jrb2初始状态选中
static JRadioButton jrb3=new JRadioButton("蓝色");
ButtonGroup grp=new ButtonGroup();//创建一个单选按钮组对象
grp.add(jrb1);
grp.add(jrb2);
grp.add(jrb3);
frm.add(jrb1);
frm.add(jrb2);
frm.add(jrb3);五种界面布局方式：
- 绝对布局：设定按钮位置，是固定的。
Container c=jframe.getContentPane();//创建容器 c.setLayout(null); Button b=new Button("click me"); b.setBounds(40,40,50,50) ; //流布局（FlowLayout）：像水一样，默认中间排列 c.setLayout(new FlowLayout()); //边界布局（BorderLayout）：东南西北排列 c.setLayout(new BorderLayout()); JButton b=new JButton("中"); JButton b1=new JButton("西"); JButton b2=new JButton("南"); JButton b3=new JButton("北"); JButton b4=new JButton("东"); c.add(b,BorderLayout.CENTER); c.add(b1,BorderLayout.WEST); c.add(b2,BorderLayout.SOUTH); c.add(b3,BorderLayout.NORTH); c.add(b4,BorderLayout.EAST); //网格布局（new GridLayout（int a,int b））:将界面划分成a行b列 //设置布局为网格式，三行两列，水平间和垂直间距都设为5像素 c.setLayout(new GridLayout(3,2,5,5)); //网格组布局（GridBagConstraints）
列表框
String items[]={"元素1","元素2","元素3","元素8"};//第一种添加数据的方法，缺点不能随时添加数据
DefaultListModel<String> model =new DefaultListModel<String>();//第二种方法，列表框的数据模型
for(String tep:items){
model.addElement(tep);
}
JList<String> jList =new JList<String>();//创建列表框
model.addElement("添加数据");//添加新数据
jList.setModel(model);//列表框载入数据模型
/**
* SINGLE_SELECTION 单选模式
* SINGLE_INTERVAL_SELECTION 只能连续选择相邻的元素
* MULTIPLE_INTERVAL_SELECTION 随便选
*/
jList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);//设置选择模式
JScrollPane jScrollPane =new JScrollPane(jList);//给列表框添加滑动框
jScrollPane.setBounds(30,30,100,100);
container.add(jScrollPane);
JButton button=new JButton("确定");
button.setBounds(150,150,60,60);
container.add(button);
//给按钮添加监听
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
java.util.List<String> values=jList.getSelectedValuesList();//java.util.List将列表框中的数据取出来
//遍历输出
for (String tmp:values) {
System.out.println(tmp);
}
System.out.println("-------end------");
}
});文本框
JTextField jTextField=new JTextField();//创建文本框
jTextField.setColumns(20);//设置文本框长度，20个字符
jTextField.setText("123");//设置文本框内默认文字
jTextField.setFont(new Font("黑体",Font.BOLD,20));//设置文本框中字体样式
container.add(jTextField);
JButton jButton=new JButton("确定");
jButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.out.println("文本框中的内容："+jTextField.getText());//获取文本框中的内容
jTextField.setText("");//清空文本框
jTextField.requestFocus();//获取焦点，获取光标
}
});
container.add(jButton);密码框
JPasswordField jPasswordField=new JPasswordField();//创建密码框
jPasswordField.setColumns(20);//设置密码框长度，20个字符
jPasswordField.setFont(new Font("Arial",Font.BOLD,18));//设置密码框显示字体样式
jPasswordField.setEchoChar('*');//设置密码框显示字符，实心星'\u2605'
//添加事件监听，回车
jPasswordField.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
char ch[]=jPasswordField.getPassword();//获取密码框内容
String string=new String(ch);
System.out.println(string);
}
});
container.add(jPasswordField);文本域
JTextArea jTextArea=new JTextArea();//创建文本域
jTextArea.setText("编程一时爽，一直编程一直爽");//文本域内容
jTextArea.setRows(5);//设定行
jTextArea.setColumns(20);//设定列
jTextArea.append("添加内容");
jTextArea.insert("插入",5);//在第五个字符后面插入文本
jTextArea.setFont(new Font("黑体",Font.BOLD,20));//设置文本样式
JScrollPane jp=new JScrollPane(jTextArea);//添加滚动条
container.add(jp);焦点事件监听器
可以改变文本框颜色，点击时显示绿色，不点击时显示红色。
public class Text extends JFrame { public Text(){ setTitle("焦点事件监听"); setBounds(400,400,400,400); setVisible(true); setDefaultCloseOperation(DISPOSE_ON_CLOSE); Container container=getContentPane(); container.setLayout(new FlowLayout()); JTextField jTextField1=new JTextField(); jTextField1.setColumns(20);//设置文本框长度，20个字符 jTextField1.setText("");//设置文本框内默认文字 jTextField1.setFont(new Font("黑体",Font.BOLD,20));//设置文本框中字体样式 JTextField jTextField2=new JTextField(); jTextField2.setColumns(20);//设置文本框长度，20个字符 jTextField2.setText("");//设置文本框内默认文字 jTextField2.setFont(new Font("黑体",Font.BOLD,20));//设置文本框中字体样式 JTextField jTextField3=new JTextField(); jTextField3.setColumns(20);//设置文本框长度，20个字符 jTextField3.setText("");//设置文本框内默认文字 jTextField3.setFont(new Font("黑体",Font.BOLD,20));//设置文本框中字体样式 container.add(jTextField1); container.add(jTextField2); container.add(jTextField3); jTextField1.addFocusListener(new MyFocusListenter()); jTextField2.addFocusListener(new MyFocusListenter()); jTextField3.addFocusListener(new MyFocusListenter()); container.setVisible(true); } class MyFocusListenter implements FocusListener{ @Override public void focusGained(FocusEvent e) { JTextField tmp=(JTextField)e.getSource();//获取触发事件的组件 tmp.setBorder(BorderFactory.createLineBorder(Color.green)); } @Override public void focusLost(FocusEvent e) { // TODO Auto-generated method stub JTextField tmp=(JTextField)e.getSource();//获取触发事件的组件 tmp.setBorder(BorderFactory.createLineBorder(Color.red)); } } public static void main(String[] args){ new Text(); } }
