一.Java基础:Java开发环境配置，Jdk的安装以及环境变量的设置，还有java的基本数据类型。数据类型有值类型和应用类型，值类型有：int、byte、float、double、long、boolen。
二.类与对象。掌握什么是类以及类的实例化。最初写的是很简单的类，从练习中慢慢熟悉了定义类的格式。如：写一个学生类
public class Student{
//定义私有的姓名属性
private String name;
//定义私有的年龄属性
private int age;
//写一个公共的给姓名属性赋值的方法
public void setName(name){
this.name = name;
}
//写一个公共的给年龄属性赋值的方法
public void setAge(int age){
this.age = age;
}
//一个获取姓名的方法
public String getName(){
return name;
}
//一个获取年龄值的方法
public int getAge(){
return age;
}
}
重新再写一个Manager类，其中含有主函数main,这是程序运行的入口。
public class Manager{
//主函数
public static void main(String[] args){
//用Student类实例化对象st
Student st = new Student();//Student()也就是构造器的调用
//对象st调用setName()方法给对象的名字属性赋值
st.setName("张三");
//对象st调用setAge()方法给对象的年龄属性赋值
st.setAge(20);
//对象st调用getName()方法返回名字属性的值
st.getName();
//象st调用getAge()方法返回年龄属性的值
st.getAge();
}
}
三.登陆界面开发。了解构造器、方法的重载、this关键字以及值传递与应用传递。一个简单的界面程序:
(1)构造器的格式：构造方法的名字与类名完全相同并且没有返回值。
如果重写了一个有参数的构造器，那么默认的无参构造器就不能被调用，除非在类定义中显示申明。
public class Student{
//定义私有的姓名属性
private String name;
//定义私有的年龄属性
//定义一个无参数构造函数
public Student(){}
//定义一个带一个参数的构造器
public Student(String name){
this.name = name;
}
//写一个公共的给姓名属性赋值的方法
public void setName(name){
this.name = name;
}
//一个获取姓名的方法
public String getName(){
return name;
}
}
(2)方法的重载格式：两个方法的名字相同，但是它们的参数个数或者参数类型不同。
例如：
public void play(){
System.out.println(name+"正在玩!");
}
public void play(int i){
System.out.println(name+"是第"+i+"次玩了!");
}
以上就是方法的重载，它们的参数个数不同。调用play方法时根据传的参数值的类型选择符合的方法实现。
(3)this关键字有两个重要作用：
1.代表本对象，如this.name表示本对象的name属性
2.this可以调用类中其他的构造器，如：
public class Student{
//定义一个无参构造函数
public Student(){
this("张三")；//调用参数匹配的构造器实例化对象,此代码必须在第一行
}
public Student(String name){
this.name = name;
}
private String name;
}
(4)值传递传递的是参数的具体值，引用传递传递的是引用地址。
八种基本类型以及String型的都是值传递，类实例化的对象传递是引用传递。
(5)尝试做窗口界面程序。
知道了JFrame是属于容器类组件，它可以使用add(Component comp)添加一些元素组件，如JButton、JLabel等。一下是一段简单的窗体程序：
public class JFrameTest{
public static void main(String[] args){
//实例化对象
JFrameTest jt = new JFrameTest();
//调用showUI方法
jt.showUI();
}
public void showUI(){
//创建一个窗体
javax.swing.JFrame jf = new javax.swing.JFrame();
//设置窗体的标题
jf.setTitle("登陆界面");
//设置窗体的大小
jf.setSize(250,200);
//设置窗体不可改变大小
jf.setResizable(false);
//创建流式布局对象
java.awt.FlowLayout fl = new java.awt.FlowLayout();
//设置窗体的布局为流式布局
jf.setLayout(fl);
//创建一个文本框
javax.swing.JTextField txt = new javax.swing.JTextField(20);
//把文本框对象添加到窗体中
jf.add(btn);
//创建一个按钮
javax.swing.JButton btn = new javax.swing.JButton("登陆");
//把按钮对象添加到窗体中
jf.add(btn);
//设置关闭窗体的时候退出程序
jf.setDefaultCloseOperation(3);
//设置窗体可见
jf.setVisible(true);
}
}
四.类的继承。
内容有:
1.类继承的实现和作用
前面已经学了类的语法格式，现在学了类的继承。类的继承是用extends关键字。
示例：
public class UNStudent extends Student{
//方法和属性
}
类的继承作用：子类继承父类后，子类会继承父类的属性和方法，根据需要子类可以重写父类的 方法。
注意点：除了private修饰的属性和方法不能被继承，public,protected以及不加修饰符的方法以及属性都能被子类继承。
//父类Student
public class Student {
private String name;//子类不能继承使用该属性
protected int age;
public void setName(String name) {
this.name = name;
}
void setAge(int age) {
this.age = age;
}
//子类不能调用该方法，如过要调用，那么在子类中必须重写这个方法
private String getName(){
return this.name;
}
int getAge(){
return age;
}
}
2.接口
接口定义的关键字是interface；
public interface 接口名{
//接口中定义的方法
//方法没有方法体，也就是方法不能有具体的实现
//方法示例
public void study();
//每一个方法都没有{}，{}指的是有具体的方法实现。
}
不论方法的修饰符有没有public,接口都默认它是public。
类实现这个接口后，子类必须重写接口中的方法。这也是接口的特性，它的作用也在此得到体现 ，这一特性可以防止我们漏写接口中的方法。
接口中只有常量，一般定义格式是：
public static final String name;
static 表示这是静态的，该属性可以直接用类名调用而不需要类的实例化对象；
final 表示的是name是不能再被赋值，不能改变的。
接口不能用来创建对象。
3.抽象类
抽象类是介于类和接口之间的。因为接口被子类实现后，子类必须重写接口中所有的方法，而有些时候我们并不需要使用到接口中所有的方法，所以就加入了抽象类，它可以让我们对接口中的方法选择性的重写和使用。
抽象类定义格式：
pubic abstract class 类名{
//定义属性和方法
}
//不能使用abstract去定义属性，
如：abstract protected String time;这是错误的。
子类继承抽象类用extends关键字，子类继承抽象类后，如果抽象类中的方法用abstract修饰的， 那么子类必须重写这些方法。
抽象类也不能创建对象，因为抽象类中可能有abstract修饰的方法，这种方法是没有具体实现的 。可以这么理解，因为接口和抽象类中含有没有具体实现的方法，所以是不能创建对象的。
abstract和private关键字不能同时使用，如：
abstract private void play();这是不对的。abstract可以和public、protected连用,abstract后也可不接修饰符，它会默认是public。
抽象类常用作“适配器”，因为无论一个接口中定义了多少方法，子类都必须实现。
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
public class Mouse implements MouseListener {
@Override
public void mouseClicked(MouseEvent e) {
// TODO Auto-generated method stub
}
@Override
public void mouseEntered(MouseEvent e) {
// TODO Auto-generated method stub
}
@Override
public void mouseExited(MouseEvent e) {
// TODO Auto-generated method stub
}
@Override
public void mousePressed(MouseEvent e) {
// TODO Auto-generated method stub
}
@Override
public void mouseReleased(MouseEvent e) {
// TODO Auto-generated method stub
}
}
以上是用在类Mouse实现(继承)接口MouseListener(java.awt.event.MouseListener),在子类Mouse中必须重写以上所有方法。为此，Java的设计者提供了一个抽象类：java.awt.event.Adapter,这个类实现了所有鼠标监听器接口(MouseListener,MouseWheelListener,MouseMotionListener),只是这个类定义为抽象类(abstract)。如下是Java的设计者已经写好的：
public abstract class MouseAdapter implements MouseListener, MouseWheelListener, MouseMotionListener {
/**
* {@inheritDoc}
*/
public void mouseClicked(MouseEvent e) {}
/**
* {@inheritDoc}
*/
public void mousePressed(MouseEvent e) {}
/**
* {@inheritDoc}
*/
public void mouseReleased(MouseEvent e) {}
/**
* {@inheritDoc}
*/
public void mouseEntered(MouseEvent e) {}
/**
* {@inheritDoc}
*/
public void mouseExited(MouseEvent e) {}
/**
* {@inheritDoc}
* @since 1.6
*/
public void mouseWheelMoved(MouseWheelEvent e){}
/**
* {@inheritDoc}
* @since 1.6
*/
public void mouseDragged(MouseEvent e){}
/**
* {@inheritDoc}
* @since 1.6
*/
public void mouseMoved(MouseEvent e){}
}
这样我们就可以根据自己的需要，选择性地重写java.awt.event.MouseAdapter这个抽象类中的方法。
swing组件用容器类组件和元素组件。
Container(容器)组件：用于管理其他界面组件的组件，例如：JFrame(窗体组件)，JPanel等。
元素组件：用于构成各种用户界面的组件，例如：JLabel(标签)，JTextField(文本框)，JButton(按 钮)等。
任何元素组件都有一个.addActionListener(java.awt.ActionListener listener)方法，这个方法实现了接收一个实现了java.awt.ActionListener接口的对象，将这个对象加为某个对象(事件源)的事件处理器，当一般的动作事件(如按键、鼠标单击)发生时，组件(事件源)就会自动调用所加入的实现了ava.awt.ActionListener接口的对象的事件处理方法。
下面是简单示例：
1.先编写一个实现了ava.awt.ActionListener接口的类MyButtonListener
/**
* 一个简单的动作时间监听器：当时间发生时， 在命令行输出按钮上的标签文字
*/
import java.awt.event.ActionEvent;
public class MyButtonListener implements java.awt.event.ActionListener {
@Override
// 必须重写的接口中的方法：当时间发生时，这个方法被调用
public void actionPerformed(ActionEvent e) {
// 得到事件源对象
Object sour = e.getSource();
// 如果事件是一个按钮：
if (sour instanceof javax.swing.JButton) {
javax.swing.JButton bu = (javax.swing.JButton) sour;
// String lab = bu.getActionCommand();
String lab = bu.getText();
// 在这里bu.getText()与bu.getActionCommand()的效果一样
// 都是将事件源上的标签赋值给String类型的lab
System.out.println("您按下了\"" + lab+"\"按钮");
} else {
System.out.println("其他组件发出的事件！");
}
}
}
2.在编写程序入口的类
import javax.swing.JButton;
import javax.swing.JFrame;
public class Manager extends JFrame{
/**
* 主函数，程序入口
*/
public static void main(String[] args) {
//实例化对象
Manager mana = new Manager();
//调用显示窗体的方法
mana.showUI();
}
学了事件处理后，我学习了做一个简单的画板程序，该画板简单到只能选择颜色，画直线、矩形、圆形和填充圆。这个程序中我用到了接口，抽象类，使用内部类简化事件处理方式。
1.类实现接口必须重写接口中所有的方法
2.在内部类中可以new 接口名
如：
btnColor.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
color = javax.swing.JColorChooser.showDialog(null, "颜色选择器",
color);
}
});
3.对于鼠标的事件监听，使用java.awt.event.MouseAdapter抽象类比鼠标事件监听器接口要好，继承这个抽象类的子类只需要重写我们所需要的方法，避免代码的冗余。
4. java.awt.Graphics不能实例化对象，javax.swing.JFrame类提供了一个getGraphics()方法可以得到java.awt.Graphics对象，Graphics可以理解为"画布"对象，通过调用Graphics对象不同的draw方法并传入鼠标的坐标参数，就可以在JFrame界面上画出相应的图形。
注意：用JFrame对象取得画布对象一定要在界面setVisible(设置可见性)后取得。
以下是只可以画直线的简单程序：
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseWheelListener;
public class SampleDraw {
private int x1,y1,x2,y2;//记录鼠标两次点击的坐标
private java.awt.Graphics g;//从界面对象上得到的画布对象
public static void main(String[] args){
SampleDraw sd = new SampleDraw();
sd.showUI();
}
//显示主界面
public void showUI(){
javax.swing.JFrame jf = new javax.swing.JFrame();
jf.setTitle("画板");
jf.setSize(500,300);
jf.setResizable(false);
//加上自定义的鼠标事件监听器：鼠标释放是调用方法
jf.addMouseListener(new java.awt.event.MouseAdapter(){
//只需要重写需要的方法即可，因为父类不是接口
//鼠标按下时点的坐标
public void mousePressed(MouseEvent e){
//记录第一次点击的x,y，通过事件对象e得到
x1 = e.getX();
y1 = e.getY();
}
public void mouseReleased(MouseEvent e){
//记录第二次点击的x,y
x2 = e.getX();
y2 = e.getY();
//现在，两次点的坐标都得到了，在画布上画线，调用画布对象的方法
g.drawLine(x1,y1,x2,y2);
}
});
jf.setDefaultCloseOperation(3);//关闭时退出程序
jf.setVisible(true);
//用JFrame对象取得画布对象时，一定要在界面setVisible(设置可见性)后取得。
g = jf.getGraphics();
}
}
//显示窗体的方法
void showUI(){
//设置窗体的标题
this.setTitle("第一个界面程序");
//设置窗体的大小
this.setSize(340,280);
//设置窗体的流式布局
this.setLayout(new java.awt.FlowLayout());
//创建文本框
javax.swing.JTextField txt = new javax.swing.JTextField(20);
//创建按钮
JButton btn = new JButton("登陆");
this.add(txt);//把文本框添加到窗体中
this.add(btn);//把按钮添加到窗体中
//创建一个实现了addActionListener接口的对象
MyButtonListener mb = new MyButtonListener();
//给按钮添加动作事件监听器，并绑定事件处理器
btn.addActionListener(mb);
//设置窗体居中
this.setLocationRelativeTo(null);
//设置窗体关闭时退出程序
this.setDefaultCloseOperation(3);
//设置窗体可见性
this.setVisible(true);
}
}
小结：
每一个事件监听器都是一个接口，当子类实现某一个监听器接口时，子类必须重写接口中所有的方法。而有些方法是我们不需要的，所以我们可以用抽象类来作为接口和类的“适配器”，我们就可以根据自己的需要重写抽象类中的方法。
