java基础入门笔记（二）

抽象类

使用关键字abstract声明的类，使用abstract声明的成员方法称为抽象方法，抽象方法只有方法没有方法体，需要在子类中去实现。

public abstract class CloseFigure
{
    public abstract double area();
}

抽象类不能被实例化，既不能创建抽象类的实例；

CloseFigure g=new CloseFigure();//语法错误

注意：

1、当一个类，继承的父类为抽象类时，需要把抽象类中的所有抽象方法全部实现。
2、抽象方法不能有主体，但是抽象类中可以有可以实现的方法。

abstract class Animal
{
    String name;
    int age;
    abstract public void aaa();//抽象方法，不能有主体
    public void cry( )   //可以实现的非抽象方法的方法
    {
        System.out.println("不知道怎么叫");
    }
}

abstract class Animal
{
    String name;
    int age;
    //动物会叫
    abstract public void cry();
}
//当一个类，继承的父类为抽象类时，需要把抽象类中的所有抽象方法全部实验。
class Cat extends Animal
{
    //实现父类的cry();
    public void cry()
    {
        System.out.println("猫猫叫");
    }
}

接口

接口是一组抽象方法、常量和内嵌类型的集合，接口是一种数据类型，接口采用抽象的形式来描述约定，一个接口可被多个类实现。

注意：

1、接口出成员变量都是常量，声明时必须赋值，默认修饰符为public static final;不能声明实例成员变量。
2、接口中的成员方法都是抽象的实例成员方法，默认修饰符为public abstract,不能声明为static.
3、接口中不能包含构造方法,因为构造方法不能是抽象的。
4、接口的访问权限是public或者缺省
5、接口没有具体任何实现，也不能创建实例。
6、当一个类实现了一个接口，就要求该类把这个接口的所有方法通通实现。

public class test2 {
    public static void main(String[] args)
    {
        //创建一个计算机
        Compture computer =new Compture();
        Camera camera=new Camera();
        Phone phone= new Phone();
        computer.useUsb(camera);
        computer.useUsb(phone);
    }
}
interface useUsb{
    public void start();//开始工作
    public void stop();//停止工作
}
class Camera implements useUsb{
    public void start()
    {
        System.out.println("我是相机，我开始工作了");
    }
    public void stop()
    {
        System.out.println("我是相机，我停止工作了");
    }
}
class Phone implements useUsb{
    public void start()
    {
        System.out.println("我是手机，我开始工作了");
    }
    public void stop()
    {
        System.out.println("我是手机，我停止工作了");
    }
}
class Compture{
    public void useUsb(useUsb usb)//多态
    {
        usb.start();
        usb.stop();
    }
}

注意

1、接口不能被实例化
2、接口中的所有(抽象方法和非抽象方法)方法不能主体
3、一个类可以实现多个接口
4、一个接口不能继承其他类，但是可以继承其他接口

BufferedReader类

所属类库：
   java.lang.Object
     java.io.Reader
         java.io.BufferedReader
基本概念
   public class BufferedReader extends Reader
  从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值足够大。

    通常， Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader （如 FileReader 和 InputStreamReader ）。

    BufferedReader 流能够读取文本行 , 通过向 BufferedReader 传递一个 Reader 对象 , 来创建一个 BufferedReader 对象 , 之所以这样做是因为 FileReader 没有提供读取文本行的功能 .

import java.awt.datatransfer.FlavorTable;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class test4 {
    public static void main(String[] args) throws Exception
    {
        InputStreamReader inputs=new InputStreamReader(System.in);
        BufferedReader bufferedReader=new BufferedReader(inputs);
        System.out.println("请输入一系列文字，可以包括空格：");
        String text=bufferedReader.readLine();
        System.out.println("输入是文字是："+text);
    }
}

注解：
throws Exception 抛出异常
InputStreamReader 是字节流通向字符流的桥梁

InputStreamReader类

    InputStreamReader 将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码，该解码过程将使用平台默认的字符编码，如：GBK。
