java学习笔记

API（Application Programming Interface,应用程序编程接口）
是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。

# java 方法体

public void test(){}
大括号里就是方法体
如果没有{}，就没有方法体
有{} 但是里面没内容说明方法体为空，但是有方法体
test是方法名
方法体就是方法的内容

final类

假设希望阻止人们定义类的子类，就可以在定义这个类的时候 使用 final 修饰符声明,类中的特定方法也可以被声明为 final。 如果这样做，子类就不能覆盖这个方法（ final 类158 Java 核心技?中的所有方法自动地成为 final 方法。)

将方法或类声明为 final 主要目的是： 确保它们不会在子类中改变语义。

对象类型的转换

*向上转型
把子类对象赋值给父类对象
*向下转型
将一个超类的引用赋给一个子类变量。语法：Manager boss = (Manager) staff[0]:
进行类型转换的唯一原因是：在暂时忽视 对象的实际类型之后， 使用对象的全部功能。每个对象变量都属于一个类型。类型描述了这个变量所引用的以及能够引用的对象类型。例如， staff[i] 引用一个 Employee 对象（因此它还可以引用 Manager对象。)

Object

• equals
  Object 类中的 equals 方法用于检测一个对象是否等于另外一个对象。这个方法将判断两个对象是否具有相同的引用。

• toString
  Object 类定义了 toString 方法， 用来打印输出对象所属的类名和散列码。例如， 调用System.out.println(System.out) 将输出下列内容：java.io.PrintStream@2f6684 之所以得到这样的结果是因为 PrintStream 类的设计者没有覆盖 toString方法。

this 与 super

• this
• super

关键字 this 有两个用途：一是引用隐式参数，二是调用该类其他的构
造器 ， 同样，super 关键字也有两个用途：一是调用超类的方法，二是调用超类的构造器。
在调用构造器的时候， 这两个关键字的使用方式很相似。调用构造器的语句只能作为另
一个构造器的第一条语句出现。 构造参数既可以传递给本类 （this) 的其他构造器， 也可
以传递给超类（super ) 的构造器。

extend

子类继承超类时，超类必须有一个不带参数的构造方法。

hashcode

