前几章基础学习小结

[color=red][/color][align=center][size=medium][color=darkblue]前几章基础学习小结[/color][/size][/align]


[color=red]1.Java程序的编写，翻译和运行过程[/color]
编写生成java文件，翻译时生成class文件，即生成机器语言二进制代码，运行就是将结果输出在显示器中


[color=red]2.JDK,JRE,JVM关系，区别[/color]

JDK是Java Development Kit的缩写

JRE是Java Run Environment的缩写

JVM是Java Virtrue Mechian的缩写

三者关系与区别：
我们利用JDK（调用JAVA API）开发了属于我们自己的JAVA程序后，通过JDK中的编译程序（javac）将我们的文本java文件编译成JAVA字节码，在JRE上运行这些JAVA字节码，JVM解析这些字节码，映射到CPU指令集或OS的系统调用。


[color=red]3.数据类型：[/color]
基本类型（8种）
byte 8bit -128~127
char 16bit
short 16bit
int 32bit
long 64bit
float 32bit
double 64bit
boolean 8bit true/false

引用类型(类类型)：每一个类（接口，抽象类）都是一种数据类型，如：private[]Student=new Student[0];

数组类型：基本类型或者引用类型的集合
int[][] t; String[] str;
int t[][];
int[] t[];


[color=red]4.面向过程，面向对象理解[/color]

面向过程指的是关注的是完成事件的步骤，C语言面向对象,相当于谓语，结果唯一确定。

面向对象指的是关注的是完成事件的对象，不关注过程，Java面向对象，相当于主语和宾语，结果随着对象不同而不唯一。


[color=red]5.类与对象的关系分析[/color]
类：抽象的，主观的
对象：具体的，客观的

public class A{

A a1=new A();
A a2=new A();
}
A就是一个抽象的我们的脑海里抽象出来的一群具有共同特征的个体的概念，而a1,a2是具体的对象


[color=red]6.如何定义一个类，如何创建对象，如何调用属性和方法[/color]public class A{
public A(){
}//每一个类都有一个默认的构造方法
private int m;
public void n(){

}
}

A a = new A();//创建对象

a.m=10;//调用属性
a.n();//调用方法


[color=red]7.构造方法与一般方法的区别[/color]

每一个类都有一个默认的构造方法，构造方法是在new对象的时候被调用的，是被系统自动调用的，而且一定会被调用，构造方法一般用来给对象的属性做初始化的，构造方法没有返回值。
普通方法必须有返回值，就算不返回也得写个void。

如：构造方法：public A(){
} 调用：A a=new A();

一般方法：public void B(){
} 调用：a.B();


[color=red]8.方法的重载与重写[/color]

重写是子类的方法覆盖父类的方法，要求方法名和参数都相同，是在不同的类中重写,只是子类中的方法体与父类不同

如：父类：public class A{
public void C(){}
}
子类：public class B extends A{
public void C(){}
}

重载是在同一个类中的两个或两个以上的方法，拥有相同的方法名，但是参数的个数或类型却不相同，方法体也不相同，最常见的重载的例子就是类的构造函数。如：
public class C{

public void D(int){}
public void D(String){}
public void D(int,String){}

}


[color=red]9.类的继承，接口的实现，抽象类的继承[/color] 类，接口，抽象类的特点，区别[/color]
a、一个类(抽象类)只能继承一个父类（单根继承）
public class A{}
public class B extends A{}

b、一个接口可以继承多个接口
public interface C{}
public interface D{}
public interface E extends C,D{}

c、一个类可以实现多个接口
public class F implements C,D{}

d.一个类可以在继承一个类之后在实现多个接口
public class G extends A implements C,D{}

G g1 = new G();
A g2 = new G();
C g3 = new G();
类：指具有相同属性和方法的个体的抽象，有方法和方法体

接口：接口本身没有任何实现，只有方法，没有方法体，不能有构造器，接口可以有public，static的和final属性,
接口的方法只能是抽象的和公开的。