构造方法 ：
    InputStreamReader isr = new InputStreamReader(InputStream in);//构造一个默认编码集的InputStreamReader类
     InputStreamReader isr = new InputStreamReader(InputStream in,String charsetName);//构造一个指定编码集的InputStreamReader类。

    参数 in对象通过 InputStream in = System.in;获得。//读取键盘上的数据。
     或者 InputStream in = new FileInputStream(String fileName);//读取文件中的数据。可以看出 FileInputStream 为InputStream的子类。
主要方法 ：int read();//读取单个字符。
int read(char []cbuf);//将读取到的字符存到数组中。返回读取的字符数。

对象数组

数组

int a[]={1,2,3,4,5};
int b[];
b=a;
b[1]=10;

通过数组变量改变数组b[1]的值，实际上也改变了另一个数组变量a 所引用的数组元素a[1];
注意：
引用数据类型的变量获得存储单元的方式都是动态的，必须有使用new运算符申请并动态获得存储单元。引用变量保存地址、长度、引用计数等特性。

public class test3 {
    public static void main(String [] args)
    {
        //定义对象数组；
        Dog dogs[]=new Dog[4];
        //给各个赋值
        //dogs[0]=new Dog();//注意这儿！如果没有这个语句将会报错！空指针异样。需要理解
        dogs[0].setName("花花");
    }
}
class Dog
{
    private String name;
    private int age;
    private float weight;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public float getWeight() {
        return weight;
    }
    public void setWeight(float weight) {
        this.weight = weight;
    }

/*
 * 功能：对象数组的使用
 */
package subject6;

import java.awt.datatransfer.FlavorTable;
import java.io.BufferedReader;
import java.io.InputStreamReader;

import javafx.util.converter.FloatStringConverter;

public class test3 {
    public static void main(String [] args) throws Exception
    {
        //定义对象数组；
        Dog dogs[]=new Dog[4];
        InputStreamReader isr=new InputStreamReader(System.in);//注意这儿！
        BufferedReader br=new BufferedReader(isr);
        for(int i=0;i<4;i++)
        {
            dogs[i]=new Dog();
            System.out.println("请输入第"+(i+1)+"狗的姓名：");
            //从控制台读取狗名
            String name=br.readLine();//异常
            //将名字赋给对象
            dogs[i].setName(name);
            System.out.println("请输入第"+(i+1)+"狗的体重");
            String s_weight=br.readLine();
            float weight=Float.parseFloat(s_weight);//将string-->float型！注意了
            dogs[i].setWeight(weight);          
        }
        float allWeight=0;
        float aveWeight=0;
        for(int i=0;i<4;i++)
        {
            //计算总体重
            allWeight=allWeight+dogs[i].getWeight();
            aveWeight=allWeight/dogs.length;
        }
            System.out.println("总体重："+allWeight+"，平均体重："+aveWeight);            
    }
}
class Dog
{
    private String name;
    private int age;
    private float weight;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public float getWeight() {
        return weight;
    }
    public void setWeight(float weight) {
        this.weight = weight;
    }   
}

注意：
1、比较字符串内容是否相等用：equals,”==”是比较字符串地址。
2、数组可以存放同一类型数据
3、对象数组在定以后，赋值时需要再次为每个对象分配空间【即：new 对象】
4、数组大小必须事先指定
5、数组下标是从0开始的
6、数组名可以理解为指向数组首地址的引用

枚举

枚举其实就是一种类型，跟int、char这种差不多，就是定义变量时限制输入的，你只能使用enum里面规定的值。

