画板做完前的总结

[size=large] [b][[size=x-large]size=large]1类与对象关系分析[/size][/b[/size]]

（1）类是由属性和方法组成的，根据一个类可以创建对象，并且可以创建多个 象， 有该类创建的任何对象都可以调用该类中的方法。
（2）属性的值可以在该类中编写方法改变，对象通过调用相应的方法来改变属性的值。
public class Student{
//[align=center]属性
//名字的属性
String name;
int scro; //学分的属性
//方法
//设置名字的方法
public void setName(String n)
{ name=n；}
//学习的方法 改变属性的值
public void study(){ scro++;[align=right][/align]
}
}
通过另一个类创建对象 然后调用方法
public void Manger {
在主函数中 根据上一类创建它的对象
Public static void main(String args[]){
Student st1=new Student();
Student st2 =new Student(); //可以创建多个对象
}
//调用方法
st1.setName("盖茨")；
St1.study();[/align]}
[size=x-large]（3）方法的分类[/size]
分为：有返回值的方法，无返回值的方法；
有返回值的方法的定义格式： public （不是void）方法名
无返回值的方法的定义格式 ： public void 方法名
（一个类中 创建了对象就可以调用它所具有的方法）
方法还可分为 有参方法 和无参方法
方法也可分为 私有方法和公有方法（一般用公有方法）
私有方法 在类的内部调用 公有方法不可以
[size=x-large]2 构造方法的区别[/size]：
（1）构造器方法
对于语句：Student st=new Student (); 其中Student() 就是一个无参构造器（是系统默认的） 每个类都有自己默认的无参构造器，我们也可以为类重新定义构造器方法----构造器方法的重载（为什么，什么时候需要）
[align=center]public void Student{
//无参构造器 这是默认的 构造器方法的书写格式 public (不写void) 类名
public Student (){}
//一个参数的构造器的重载
public Student (String name){}
//两个参数的构造器
Public Student(String name ,String km){}|
}
//使用三种构造器
Public static void main(String args[]){
//用无参构造器 创建一个学生对象
Student st1 =new Student();
// 用一个参数的构造器 创建一个学生对象
String name="Hello";
Student st2=new Student(name);
//用两个参数构造器创建一个学生对象
String name="word";
String km="java";
Student st3 =new Student(name,km);
}[/align]
构造器方法的特点：没有任何返回值的定义，且必须与类名字相同。只能在创建对象时调用，对于一个对象而言它的构造器只能调用一次。（在上述的创建的过程中我们创建了3个对象）

（2）一般方法
方法的重载是 在类中定义多个同名，但是参数类型和数量不同的方法 如：
[align=center]public void study(int hour,String k){
km=k;
scro=scro+hour/3;
if(scro>3){.......}
}
一个参数 的重载
public void study (int hour){}
无参数重载
pubic void study(){}；
[/align]
（4）共同点
定义可以传入不同参数列表的构造器（在创建对象时 可以初始化对象的某些属性值）
注意: 每个类都有默认的无参构造器，但如果重新写了一个有参数的构造器，则默认的构造器就不能调用，{除非在类定义中显示声明？}
[size=x-large]3为什么需要继承？[/size]
当一个类与另一个类有许多相似点时，我们就可以用继承。比如大学生类和学生类 就会有许多相同的东西比如都会有学习的方法，但大学生和小学生的学习的方法是不同的，这是我们就可以在编写好学生类的情况下，用大（小）学生类继承它 ，就可完成大（小)学生类的编写。其中 学生类时父类 大（小）学生类时子类。在java中子类一次只能继承一个父类。是单根继承。如：
[align=center]public class Student{
private name;
public void study(){};
}
Public UNstudent extends Student{ }
这样由大学生类创建的对象就可以调用学生类中的方法
代 码 为：
// 程序入口
Public static void main(String args[]){
//创建大学生类对象
UNstudent un=new UNstudent();
//调用父类中的方法
un.setName("学习java");
un.study();[/align]}
（2）如何继承，继承到了什么？
用extends 关键字继承 ；子类拥有父类中部分或全部的方法 Public UNstudent extends Student{ }


[size=x-large]4 方法的重写与重载[/size]
方法的重载是在同一个类中，类名相同 但参数列表不同 内容相同
方法的重写是在子类中对父类中的方法进行重写，类名相同，参数列表相同 内容不同。