散列码（ hash code ) 是由对象导出的一个整型值。由于 hashCode 方法定义在 Object 类中， 因此每个对象都有一个默认的散列码，其值为对象的存储地址。
以下程序实现了 Employee 类（程序清单 5-9 ) 和 Manager类（程序清单 5-10 )的 equals、hashCode 和 toString 方法。
“`java
package equals;

/**
* 程序清单 5-8 equals/EqualsTest.java
* This program demonstrates the equals method.
* @author yxd
* 2018.5.14
*/
public class equals {

/**
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    Employee alicel = new Employee("Alice Adams" , 75000, 1987, 12 , 15);
    Employee alice2 = alicel;
    Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);
    Employee bob = new Employee("Bob Brandson" , 50000, 1989, 10, 1);

    System.out.println("alicel == alice2: " + (alicel == alice2));

    System.out.println("alicel == alice3: " + (alicel == alice3));

    System.out.println("alicel.equals(alice3) : " + alicel.equals(alice3));

    System.out.println("alicel.equals(bob) : " + alicel.equals(bob)) ;

    System.out.println("bob.toStringO:" + bob);

    Manager carl = new Manager("Carl Cracker", 80000 , 1987, 12, 15) ;
    Manager boss = new Manager("Carl Cracker", 80000 , 1987, 12 , 15) ;
    boss. setBonus(5000);
    System.out.println("boss.toStringO：" + boss);
    System.out.println("carl .equals(boss) : " + carl .equals(boss)) ;
    System.out.println("alicel.hashCode() : " + alicel. hashCode()) ;
    System.out.println("alice3 . hashCode() : " + alice3 .hashCode()) ;
    System.out.println("bob.hashCodeO： " + bob.hashCode());
    System.out.println("carl .hashCodeQ: " + carl.hashCode());
}

}

package equals;
import java.time.*;
import java.util.Objects;
/**
* @author yxd
*
*/
public class Employee {

/*
 * 程序清单 5-9 equals/Employee.java
 * @param args
 */
private String name;
private double salary;
private LocalDate hireDay;
public Employee()
{

}
public Employee(String name , double salary , int year , int month, int day)
{
    this.name = name;
    this.salary = salary;
    hireDay = LocalDate.of(year, month, day);
}
public String getName()
{
    return name;
}
public double getSalary()
{
    return salary;
}

public LocalDate getHireDay()
{
    return hireDay;
}
public void raiseSalary(double byPercent)
{
    double raise = salary * byPercent / 100;
    salary += raise;
}
public boolean equals(Object otherObject)
{
// a quick test to see if the objects are identical
    if (this == otherObject) return true;
// must return false if the explicit parameter is null
    if (otherObject == null) return false;
// if the classes don't match, they can 't be equal
    if (getClass()!= otherObject.getClass()) return false;
// now we know otherObject is a non-null Employee
    Employee other = (Employee) otherObject;  //类型转换，超类到子类
// test whether the fields have identical values
    return Objects.equals(name, other.name) && salary == other.salary
            && Objects.equals(hireDay, other.hireDay) ;
}
public int hashCode()
{
return Objects.hash(name, salary, hireDay);
}
public String toString()
{
    return getClass().getName() + "[name:" + name +"salary:" 
            + salary + ",hireDay=" + hireDay+"]";
}
public static void main(String[] args) {
    // TODO Auto-generated method stub

}

}
package equals;

/**
* @author yxd
* 程序清单 5-10 equals/Manager.java
*/
public class Manager extends Employee {

private double bonus;

public Manager(String name,double salary,int year,int month,int day)
{
    super(name,salary,year,month,day);
    bonus=0;
}
public double getSalary()
{
    double baseSalary = super.getSalary() ;
    return baseSalary + bonus;
}
public void setBonus(double bonus)
{
    this.bonus = bonus;
}
public boolean equals(Object otherObject)
{
    if(!super.equals(otherObject))
        return false;
    Manager other = (Manager)otherObject;
    // super.equals checked that this and other belong to the same class
    return bonus== other.bonus;
}
public int hashCode()
{
    return super.hashCode()+17*new Double (bonus).hashCode();
}
public String toString()
{
    return super.toString()+"[bonus="+bonus+"]";
}

}

泛型

优点

• 安全简单
• 提高代码的重用率

异常处理

final

不管是否有异常被捕获，finally 子句中的代码都被执行。
以下情况，finally块将不会被执行：
1. finally块中发生了异常；
2. 程序所在线程死亡；
3.在前面法代码中用了System.exit();
4.关闭CPU

线程

• 什么是进程
  进程是指运行中的应用程序，每个进程都有自己的独立的地址空间（内存空间），用户每启动一个进程，操作系统就会为该进程分配一个独立的内存空间。

• 什么是线程
  是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属于一个进程的其他线程共享进程所拥有的全部资源。一个线程可与创建和撤销另一个线程，同一个进程的多个线程之间可以边修改后执行。线程有就绪、阻塞和运行三种基本状态。
  简单点：

  • 线程是轻量级的进
  • 线程没有独立的地址空间（内存空间）
  • 线程是由进程创建的（寄生在进程）
  • 一个进程可以拥有多个线程—>这就是我们常说的多线程编程
  • 线程有几种状态：
    1.新建状态（new）
    2 就绪状态（Runnable）
    3.运行状态（Running）
    4.阻塞状态（Bloced）
    5.死亡状态（Dead）

  注意
  Threaf.currentThread().getName() //当前线程的名字
  线程的同步问题：解决问题的关键就是保证容易出问题的代码的原子性，所谓原子性就是指：当a线程在执行某段代码的时候，别的线程必须等到a线程执行完后，它才能执行这段代码。就像好些人排队上厕所，厕所只有一个马桶，得一个一个的解决。
  对同步机制的解释：java任对象都有一个标志位，该标志位具有0,1两种状态，其开始状态为1，当某个线程执行synchronized(object)语句后，object对象的标志位变为0的状态，直到执行完整个sychronized语句中的代码块后，该对象的标志位又回到1状态。 当一个线程执行到synchronized(object) 语句的时候，先检查object对象的标志位，如果为0状态，表明已经有另外的线程正在执行synchronized包括的代码，那么这个线程将暂时阻塞，让出cpu资源，直到另外的线程执行完相关的同步代码，并将object对象的标志位变为1状态，这个线程的阻塞就被取消，线程将继续运行，该线程又 将object的标志位变为0状态，防止其他的线程再进入的同步代码块中。

文件流

文件在程序中是以流的形式来操作的。
流：数据在数据源（文件）和程序（内存）之间经历的路径
输入流：数据从数据源（文件）到程序（内存）的路径
输出流：数据从程序（内存）到数据源（文件）的路径

文件流-分类

java文件流分为两种流，
1.字节流：可以用于读写二进制文件及任何类型文件
2.字符流：可以用于读写文本文件，不能操作二进制文件。
| | 字节流 | 字符流 |

输入/输出	字节流	字符流
输入	InputStream	Reader
输出	OutputStram	Writer

file没有读写的能力，所以需要InputStream
打开文件处理完毕后必须关闭文件，放在finally中完成

缓冲字符流

为了提高效率引入缓冲字符流
文件缓冲字符流，目的:BufferedReader和BufferedWriter类介绍，直接操作String

注意:
‘’‘’java
byte buf[]=new byte[1024];
int n=0;//记录实际读到的字节数
while((n=fis.read(buf))!=-1)
{
中

基本编码

unicode编码：用两个字节表示一个字符（可以死英文字母，可以死汉字）->对汉字比较友好
非unicode 编码：用一个字节表示一个字母，用两个字节表示一个汉字。

常见编码：
big5
iso-8859-1编码
gb2312国际码
gbk 可以支持更多汉字

sql server 数据类型

字符型

char 定长 最大8000字符（非unicode编码）
char（10）‘小伟’前四个字符放‘小伟’，后6个字符空格补全
varchar 变长 最大8000字符 （非unicode 编码）
varchar(10) ‘小伟’sql server 分配四个字符，这样可以节省空间
注意：当使用数据为定长时最好使用char 查询较快

ntext 可变长度unicode 数据，最大为2的30次方-1（1,073,741,823）个字符
text 可变长度unicode数据，最大长度为2的31次方-1（2,147,483,647）个字符
注意：text 是字节格式存储英文的，也可以存中文但有时候会显示成乱码；ntext 是多字节格式存储unicode的，也就是说存储各种文字用的

nchr 定长 最大4000字符 （unicode编码）
nvarchar 变长 最大4000字符（unicode 编码）

特别说明
1.对于变长的字符，一般带有汉字使用nvarchar，全英文使用varchar，nvarchar处理汉字或其他unicode 字符集的速度比varchar字段块；
2.如果一些特殊字符nvarchar没有的，如日文的某些片名，那当然只能选合适的代码页用varchar了，而且这些特有语言特有的字符转换到nvarchar会丢失

数字型

1.bit 范围0到1
2.int 范围 -2的31次方到 2的31次方减1
3.bigint 范围-2的63次方到2的63次方-1
4.float 存放小数，不推荐使用
5 numeric 小数

针对外键，注意
外键只能指向主键
外键和主键的主键类型要一致