    public static enum SeasonEnum
    {
        spring,summer,autumn,winter;
        //注意：枚举写在最前面，否则编译出错
        private final static String position="test";
        public static SeasonEnum getSeason()
        {
            if("test".equals(position))
                return spring;
            else
                return winter;
        }
    }

排序

1、内部排序

将要处理的所有数据加载到内部存储器中进行排序。有：交换式排序、选择排序法和插入式排序法。

2、外部排序

数据量过大、无法全部加载到内存中，需要借助外部存储进行排序，有：合并排序法和直接排序法。
例子：定义Person类，包含name（姓名）、birthday（出生日期）、idCard（身份证号）、sex（性别）、age(年龄)等基本信息，通过使用Comparator接口实验Person类可以按姓名、年龄、出生日期等多种比较规则进行排序。

package com.exper6;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

import javafx.scene.chart.PieChart.Data;
//import sun.security.provider.JavaKeyStore.CaseExactJKS;

public class Person {
    private String name;
    private int age;
    private Date birthday;
    private char sex;

    public Person(String name, int age, Date birthday, char sex) //构造函数
    {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
        this.sex = sex;
    }

    public Person() {
        setName(name);
        setAge(age);
        setBirthday(birthday);
        setSex(sex);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public static enum AscOrDesc // 排序方式，注意枚举的方式
    {
        Asc, Desc
    }

    public void sort(Person persons[], AscOrDesc ascOrDesc, Comparator comp) {
        if (persons == null | persons.length == 0) {
            return;
        }
        for (int i = 0; i < persons.length - 1; i++) {
            for (int j = i + 1; j < persons.length; j++) {
                switch (ascOrDesc) {
                case Asc:// 升序
                    if (comp.compare(persons[i], persons[j]) > 0) {
                        Person temp = persons[i];
                        persons[i] = persons[j];
                        persons[j] = temp;// 实现交换
                    }
                    break;
                case Desc:
                    if (comp.compare(persons[i], persons[j]) < 0) {
                        Person temp = persons[i];
                        persons[i] = persons[j];
                        persons[j] = temp;// 实现交换
                    }
                    break;
                default:
                    break;
                }
            }
        }
    }

    public void print(Person persons[]) {
        if (persons == null || persons.length == 0) {
            return;
        }
        for (int i = 0; i < persons.length; i++) {
            System.out.println(persons[i].toString());
        }
    }

    public String toString()// 覆盖toString方法
    {
        SimpleDateFormat date = new SimpleDateFormat("yyyy年MM月dd日");
        return "姓名是：" + name + ",年龄是：" + age + ",出生日期是：" + date.format(birthday);
    }

    public static void main(String[] args) {
        Comparator compare1 = new CompareBirthday();
        Person.AscOrDesc ascOrDesc = Person.AscOrDesc.Asc;
        Person persons[] = new Person[5];
        Calendar data = Calendar.getInstance();// 调用getInstance()创建一个子类实例。
        data.set(1992, 4, 2);
        persons[0] = new Person("小明", 24, data.getTime(), '男');
        data.set(1993, 5, 27);
        persons[1] = new Person("王二小", 23, data.getTime(), '男');
        data.set(1993, 7, 6);
        persons[2] = new Person("小花", 23, data.getTime(), '女');
        data.set(1994, 9, 11);
        persons[3] = new Person("小红", 22, data.getTime(), '女');
        data.set(1995, 9, 23);
        persons[4] = new Person("李武", 21, data.getTime(), '男');
        Person person = new Person();
        System.out.println("排序之前：");
        person.print(persons);
        person.sort(persons, ascOrDesc, compare1);
        System.out.println("排序之后：");
        person.print(persons);

    }
}

class CompareAge implements Comparator// 年龄比较
{
    @Override
    public int compare(Person arg0, Person arg1) {
        return arg0.getAge() - arg1.getAge();
    }
}

class CompareBirthday implements Comparator// 出生日期比较
{

    public int compare(Person p1, Person p2) {
        return p1.getBirthday().compareTo(p2.getBirthday());
    }
}

class CompareName implements Comparator// 姓名比较
{
    public int compare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName());
    }
}

java String.trim()方法

该方法返回一个复制该字符串的开头和结尾的白色空格去掉，或字符串，如果它没有头或尾空白.

描述

java.lang.String.trim() 方法返回一个字符串副本，并忽略(去除)开头和结尾的空白

声明

public String trim()

实例

package text;