下面就是要对父类中的方法进行重写,否则大学生的学习方法就与任何学生的学习方法相同了。代码：
Public class UNstudent extends Student{
//重写从父类中继承到的方法
Public void study(){System.out.println("UNstudent学习要自觉")；}
}
[size=x-large]5自动转型，指的是子类对象会自动转变为父类类型。代码[/size]Public void main(String args[]){
//父类类型变量名用来引用子类对象
Student un=new UNstudent();
// 调用方法： 这些方法是从父类中继承来的
un.setName("我是大学生");
un.study();
}
un调用的方法是谁的方法？（如果子类中重写了该方法，就调用子类中的，如果没有重写就是调用父类中的方法。）
[size=xx-large]6 [/size]
（[size=x-large]1）什么情况下定义接口，它的特点，用什么样的关键字定义接口[/size]
当子类要求必须重写父类中的方法时 ，就需要定义接口。因此接口就不会由具体的方法实现了，也因此不能直接使用接口创建对象。接口中可以定义属性，但它的值是常量。接口中的方法是都是public
接口定义，用interface不用 extends代码：
//形状接口的定义
public interface NetJavaShape{
Public final static String comName="蓝杰"；
Void draw (int x1,int x2,int y1,int y2);
}
[size=x-large]（2）接口的实现[/size]接口的实现使用implements关键字，实现类中必须重写接口中定义的方法。一个类可以实现多个接口，当一个类实现多个接口时，自动转型为某个接口类型时，就只能调用在该接口中的方法。
定义两个接口：
Public interface Shape{
public final static String comName=”蓝杰” ；
void draw(int x1,int y1,int x2,int y2);
}
Public interface OtherShape{
String doOther();
}
定义一个画图的类
Public class Draw(){
System.out.println(”画好了”)；
}
//一个类实现两个接口
Public class Draw implements Shape ,OtherShape{
//实现接口中的方法
Public void Draw(int x1,int x2, int y1, int y2){
System.out.println(“实现了第一个接口中的方法”)；
}
Public void Other(){
System.out.println(“实现了第二个接口中的方法”)；
}

}

Public static void main(String args[]){
Shape sh=new Draw();//自动转型 就只能调用 Shape中的方法
sh.draw();
}
[size=x-large]7. 类与接口中的区别[/size]
在java中类可以通过extends继承类，类可以通过implents 关键字实现接口，接口与接口之间也可以通过extends 关键字实现继承，与类继承不同的是；一个接口可以继承多个接口。（一个类中只能继承一个类） 在 6中我们已经 实现两个接口

[size=x-large]8 swing组件举例[/size]
Javax.swing.border : 为swing 组件提供大量的有趣的边框。
Javax.swing.event : 定义swing组件使用的事件 和事件监听器
Javax.swing.text 提供一些支持文本组件的类和接口。
这些类和接口 控制 在文本组件 中输入和编辑 的实现、

Javax.swing.tree 提供一些必须的雷和接口，以支持JTree组件的使用
Javax.swing.undo 支持撤销和恢复操作
Javax.swing.plaf 对swing 的嵌入式界面的特正提供服务。
Javax.swing.JBtton 按钮
Javax.swing.JCheckBox 复选框
Javax.swing.JLabel创建无图像并且其标题为空字符串的 JLabel
Javax.swing.JMenuBar 菜单栏
Javax.swing.JTexField 文本行
Javax.swing.Jlist 下拉框
[size=x-large]9 swing事件机制[/size]在一个按钮对象上 点击鼠标时 ，系统会发出一个事件通知，这个通知会被一个事件对象（EventObject）通知给一个事件处理器（事件监听器），事件监听器根据这个事件对象的数据，读取JTextfiled 中的内容，并显示在另一个JLabel上。
10 java中常用的监听器
（1）ActionListener 动作监听器 是一个接口 只有一个方法actionPerformed（ActionEvent e） 当实现了这个方法后，主要就是应用 ActionEvent 了，最常用的方法是 getActionCommand（）；
（2）java.awt.event.MouseMotionListener; 用于接收组件上的鼠标移动事件的侦听器接口。
（3） java.awt.event.MousWheelListener; 鼠标滑轮 监听器

（4） java.awt.event.MouseListener; 用于接收组件上“感兴趣”的鼠标事件（按下、释放、单击、进入或离开）的侦听器接口。

（5）java.awt.event.KeyListener 用于接收键盘事件（击键）的侦听器接口
[size=x-large]11多态 [/size]相同的类型的对象调用相同类型的方法时 由于重载，重写的原因，会产生不同的结果。
//一个父类 学生类 Studnt
public class Studnt {
//属性
private String Name=””;
public void getName(String s){
name=s;
}

}
//大学生继承学生类
public class UnStudnt extends Student {
//重写父类中的方法
public void Study(){
System.out.println(“大学生”+getName(“我是大学生”));
}
}

//计算机专业的学生继承学生类
public class ComStudent extends Student {

//重写父类中学习的方法
public void Study(){
System.out.println(“计算机专业学生”+getName(“我是学软件的”));
}
//
}
//一个 Teacher 类
public class Teacher {
//老师教学生
public void teacher(Student st1,Student st2){
st1.Study();
st2.Study();
}
//程序入口
public static void main(String args[]){

//父类类型变量名用来引用子类对象
Student un=new UnStudent();
un.setName(“大学生”)；

Studnt com=new ComStudent();
com.setName(“软件人才”)；

//创建一个老师的对象
Teacher tea =new Teacher();
tea.teacher(un,com);
//un 与com 是同 类型即 Student 调用相同的方法Study(), 由于 在ComStudent 和 UnStudent中重写了Study(),因此产生的 结果 不同。这便是 多态。
}
}
[size=x-large]其他的网上的理解（目前没理解）[/size]（1） 接口的多种不同实现方式 即为多态。
（2） 发送消息给某个对象，让该对象自行决定相应何种行为。通过将子类对象引用赋值给超类对象引用变量来实现动态调用。[/size]