学习笔记NO.3
java的核心技术
第十章
- 可以在子类中用super（）；语句来调用父类方法。但是不能调用private方法，同时子类也可以定义一些新的方法。子类不止可以调用父类方法，还可以重写父类方法，就是覆盖，但是重写的时候，权限修饰符只能从小到大，不能重大到小，
- 继承父类方法的子类的主方法实例化子类的时候，得首先实例化上级父类，就是最顶级，从上到下。实例化的时候，父类 的无参构造方法被自动调用，但是有参的不能，只能用super关键字进行调用。
- Object类
Object是所有类的父类，他的getClass();notify();notifyAll();wait();等方法不能被重写，因为他们被定义为final类型
（1），getClass（）方法，他会返回对象执行时的Class实例，然后用此实例调用getName（）方法可以取得类的名称
getClass（）.getName（）；
（2），toString（）方法，将一个对象返回为字符串形式，但实际应用的时候都会重写
（3），equals（）方法，他默认比较引用对象的地址，而不是具体内容而“==”就可以比较具体内容，所以一般引用的时候都会重写。 - 对象类型的转换
向上转型的时候一般随意，就是子类向父类转型的时候，而向下转的时候就得注意了，将父类对象赋予子类的时候用强制转换
可以使用instanceof操作符判断对象的类型，
myobject instanceof ExampleClass;myobject是某类对象的引用，而ExampleClass是某个类，返回布尔值。用来判断操作对象是不是这个类。
如果是的话就可以强制转换了。 - 方法的重载，就是一个名字的方法可以定义很多次并且互不影响，可以类型不同，参数个数，顺序不同等等。
还有不定个数的长参数方法
public static int add（interesting……a）；就像数组一样 (int[]a); - 多态
不会………………………………………………，不知道会不会，看不懂》 - 抽象类和接口
越往上的类越抽象，语法如下
public anstract class Test{
abstract void testAbstract();
}
其中abstract是定义抽象类的关键字，他定义的方法是抽象方法。抽象方法没有方法体，本身没有任何意义，除非被重写，而承载这个方法的抽象类必须被继承，实际上抽象类除了被继承也没有意义。反过来要是声明一个抽象方法，那么这个类必须是抽象类，继承的时候抽象方法必须被重写，这样很费劲，所以便有了接口，用之即来挥之即去。
- 接口
定义语法：
public interface drawTest{
void draw();
}
interface是定义接口的关键字，一个类实现一个接口可以使用implements关键字，代码如下。
public class sun extands father implements drawTest{
…//
}
在接口中，方法必须定义为public或abstract形式，默认是public，接口定义的任何字段都是static或者final的。
接口和多态技术相结合的例子
interface drawTest { // 定义接口
public void draw(); // 定义方法
}
// 定义平行四边形类，该类继承了四边形类，并实现了drawTest接口
class ParallelogramgleUseInterface extends QuadrangleUseInterface
implements drawTest {
public void draw() { // 由于该类实现了接口，所以需要覆盖draw()方法
System.out.println("平行四边形.draw()");
}
void doAnyThing() { // 覆盖父类方法
// SomeSentence
}
}
class SquareUseInterface extends QuadrangleUseInterface
implements drawTest {
public void draw() {
System.out.println("正方形.draw()");
}
void doAnyThing() {
// SomeSentence
}
}
class AnyThingUseInterface extends QuadrangleUseInterface {
void doAnyThing() {
}
}
public class QuadrangleUseInterface { // 定义四边形类
public void doAnyTthing() {
// SomeSentence
}
public static void main(String[] args) {
drawTest[] d = { // 接口也可以进行向上转型操作
new SquareUseInterface(), new ParallelogramgleUseInterface() };
for (int i = 0; i < d.length; i++) {
d[i].draw(); // 调用draw()方法
}
}
}
接口也可以进行向上转型的操作。
- 继承不可以多重继承，但是接口可以，一个类可以同时实现多重接口，将需要 继承的接口放在implements后面，用逗号隔开，但这个会产生庞大的代码量，因为继承一个接口的时候需要实现接口中的所有方法。
class 类名 implements 接口1，接口2，…接口n；
定义一个接口的时候，可以用这个接口继承另一个接口。
interface intf1{
}
interface intf2 extends intf1{
}
第十一章，Java类包
- 类名冲突
要是需要创建同一个名字的几个类的话，为了避免可以放在不同的包里面，调用的时候可以通过指定包名即指定路径就可以调g用合适的类。
导入包可以通过import关键字进行。 - 使用import导入静态成员，
import static java.lang.Math.max;导入静态方法。
import static java.lang.System.out;导入静态成员变量. - final 变量。
可以用于变量声明，一旦变量被设定便不能再更改，通常可以用它定义变量为常量。再Java中定义全局变量，通常使用public static final 修饰，这样的常量只能在定义的时候被赋值。 - final方法
final方法不能被重写， - final类
定义为final的类不能被继承，final 类名{}
final类型的类的所有方法都是被隐式设置为final形式，但是类中的成员变量可以被定义为final或非final形式。 - 内部类（内部成员类，局部内部类，匿名类，静态内部类）
成员内部类：
成员内部类可以使用外部类的成员变量，包括private形式，外部类要想使用内部类的成员的时候得通过内部类的对象进行使用。如果要在外部类和非静态方法之外实例化内部类对象，需要使用外部类。不是在new操作符之前使用外部类的名称，而是使用外部类的对象。
还可以向上转型为接口。
使用this关键字获取内部类和外部类的引用
直接在内部类用this就可以用内部类，前面加上外部类的名字就可以用外部类。
局部内部类：
在方法里面也可以定义类，但是这个类就是属于方法的，所以外部类就调用不了，但是它可以访问外部类，
匿名内部类：
return new A(){
^^^//内部类体
}；
匿名内部类就是返回一个类的时候，但是没有创建，这个时候就可以整一个匿名内部类，返回他这个类。
静态内部类：
不能从静态内部类的对象中访问非静态外部类的对象。
如果创建静态内部类对象，不需要其他外部类的对象。
静态内部类可以有主方法 - 内部类的继承
public class OutClass extends ClassA.ClassB{
public OutClass(ClassA a){
a.super();
}
}
class ClassA{
class ClassB{
}
}
在某个类中继承内部类的时候，必须硬性的给予这个类一个带参数的构造方法，并且该构造方法的参数为需要继承的内部类的外部类的引用，同时构造方法体中使用a.super（）语句，这样才为继承提供了必要的对象引用。
异常处理
- 异常概述
程序的异常有error异常和exception，前者程序致命错误，只能修改代码，后者可以根据操作来应对错误。 - 异常有很多，一般没有按照规定都会异常
- 捕捉异常
Java语言的异常捕获结构由try，catch，finally三部分构成，
其中try语句块存放可能出现异常的Java语句，catch在try语句之后，用来激发被捕获的异常，finally语句块是异常处理结构的最后执行部分，无论try语句的代码如何退出，都将执行finally语句块。
可以有好几个错误然后慢慢抛出
try {
//程序代码块
}
catch(Exception1 e) {
//对这个错误的处理
}
catch(Exception2 e) {
//对这个错误的处理
}
……
finally {
//程序块
}
- 自定义异常
1，创建自定义异常类
2，在方法中通过throws关键字抛出异常对象
3，如果在当前抛出异常的方法中处理异常，可以使用try——catch语句块捕获并处理，否则在声明处通过throws关键字指明要抛出给方法调用者的异常，继续下一步操作
4，在出现异常方法的调用者中捕获并且处理异常
例子
public class MyException extends Exception {//创建自定义异常，继承Exception类
public MyException(String ErrorMessagr) { // 构造方法
super(ErrorMessagr+"asd"); // 父类构造方法
}
}
两者放在不同的类体中
public class Tran { // 创建类
// 定义方法，抛出异常
static int avg(int number1, int number2) throws MyException {
if (number1 < 0 || number2 < 0) { // 判断方法中参数是否满足指定条件
throw new MyException("不可以使用负数"); // 错误信息
}
if (number1 > 100 || number2 > 100) { // 判断方法中参数是否满足指定条件
throw new MyException("数值太大了"); // 错误信息
}
return (number1 + number2) / 2; // 将参数的平均值返回
}
public static void main(String[] args) { // 主方法
try {
int result = avg(102, 150); // 调用avg()方法
System.out.println(result); // 将avg()方法的返回值输出
} catch (MyException e1) {
System.out.println(e1); // 输出异常信息
}
}
}
- 在方法中抛出异常
throws抛出给上一级后要是不想处理可以继续向上抛出但最后必须处理
public class Shoot { // 创建类
static void pop() throws NegativeArraySizeException {
// 定义方法并抛出NegativeArraySizeException异常
int[] arr = new int[-3]; // 创建数组
}
public static void main(String[] args) { // 主方法
try { // try语句处理异常信息
pop(); // 调用pop()方法
} catch (NegativeArraySizeException e) {
System.out.println("pop()方法抛出的异常");// 输出异常信息
}
}
}
用throw抛出
public class MyException extends Exception { // 创建自定义异常类
String message; // 定义String类型变量
public MyException(String ErrorMessagr) { // 父类方法
message = ErrorMessagr;
}
public String getMessage() { // 覆盖getMessage()方法
return message;
}
}
public class Captor { // 创建类
static int quotient(int x, int y) throws MyException { // 定义方法抛出异常
if (y < 0) { // 判断参数是否小于0
throw new MyException("除数不能是负数"); // 异常信息
}
return x / y; // 返回值
}
public static void main(String args[]) { // 主方法
try { // try语句包含可能发生异常的语句
int result = quotient(3, 0); // 调用方法quotient()
} catch (MyException e) { // 处理自定义异常
System.out.println(e.getMessage()); // 输出异常信息
} catch (ArithmeticException e) { // 处理ArithmeticException异常
System.out.println("除数不能为0"); // 输出提示信息
} catch (Exception e) { // 处理其他异常
System.out.println("程序发生了其他的异常"); // 输出提示信息
}
}
}
- 运行时异常
| 种类 | 说明 |
|---|---|
| NullPointerException | 空指针异常 |
| ArrayIndexOutOfBoundsException | 数组下标越界异常 |
| ArithmeticException | 算数异常 |
| ArryayStoreException | 数组中包含不兼容的值抛出的异常 |
| IllegalArgumentException | 非法参数异常 |
| SecurityException | 安全性异常 |
| NegativeArraysSizeException | 数组长度为负异常 |
- 异常的使用原则
1，在当前方法声明中使用try——catch语句捕获异常
2，一个方法被覆盖时覆盖他的方法必须抛出相同的异常或异常的子类
3，如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常
第十三章 Swing程序设计
- 常用swing组件概述
| 组件名称 | 定义 |
|---|---|
| JButton | 代表Swing按钮，按钮可以带一些文字或图片 |
| JcheckBox | 代表Swing中的复选框组件 |
| JComBox | 代表下拉列表框，可以在下拉显示区域显示多个选项 |
| JFrame | 代表Swing框架类 |
| JDialog | 代表Swing版本的对话框架 |
| JLabel | 代表Swing的标签组件 |
| JRadioButton | 代表Swing的单选按钮 |
| JList | 代表能够在用户界面中显示一系列条目的组件 |
| JTextField | 代表文本框 |
| JPasswordField | 代表密码框 |
| JTextArea | 代表Swing的文本区域 |
| JOptionPane | 代表Swing的一些对话框 |
- 常用窗体
练习Frame窗体
package lianxi;
import java.awt.*;
import javax.swing.*;
public class get extends JFrame{//((也可以直接让get继承窗体，这样get本身就是一个窗体类了
public get() {
JFrame f=new JFrame("练习");//创建窗体对象，和窗体标题
f.setVisible(true);//设置窗体可见
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//这个参数的作用是隐藏窗口并停止程序
//f.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);//无任何操作
//f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);//释放窗体资源，释放完了，程序就继续运行然后停止
//f.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);//隐藏窗体，但不停止程序
f.setSize(303, 230);//设置窗体的大小，按照像素
f.setLocation(300, 400);//设置窗体的坐标，按照左上角第一个点为基准
//f.setBounds(600, 700, 500, 700);//设置窗体的坐标和大小，他们执行是按照顺序的，就是按照最后面的那一次
Container c =f.getContentPane();//获取窗体容器
c.setBackground(Color.GREEN);//设置背景颜色
JLabel l=new JLabel("我会创建窗体了");//创建窗体标签
l.setHorizontalAlignment(SwingConstants.CENTER);//使标签内的文字居中
c.add(l);//把组件添加到容器里面。
//c.remove(l);//把组件从容器里面删除
c.validate();//验证容器组件（刷新）；
//f.setContentPane(c);//重新载入容器
f.setResizable(false);//设置是否可以改变容器大小
System.out.println("x="+f.getX()+" y="+f.getY());//获取窗体的坐标
}
public static void main(String[] args) {
new get();
}
}
JDialog窗体
在应用程序中创建JDialog窗体需要实例化他的对象，通常有下面几种方法
1.public JDialog():创建一个没有标题和父窗体的对话框
2.public JDialog(Frame f):创建一个指定父窗体的对话框，但是这个窗体没有标题
3.public JDialog(Frame f,boolean model):创建一个指定类型的对话框，并指定父窗体，但该窗体没有标题
4.public JDialog(Frame f,String title):创建一个指定标题和父窗体的对话框
5.public JDialog(Frame f,String title,boolean model):创建一个指定标题，窗体和模式的对话框
package lianxi;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class get extends JDialog{
public get(JFrame frame) {
super(frame,"这是一个JDialog窗体",true);
Container c=getContentPane();
JLabel jl=new JLabel("我造了一个对话框");
c.add(jl);
setBounds(300, 400, 500, 600);
}
public static void main(String[] args) {
JFrame f=new JFrame("这是一个父类窗体");
f.setBounds(50, 50, 300, 400);//设置窗体的坐标和大小
Container c=f.getContentPane();//设置容器
JButton but=new JButton("创建一个按钮");
c.add(but);
f.setVisible(true);
f.setDefaultCloseOperation(EXIT_ON_CLOSE);//这个是关设置闭方式
but.addActionListener(new ActionListener() {//添加一个动作监听组件，
public void actionPerformed(ActionEvent e) {//应该就是有动作的时候就执行这个
get d=new get(f);
d.setVisible(true);//匿名内部类
}
});
}
}
- 标签组件和图标
标签的引用
package lianxi;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class get extends JFrame{
public get() {
setBounds(200, 300, 300, 400);//设置坐标大小
Container c=getContentPane();//新建一个窗体
setVisible(true);//设置可见
setDefaultCloseOperation(EXIT_ON_CLOSE);//设置关闭方法
JLabel jl=new JLabel("做一个标签");//新建标签
jl.setText("修改之后");//修改标签
System.out.println(jl.getText());//输出标签
c.add(jl);//把标签加到容器里面
Font type=new Font("楷体",Font.BOLD,40);//设置标签的格式类，字体，字体样式（加粗），字号
jl.setFont(type);//把字体样式添加到标签
jl.setForeground(Color.blue);//设置标签字体的颜色
}
public static void main(String[] args) {
new get();
}
}
图片图标的引用。 import javax.swing.ImageIcon;
- public ImageIcon();该构造方法创建一个通用的ImageIcon对象，当真正需要设置图片时候再使用ImageIcon对象调用setImage（Image image）方法来操作。
- public ImageIcon(Image image);可以直接从图片源创建图标。
- public ImageIcon(Image image,String description);除了可以直接从图片源创建图标之外，还可以为这个图标添加简要的描述，但是这个描述不会再图标上显示，可以使用getDescription（）方法获取这个描述。
- public ImageIcon(URL url);该构造方法利用位于计算机网络上的图片文件创建图标。
package lianxi;
import java.awt.*;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;
import javax.swing.*;
public class get extends JFrame{
public get() {
setBounds(300, 300, 500, 400);//设置坐标大小
setVisible(true);//设置可见
setDefaultCloseOperation(EXIT_ON_CLOSE);//设置关闭方法
JLabel jl =new JLabel("尝试着添加图片");//新建个标签
Container c=getContentPane();//新建个容器
c.add(jl);//把标签添加到容器里面
URL url =get.class.getResource("微信图片_20191219175327.png");//和下面的那一行，这个是获取图片URL的地址
Icon icon=new ImageIcon(url);//这个是获取i相应路径下的图片文件
//Icon icon=new ImageIcon("src/微信图片_20191219175327.png");//和上边的东西作用一样，更简单
jl.setIcon(icon);//把图片添加到标签中
}
public static void main(String[] args) {
new get();
}
}
图标的使用
5. 在swing中用Icon接口创建图标，可以在创建时给定大小颜色等，如果使用Icon接口的话，必须实现下面三种方法。
6. public int getIconHeight();获取图标的长
7. public int getIconWidth();获取宽
8. public void paintIcon(Component arg0,Graphics arg1,int arg2,int arg3);在指定位置画图
package com.lzw;
import java.awt.*;
import javax.swing.*;
public class DrawIcon implements Icon { // 实现Icon接口
private int width; // 声明图标的宽
private int height; // 声明图标的长
public int getIconHeight() { // 实现getIconHeight()方法
return this.height;
}
public int getIconWidth() { // 实现getIconWidth()方法
return this.width;
}
public DrawIcon(int width, int height) { // 定义构造方法
this.width = width;
this.height = height;
}// 实现paintIcon()方法
public void paintIcon(Component arg0, Graphics arg1, int x, int y) {
arg1.fillOval(x, y, width, height); // 绘制一个圆形，x，y是图形的坐标，三个相关方法必须实现
}
public static void main(String[] args) {
DrawIcon icon = new DrawIcon(50, 50);
// 创建一个标签，并设置标签上的文字在标签正中间
JLabel j = new JLabel("测试", icon, SwingConstants.CENTER);//给标签添加东西，名字和icon，还有位置
JFrame jf = new JFrame(); // 创建一个JFrame窗口
Container c = jf.getContentPane();//造一个容器
c.add(j);//标签添加到容器里面
jf.setSize(300,300);//设置窗体大小
jf.setVisible(true);//设置可见
jf.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);//设置关闭方式
}
}
- 常用布局管理器
1，绝对布局
直接设定组件在容器内的位值，步骤如下
使用Container.setLayout(null)方法取消布局管理器
使用Container.setBounds(int a,int b,int c,int d)方法设置每个组件的大小和位置
其中a，b表示组件在容器内的坐标位置，c，d表示x方向的长度和y方向的长度
要注意在使用绝对布局之前要告知编译器不再使用布局管理器。
例子
l例子
setTitle(“本窗体使用绝对布局”); // 设置该窗体的标题
setLayout(null); // 使该窗体取消布局管理器设置
setBounds(0, 0, 200, 150); // 绝对定位窗体的位置与大小
Container c = getContentPane(); // 创建容器对象
JButton b1 = new JButton(“按钮1”); // 创建按钮
JButton b2 = new JButton(“按钮2”); // 创建按钮
b1.setBounds(10, 30, 80, 30); // 设置按钮的位置与大小
b2.setBounds(60, 70, 100, 20);
c.add(b1); // 将按钮添加到容器中
c.add(b2);
setVisible(true); // 使窗体可见
// 设置窗体关闭方式
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
流布局管理器
流（FlowLayout）布局管理器是最基本的布局管理器，默认情况下，组件的排列都是剧中的，但可以更改设置来实现指定布局。
FlowLayout类中常有以下的构造方法
public FlowLayout();
public FlowLayout(int alignment);
public FlowLayout(int alignment,int horizGap,int vertGap);
其中alignment参数是表示组件在每一行的位置，有三个值，0，1，2.。0是左对齐，2是右对齐，1是居中。
其中horizGap表示组件的水平间隔，vertGap是垂直间隔。
边界布局管理器
在默认不指定窗体布局的情况下，Swing组件的布局模式是边界（BorderLayout）布局管理器，边界布局管理器将容器划分为东南西北中五个区域，调用Container类的add（）方法添加组件时可以设置组件在窗体的区域，区域控制可以用BorderLayout类中的成员变量来决定。
c.add(按钮布局方法，按钮名字）；
网格布局管理器
网格（GridLayout）布局管理器将容器化为网格，组件按行案列放置，从左到右，从上到下，常有两个构造方法。
public GridLayout(int a1,in a2);
public GridLayout(int a1,int a2,int a3,int a4);
a1，a2表示网格的行数和列数，a3，a4表示指定网格之间的距离，前者是水平方向，后者是竖直方向。
例子
Container c = getContentPane();
// 设置容器使用网格布局管理器，设置7行3列的网格
setLayout(new GridLayout(7, 3, 5, 5));
网格组布局管理器
是GridBagLayout类，向网格组布局管理器添加组件的时候，需要为每个组件创建一个与之关联的GridBagConstraints类的对象，下面介绍一些属性的功能和使用方法。
1，gridx和gridy属性
用来设置组件起始位置的索引值，一个x一个y
2,gridwidth和gridheight属性
用来设置组件在网格组占用的行数和列数前者行数，后者列数
3,anchor属性
一个九个方向，就有九个常量，表示组件在所占的网格组要呆的地方，
NORTH,EAST,SOUTH,WEST,SOUTHEAST,NORTHEAST,SOUTHEAST,SOUTHWEST,CENTER，九个方向
4，fill属性
用来设置组建的填充反方式
NONE默认是这个，不填
HORIZONTAL水平方向填充
VERTICAL竖直方向填充
BOTH全都填充
5,insets属性
用来设置他与四周单元格边缘的最小距离
Insets（int top,int left,int bottom,int right)分别是上左下右，默认是没有距离
6,ipadx和ipady属性
用来修改组件的首选大小，前者是宽度，后者是高度，正数是扩大，负数是缩小
7,weightx和weighty属性
用来设置网格组每一行和每一列对额外空间的分布方式，他们的默认值都是零，表示不占用额外空间，都以各自的最大值为准，一般只设置第一行第一列，便于维护。
带个例子
void init2() {
GridBagConstraints g1=new GridBagConstraints();
JButton j1=new JButton("jb");
g1.gridx=1;
g1.gridy=1;
//g1.gridwidth=1;
//g1.gridheight=1;
g1.weightx=444;
g1.weighty=444;
g1.fill=GridBagConstraints.BOTH;
//g1.anchor=GridBagConstraints.NORTH;
//g1.fill=GridBagConstraints.VERTICAL;
//g1.insets=new Insets(5,5,5,188);
//g1.ipadx=10;
//g1.ipady=10;
c.add(j1,g1);
}