public class text {
    public static void main(String[] args){
        String str="    This is YiBai    ";
        System.out.println("Before trim:"+"..."+str+"...");
        System.out.println("After trim:"+"..."+str.trim()+"...");
    }

}

结果：

jOptionPane类提示框的一些常用方法

showMessageDialog的例子：

Swing中提供了JOptionPane类来实现类似Windows平台下的MessageBox的功能，同样在Java中也有，利用JOptionPane类中的各个static方法来生成各种标准的对话框，实现显示出信息、提出问题、警告、用户输入参数等功能。这些对话框都是模式对话框。
ConfirmDialog　—　确认对话框，提出问题，然后由用户自己来确认（按”Yes”或”No”按钮）
InputDialog　—　提示输入文本
MessageDialog　—　显示信息
OptionDialog　-－　组合其它三个对话框类型。
　　这四个对话框可以采用showXXXDialog()来显示，如showConfirmDialog()显示确认对话框、showInputDialog()显示输入文本对话框、showMessageDialog()显示信息对话框、showOptionDialog()显示选择性的对话框。它们所使用的参数说明如下：
① ParentComponent：指示对话框的父窗口对象，一般为当前窗口。也可以为null即采用缺省的Frame作为父窗口，此时对话框将设置在屏幕的正中。
② message：指示要在对话框内显示的描述性的文字
③ String title：标题条文字串。
④ Component：在对话框内要显示的组件（如按钮）
⑤ Icon：在对话框内要显示的图标
⑥ messageType：一般可以为如下的值ERROR_MESSAGE、INFORMATION_MESSAGE、WARNING_MESSAGE、QUESTION_MESSAGE、PLAIN_MESSAGE、
⑦ optionType：它决定在对话框的底部所要显示的按钮选项。一般可以为DEFAULT_OPTION、YES_NO_OPTION、YES_NO_CANCEL_OPTION、OK_CANCEL_OPTION。
1，JOptionPane.showMessageDialog(null, "友情提示");

2,JOptionPane.showMessageDialog(JPanel, "友情提示","标题",JOptionPane.WARNING_MESSAGE);

showOptionDialog

这个函数可以改变显示在按钮上的文字。你还可以执行更多的个性化操作。
1，int n=JOptionPane.showConfirmDialog(null, "你高兴吗？","标题",JOptionPane.YES_NO_OPTION);

2,Object[] options={"好啊！","去一边！"};
int n=JOptionPane.showOptionDialog(null, "我可以约你吗？","标题",JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, options, options[0]);

java通过JDBC连接Mysql数据库的方法

Java是通过JDBC连接Mysql数据库的。JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。
注意：如果要使用数据库就要添加数据库的驱动，不同的数据库有不用的驱动。

execute、executeUpdate、executeQuery三者的区别（及返回值）

Statement 接口提供了三种执行 SQL 语句的方法：executeQuery、executeUpdate 和 execute。使用哪一个方法由 SQL 语句所产生的内容决定。
1、ResultSet executeQuery(String sql);
执行SQL查询，并返回ResultSet 对象。用于产生单个结果集的语句
2、int executeUpdate(String sql);
可执行增，删，改，返回执行受到影响的行数。
3、boolean execute(String sql);
可执行任何SQL语句，返回一个布尔值，表示是否返回ResultSet 。
注意：ResultSet使用：
例如：ResultSet rs;声明一个ResultSet类型的rs变量，用来保存数据库里提取出来的记录，最后通过一个循环把所有的记录显示出来。

prepareStatement的用法和解释

1.PreparedStatement是预编译的,对于批量处理可以大大提高效率. 也叫JDBC存储过程
2.使用 Statement 对象。在对数据库只执行一次性存取的时侯，用 Statement 对象进行处理。PreparedStatement 对象的开销比Statement大，对于一次性操作并不会带来额外的好处。
3.statement每次执行sql语句，相关数据库都要执行sql语句的编译，preparedstatement是预编译得, preparedstatement支持批处理
片段一：

