画板做完前的总结

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

     （1）类是由属性和方法组成的，根据一个类可以创建对象，并且可以创建多个  象，    有该类创建的任何对象都可以调用该类中的方法。
    （2）属性的值可以在该类中编写方法改变，对象通过调用相应的方法来改变属性的值。
                 public class Student{
          //

属性
          //名字的属性
              String  name;
         int scro;  //学分的属性
         //方法
//设置名字的方法  
public void setName(String  n)
  {  name=n；}
//学习的方法  改变属性的值
public  void study(){  scro++;[align=right]

}
} 
通过另一个类创建对象 然后调用方法
public  void Manger {
  在主函数中 根据上一类创建它的对象
Public static void main(String  args[]){
  Student st1=new Student();
  Student st2 =new Student();  //可以创建多个对象
}
//调用方法
   st1.setName("盖茨")；
   St1.study();[/align]}
（3）方法的分类
分为：有返回值的方法，无返回值的方法；
有返回值的方法的定义格式： public （不是void）方法名
    无返回值的方法的定义格式 ： public void 方法名
（一个类中 创建了对象就可以调用它所具有的方法）
方法还可分为 有参方法 和无参方法
方法也可分为 私有方法和公有方法（一般用公有方法）
私有方法 在类的内部调用 公有方法不可以
2 构造方法的区别：
（1）构造器方法
对于语句：Student st=new Student ();  其中Student()  就是一个无参构造器（是系统默认的）  每个类都有自己默认的无参构造器，我们也可以为类重新定义构造器方法----构造器方法的重载（为什么，什么时候需要）

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);
}

      构造器方法的特点：没有任何返回值的定义，且必须与类名字相同。只能在创建对象时调用，对于一个对象而言它的构造器只能调用一次。（在上述的创建的过程中我们创建了3个对象）

（2）一般方法
方法的重载是 在类中定义多个同名，但是参数类型和数量不同的方法  如：

public void study(int hour,String k){
km=k;
scro=scro+hour/3;
if(scro>3){.......}
}
一个参数 的重载
public void study (int  hour){}
无参数重载
pubic void study(){}；

    （4）共同点
         定义可以传入不同参数列表的构造器（在创建对象时 可以初始化对象的某些属性值）
     注意:  每个类都有默认的无参构造器，但如果重新写了一个有参数的构造器，则默认的构造器就不能调用，{除非在类定义中显示声明？}
3为什么需要继承？
当一个类与另一个类有许多相似点时，我们就可以用继承。比如大学生类和学生类 就会有许多相同的东西比如都会有学习的方法，但大学生和小学生的学习的方法是不同的，这是我们就可以在编写好学生类的情况下，用大（小）学生类继承它 ，就可完成大（小)学生类的编写。其中 学生类时父类 大（小）学生类时子类。在java中子类一次只能继承一个父类。是单根继承。如：

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();

}
（2）如何继承，继承到了什么？
用extends  关键字继承  ；子类拥有父类中部分或全部的方法  Public UNstudent extends Student{   }

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

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

8 swing组件举例
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   下拉框
9  swing事件机制在一个按钮对象上 点击鼠标时  ，系统会发出一个事件通知，这个通知会被一个事件对象（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 用于接收键盘事件（击键）的侦听器接口
11多态 相同的类型的对象调用相同类型的方法时 由于重载，重写的原因，会产生不同的结果。
//一个父类 学生类 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(),因此产生的 结果 不同。这便是 多态。
}
}
其他的网上的理解（目前没理解）（1） 接口的多种不同实现方式 即为多态。
（2） 发送消息给某个对象，让该对象自行决定相应何种行为。通过将子类对象引用赋值给超类对象引用变量来实现动态调用。[/size]