抽象类：抽象类abstract class 。和接口类似，但有区别：
1、在abstract class方式中，Demo可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface方式的实现中，Demo只能够有静态的不能被
修改的数据成员（也就是必须是static final的，不过在interface中一般不定义数据成员），所有的成员方法都是abstract的。　
2、abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。
3、abstarct class在Java语言中体现了一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is a"关系，
即父类和派生类在概念本质上应该是相同的。 对于interface 来说则不然，并不要求interface的实现者和interface定义在概念本质上是一致的，
仅仅是实现了interface定义的契约（功能）而已。


[color=red]10.子类继承父类之后，在子类的构造方法中默认会调用父类无参数的构造方法[/color]
如果父类没有无参数的构造方法，则必须要重写子类的构造方法，如：
public class A{
public A{}//默认的无参构造方法

}
public class B extends A{
//如果父类中没有无参数的构造方法，则必须重写
public B{}
}


[color=red]11.swing界面的开发[/color] a.组件的基本用法
容器组件：重量级组件，如窗体
元素组件：轻量级组件，如按钮，输入框等
b.组件的继承体系


/**
* 画板窗体
*
* @author：zzj
*
*/
public class DrawUI extends JFrame{

//程序入口
public static void main(String[] args){

DrawUI du = new DrawUI();
du.showDrawUI();


}

/**
* 显示窗体的方法
*/
public void showDrawUI() {
this.setTitle("我的画板");
this.setSize(600, 500);
this.setDefaultCloseOperation(3);
java.awt.FlowLayout fl=new java.awt.FlowLayout();
this.setLayout(fl);
//添加更多窗体组件：如按钮，输入框,颜色等
this.setVision(true);
}
组件的继承体系，如：

javax.swing

类 JButton

java.lang.Object
java.awt.Component
java.awt.Container
javax.swing.JComponent
javax.swing.AbstractButton
javax.swing.JButton


[color=red]12.事件的监听机制：每个监听器对应着一个事件[/color]
ActionListener ActionEvent
MouseListener MouseEvent
MouseMotionListener MouseEvent
例如：

在主类中：
//创建监听器对象
DrawListener dlis= new DrawListener(g,group);
//给窗体/组件加上鼠标监听器/其他监听器
this.addMouseListener(dlis);


实现监听器的类：
import java.awt.event.MouseEvent;

/**
* 画板的监听器，实现鼠标监听器接口 监听器中的方法是通过事件触发自动调用的(监听器中的每一个方法都对应了一个事件)
*
* @author Administrator
*
*/
public class DrawListener implements java.awt.event.MouseListener {
private int x1, y1, x2, y2;
private java.awt.Graphics gr;
private javax.swing.ButtonGroup bgroup;
String type = "line";// 要绘制的形状
java.awt.Color color = java.awt.Color.green;

public DrawListener(java.awt.Graphics g, javax.swing.ButtonGroup bg) {
gr = g;
bgroup = bg;
}

public void mousePressed(MouseEvent e) {
// 绘制之前要知道被选中的形状按钮
// 得到按钮组中被选中的按钮的模型
javax.swing.ButtonModel bm = bgroup.getSelection();
// 得到被选中按钮模型的动作命令
type = bm.getActionCommand();

//设置要绘制的颜色
gr.setColor(color);


// 得带鼠标按下时候光标的位置
x1 = e.getX();
y1 = e.getY();
}

public void mouseReleased(MouseEvent e) {
// 得带鼠标释放时候光标的位置
x2 = e.getX();
y2 = e.getY();

if (type.equals("line")) {
// 画直线
gr.drawLine(x1, y1, x2, y2);
} else if (type.equals("oval")) {
gr.drawOval(x1, y1, x2-x1, y2-y1);
} else if (type.equals("rect")) {
gr.drawRect(x1, y1, x2-x1, y2-y1);
}else if(type.equals("RoundRect")){
gr.drawRoundRect(x1, y1,50,100,10,5);
}
}

public void mouseEntered(MouseEvent e) {
// System.out.println("mouseEntered");
}

public void mouseExited(MouseEvent e) {
// System.out.println("mouseExited");
}

public void mouseClicked(MouseEvent e) {
// System.out.println("mouseClicked");
}

}



[color=red]13.布局管理器[/color]
FlowLayout 流式布局
BorderLayout 边框布局
GridLayout 网格布局
CardLayout 卡片布局
流式布局写法：java.awt.FlowLayout fl=new java.awt.FlowLayout();
frame.setLayout(fl);