String sql="select* from t_user where userName=? and password=?";
ResultSet rs = statement.executeQuery(sql); 

片段二：

String sql="select* from t_user where userName=? and password=?";
PreparedStatement pstmt=con.prepareStatement(sql);
pstmt.setString(1, user.getUserName());
pstmt.setString(2, user.getPassword());
ResultSet rs =pstmt.executeQuery();//结果集

片断2和片断1的区别在于，后者使用了PreparedStatement对象，而前者是普通的Statement对象。PreparedStatement对象不仅包含了SQL语句，而且大多数情况下这个语句已经被预编译过，因而当其执行时，只需DBMS运行SQL语句，而不必先编译。当你需要执行Statement对象多次的时候，PreparedStatement对象将会大大降低运行时间，当然也加快了访问数据库的速度。
这种转换也给你带来很大的便利，不必重复SQL语句的句法，而只需更改其中变量的值，便可重新执行SQL语句。选择PreparedStatement对象与否，在于相同句法的SQL语句是否执行了多次，而且两次之间的差别仅仅是变量的不同。如果仅仅执行了一次的话，它应该和普通的对象毫无差异，体现不出它预编译的优越性。
4.执行许多SQL语句的JDBC程序产生大量的Statement和PreparedStatement对象。通常认为PreparedStatement对象比Statement对象更有效,特别是如果带有不同参数的同一SQL语句被多次执行的时候。PreparedStatement对象允许数据库预编译SQL语句，这样在随后的运行中可以节省时间并增加代码的可读性。

然而，在Oracle环境中，开发人员实际上有更大的灵活性。当使用Statement或PreparedStatement对象时，Oracle数据库会缓存SQL语句以便以后使用。在一些情况下,由于驱动器自身需要额外的处理和在Java应用程序和Oracle服务器间增加的网络活动，执行PreparedStatement对象实际上会花更长的时间。

然而，除了缓冲的问题之外，至少还有一个更好的原因使我们在企业应用程序中更喜欢使用PreparedStatement对象,那就是安全性。传递给PreparedStatement对象的参数可以被强制进行类型转换，使开发人员可以确保在插入或查询数据时与底层的数据库格式匹配。

当处理公共Web站点上的用户传来的数据的时候，安全性的问题就变得极为重要。传递给PreparedStatement的字符串参数会自动被驱动器忽略。最简单的情况下，这就意味着当你的程序试着将字符串“D’Angelo”插入到VARCHAR2中时，该语句将不会识别第一个“，”，从而导致悲惨的失败。几乎很少有必要创建你自己的字符串忽略代码。

在Web环境中，有恶意的用户会利用那些设计不完善的、不能正确处理字符串的应用程序。特别是在公共Web站点上,在没有首先通过PreparedStatement对象处理的情况下，所有的用户输入都不应该传递给SQL语句。此外，在用户有机会修改SQL语句的地方，如HTML的隐藏区域或一个查询字符串上，SQL语句都不应该被显示出来。
在执行SQL命令时，我们有二种选择：可以使用PreparedStatement对象，也可以使用Statement对象。无论多少次地使用同一个SQL命令，PreparedStatement都只对它解析和编译一次。当使用Statement对象时，每次执行一个SQL命令时，都会对它进行解析和编译。
第一：
prepareStatement会先初始化SQL，先把这个SQL提交到数据库中进行预处理，多次使用可提高效率。
createStatement不会初始化，没有预处理，没次都是从0开始执行SQL
第二：
prepareStatement可以替换变量
在SQL语句中可以包含?，可以用ps=conn.prepareStatement(“select * from Cust where ID=?”);
int sid=1001;
ps.setInt(1, sid);
rs = ps.executeQuery();
可以把?替换成变量。
而Statement只能用
int sid=1001;
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(“select * from Cust where ID=”+sid);
来实现。
第三：
prepareStatement会先初始化SQL，先把这个SQL提交到数据库中进行预处理，多次使用可提高效率。
createStatement不会初始化，没有预处理，没次都是从0开始执行SQL