# 设置名字
$ git config --global user.name "你的名字"
# 设置邮箱
$ git config --global user.email "你的邮箱"

# 设置名字
$ git config user.name "你的名字"
# 设置邮箱(邮箱与全局相同可以不设置)
$ git config user.email "你的邮箱"

#关闭忽略大小写
git config core.ignorecase false

git add reader.txt
git add .

git commit -m "xxx"

$ git diff HEAD~n

$ git checkout -- filename

$ git reset HEAD filename

$ git log

$ git reset --hard HEAD^
$ git reset --hard 一长串数字

$ git reflog

$ git reset --hard HEAD@{1}
$ git reset --hard 一长串数字

$ git rm

#通过一个对象的哈希值查看对象的类型(blob、tree、commit或tag)
$ git cat-file -t commit_id
#通过对象的哈希值可以查看这个对象的内容
$ git cat-file -p commit_id

$ git log --pretty=raw
$ git cat-file

#显示index文件的内容
$ git ls-files --stage

git checkout -b dev //创建并切换到分支dev
#相当于：
$ git branch dev
$ git checkout dev

$ git branch

$ git branch -d dev

#合并到master上
$ git merge dev

$ git reset --hard HEAD~1

$ git log --graph --pretty=oneline --abbrev-commit

# 保存未提交的内容
$ git stash
# 查看所有stash内容
$ git stash list

# 查看dev分支的状态
$ git status
# 还原被保存的工作
$ git stash apply

$ git stash save "Reupdate reader.txt"
#再次查看当前stash的内容
$ git stash list

git diff branchName`把当前branch跟branchName进行比较，也可以使用`git diff branchNameA branchNameB

$ git clone /c/vm/CentralRepo/ #被clone的仓库的地址

$ git add calc.py
$ git commit -m "add calc file"

$ git push origin master

$ git clone /c/vm/CentralRepo/
$ cd CentralRepo
$ git log

# 先在B上创建同名分支
$ git checkout -b dev1
# 拉取
$ git pull # 出错！
# 本地仓库中的分支与上游分支关联起来
$ git branch --set-upstream-to=origin/dev1 dev1
# 此时拉取就能成功了
$ git pull

#一般，"localBranchName"名称跟"remoteBranchName"名称设置成一样。
$ git checkout -b localBranchName origin/remoteBranchName

# B更新后，通过`git diff `查看B的更新
$ git diff
# 把diff的结果保存到一个文件中，生成一个patch
$ git diff > BPatch

# A通过`git apply`命令应用BPatch得到了B的更新
$ git apply BPatch
# 通过`git diff`查看B的更新
$ git diff

$ git format-patch origin/master

# 应用patch
$ git am 0001-update-calc.py.patch
# 再查看日志
$ git log

git push <远程主机名> <本地分支名>:<远程分支名>

git pull <远程主机名> <远程分支名>:<本地分支名>

git pull --rebase <远程主机名> <远程分支名>:<本地分支名>

$ git merge dev

#假设A上的更新是00abc3f
$ git cherry-pick 00abc3f

#include <QCoreApplication>
#include<QDebug>
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);

qDebug()<<"hello world";
return a.exec();
}

###basic application and HTML WIDEGTS
#include<QApplication>
#include<QLabel>
int main(int argc ,char *argv[])
{

QApplication app(argc, argv);
QLabel *label =new QLabel("Hello World");//显示Hello World
label->show();
return app.exec();
}

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
ui->pushButton->setText("close");
}

MainWindow::~MainWindow()
{
delete ui;
}

void Dialog::on_pushButton_clicked()
{

QMessageBox::information(this,"hello world","hello world");
}

void Dialog::on_pushButton_clicked()
{

//QMessageBox::information(this,"hello world","hello world");
ui->lineEdit->setText("Hello world!");
ui->lineEdit_2->setText("sssssss");
}

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
connect(ui->horizontalSlider,SIGNAL(valueChanged(int)),ui->progressBar,SLOT(setValue(int)));//添加信号
}

MainWindow::~MainWindow()
{
delete ui;
}

connect(ui->horizontalSlider,SIGNAL(valueChanged(int)),ui->progressBar_2,SLOT(setValue(int)));

disconnect(ui->horizontalSlider,SIGNAL(valueChanged(int)),ui->progressBar_2,SLOT(setValue(int)));

setCentralWidget(ui->plainTextEdit);//是文本框左右充满整个mainwindow

void MainWindow::on_actionNew_Window_triggered()
{

MyDialog dialog;

// dialog.setModal(true);
// dialog.exec();//显示Dialog(第一种显示方法)
dialog.show();这样直接是不好使的，dialog一闪就没

}

void MainWindow::on_actionNew_Window_triggered()
{
mydialog=new MyDialog(this);
mydialog->show();
}

#include<QApplication>
#include<QLabel>
int main(int argc ,char *argv[])
{

QApplication app(argc, argv);
QLabel *label =new QLabel("<b>Hello</b> <span color=\"red\" style=\"color: red;\"> <i>World</i></span>");//标签属性
label->show();
return app.exec();
//QLabel *label =new QLabel("</span>
<h2>Hello <span color="red" style="color: red;"> <i>World</i></font color =red></span></h2>
");标签可以随便加
}

#include<QApplication>
#include<QPushButton>
#include<QHBoxLayout>
#include<QVBoxLayout>
int main(int argc ,char *argv[])
{

QApplication app(argc, argv);
QWidget *window =new QWidget;//创建一个新的window
window->setWindowTitle("my app");//把window的title 设置为 my app
QPushButton *button1=new QPushButton("one");//button1名字为one
QPushButton *button2=new QPushButton("two");
QPushButton *button3=new QPushButton("three");
QHBoxLayout *layout=new QHBoxLayout;//创建一个水平布局变量
//QVBoxLayout *layout=new QVBoxLayout;//创建一个垂直布局变量
layout->addWidget(button1);
layout->addWidget(button2);
layout->addWidget(button3);
window->setLayout(layout);
window->show();
return app.exec();
}

#include<QApplication>
#include<QtGui>
#include<QtCore>

int main(int argc ,char *argv[])
{

QApplication app(argc, argv);
QWidget *window =new QWidget;
window->setWindowTitle("my app");
QGridLayout *layout=new QGridLayout;
QLabel *label=new QLabel("Name:");
QLineEdit *txtName=new QLineEdit;
layout->addWidget(label,0,0);
layout->addWidget(txtName,0,1);
window->setLayout(layout);
window->show();
return app.exec();
}

layout->addWidget(label2,1,0);//把名字改变就行，然后里面的参数也要改变
layout->addWidget(txtName2,1,1);

layout->addWidget(button,2,0,1,2);//行，列 ，上下宽度，左右长度

#include <QCoreApplication>
#include <QDebug>
#include <QDir>
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QDir m_dir("C:\\TEXT");
qDebug() << m_dir.exists();
return a.exec();
}

QDir m_dir;
QString m_path="C:\\3.txt";
if(!m_dir.exists(m_path))
{
QFile f(m_path);
f.open(QIODevice::WriteOnly);
f.close();
qDebug()<<"Created";

}
else
{

qDebug()<<"Already Exits";

}
QDir m_dir;
QString m_path="C:/";
m_dir.setPath(m_path);
foreach (QFileInfo m_Item, m_dir.entryInfoList())
{

qDebug()<<m_Item.absoluteFilePath();//为查看当前下的文件目录
}

void write(QString Filename)//文件写
{
QFile mFile(Filename);
if(!mFile.open(QFile::WriteOnly|QFile::Text))
{
qDebug()<<"could not open the file for writting";
return;
}
else
{
QTextStream out(&mFile);
out<<"Hello man!";
qDebug()<<"Write Correctly";

}
mFile.flush();
mFile.close();

}
void read(QString Filename)//文件读
{
QFile mFile(Filename);
if(!mFile.open(QFile::ReadOnly|QFile::Text))
{
qDebug()<<"could not open the file for writting";
return;
}
else
{
QTextStream in(&mFile);
QString s=in.readAll();
qDebug() << s;
qDebug() << "Read Correctly";
}
mFile.close();
}

QMessageBox::information(this,"hello world",ui->listWidget->currentItem()->text());
QListWidgetItem *item=ui->listWidget->currentItem();
item->setText("123");//选中当前项然后改变的文本
item->setForeground(Qt::red);//把当前文本变成红色

void AddRoot(QString name, QString Description);
void AddChild(QTreeWidgetItem *parent, QString name, QString Description);

ui->treeWidget->setColumnCount(2);
AddRoot("HELLO","WORLD");
AddRoot("2","3");
void Dialog::AddRoot(QString name ,QString Description)
{
QTreeWidgetItem *itm=new QTreeWidgetItem(ui->treeWidget);
itm->setText(0,name);
itm->setText(1,Description);
ui->treeWidget->addTopLevelItem(itm);//这如果删除会产生什么情况
AddChild(itm,"one","hello");
AddChild(itm,"two","world");
}
void Dialog::AddChild(QTreeWidgetItem *parent,QString name,QString Description)
{

QTreeWidgetItem *itm=new QTreeWidgetItem(ui->treeWidget//这如果删除会产生什么情况);
itm->setText(0,name);
itm->setText(1,Description);
parent->addChild(itm);
}

void Dialog::AddRoot(QString name, QString Description)
{
QTreeWidgetItem *itm=new QTreeWidgetItem(ui->treeWidget);
itm->setText(0,name);
itm->setText(1,Description);
ui->treeWidget->addTopLevelItem(itm);
AddChild(itm,"one","hello");
AddChild(itm,"two","world");
}

void Dialog::on_pushButton_clicked()
{

ui->treeWidget->currentItem()->setBackground(0, Qt::red);//设置第一排颜色为red
ui->treeWidget->currentItem()->setBackground(1, Qt::yellow);//设置第一排颜色为yellow

}

Dialog::Dialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::Dialog)
{
ui->setupUi(this);

ui->treeWidget->setColumnCount(2);
//ui->treeWidget->setHeaderLabel("123");
ui->treeWidget->setHeaderLabels(QStringList()<<"123"<<"456");
AddRoot("HELLO","WORLD");
AddRoot("2","3");
}
ui->treeWidget->setHeaderLabel("123");
ui->treeWidget->setHeaderLabels(QStringList()<<"123"<<"456");

public class Test1 {

final int A = 20;
public static void main(String[] args) {
Test1 test1 = new Test1();
System.out.println(test1.A);
}

}

public class Test1 {

static final int B = 20;
public static void main(String[] args) {
System.out.println(B);
}
}

public class Test2 {
public static void main(String[] args) {
int a = 30;
System.out.println(a++);
System.out.println(++a);
}
}

public class SearchArray
{
public static void main(String[] args)
{
int[] array = {2, 4, 6, 1, 3, 5, 9, 11, -5, 30, 100};
Arrays.sort(array);
int index = Arrays.binarySearch(array, 11);
System.out.println(Arrays.toString(array));
System.out.println("The index of 11 is "+index);
index = Arrays.binarySearch(array, 10);
System.out.println("The index of 10 is "+index);
}
}

public class StringBufferTest {

public static void main(String[] args) {

StringBuffer strbuf1 = new StringBuffer();
System.out.println(strbuf1.capacity());
System.out.println(strbuf1.length());
}
}

class overload {
// /一个普通的方法，不带参数
void test() {
System.out.println("No parameters");
}

// /重载上面的方法，并且带了一个整型参数
void test(int a) {
System.out.println("a: " + a);
}

// /重载上面的方法，并且带了两个参数
void test(int a, int b) {
System.out.println("a and b: " + a + " " + b);
}

// /重载上面的方法，并且带了一个双精度参数，与上面带一个参数的重载方法不一样
double test(double a) {
System.out.println("double a: " + a);
return a * a;
}

public static void main(String args[]) {
overload o = new overload(); //创建了对象o
o.test();
o.test(2);
o.test(2, 3);
o.test(2.0);
}
}

class People {
int a;

People() {
a = 1;
}

People(int a) {
this.a = a;
}
}

public class men extends People {
int b;

men(int a, int b) {
super(a);
this.b = b;
}

public static void main(String[] args) {
men m = new men(10, 20); //通过带参构造函数创建men类对象
System.out.println(m.a + " " + m.b); //调用对象的成员变量a和b
}
}

class Test3_super{
public Test3_super() {
// TODO 自动生成的构造函数存根
System.out.println("父类构造函数");
}
public void fun1(){
System.out.println("父类F1");
}
protected void fun2() {
System.out.println("父类F2");
}
private void fun3() {
System.out.println("父类F3");
}

}

public class Test3 extends Test3_super{

Test3(){
super();
System.out.println("子类构造函数");
}
public void fun2() {
System.out.println("子类F2");

}
public static void main(String[] args) {

Test3 test3 = new Test3();
test3.fun1();
test3.fun2();

}
}

package com.interfacetest;

interface Alarm {
void alarm();
}

class AlarmDoor implements Alarm {

void open() {
System.out.println("door open");
}
void close() {
System.out.println("door close");
}
public void alarm() {
System.out.println("a door with alarm");
}
}

public class InterfaceTest {

public static void main(String[] args) {

AlarmDoor alarmDoor = new AlarmDoor();
alarmDoor.alarm();
}
}

package com.interfacetest;

interface Alarm {
void alarm();
}

interface Window {
void window();
}

class AlarmDoor implements Alarm, Window {

public void window() {
System.out.println("a door with window");
}

public void alarm() {
System.out.println("a door with alarm");
}
}

public class InterfaceTest2 {

public static void main(String[] args) {

AlarmDoor alarmDoor = new AlarmDoor();
alarmDoor.alarm();
}
}

school sc = new student();

package com.interfacetest;

interface Lock {
void lock();
}

interface HighLock extends Lock{
void hignlock();
}

class Door implements HighLock {

@Override
public void hignlock() {
// TODO 自动生成的方法存根
System.out.println("WOW high lock");
}
@Override
public void lock() {
// TODO 自动生成的方法存根
System.out.println("just lock");
}
}

public class InterfaceTest3 {

public static void main(String[] args) {

Door door = new Door();
door.lock();
}
}

package com.interclass;

//外部类
class Out {
private int age = 12;

//内部类
class In {
public void print() {
System.out.println(age);
}
}
}

public class InterclassTest1 {
public static void main(String[] args) {

Out.In in = new Out().new In();
in.print();

Out out = new Out();
Out.In in2 = out.new In();
in2.print();

}
}

package com.interclass;

abstract class Person {
public abstract void eat();
}

class Child extends Person {
public void eat() {
System.out.println("eat something");
}
}

public class InterclassTest2 {
public static void main(String[] args) {
Person p = new Child();
p.eat();
}
}

package com.interclass;

abstract class Person1 {
public abstract void eat();
}

public class InterclassTest3 {
public static void main(String[] args) {
Person1 p = new Person1() {
public void eat() {
System.out.println("eat something");
}
};
p.eat();
}
}

public class Demo {
public static void main(String[] args) {
Thread t = new Thread() {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.print(i + " ");
}
}
};
t.start();
}
}

public class Demo {
public static void main(String[] args) {
Runnable r = new Runnable() {
public void run() {
for (int i = 1; i <= 5; i++) { System.out.print(i + " "); } } }; Thread t = new Thread(r); t.start(); } } ``` 内部类的好处： - 内部类的对象能够访问创建他的对象的所有方法和属性，包括私有数据 - 对于同一个包中的其他类来说，内部类是隐形的 。 - 匿名内部类可以很方便的定义回调 - 使用内部类可以方便的编写时间驱动的程序。 作为一个单独的类，只能有 `default` 和 `public` 两种访问控制符，但是作为内部类，可以使用 `private` 控制符。当内部类设置为 `private` 时，包含此内部类的外部类的方法才可以访问它。 ### 使用内部类来访问对象 内部类这个机制之所以出现，是因为存在如下两个目的： - 可以让程序中逻辑上相关的类结合在一起 - 内部类可以直接访问外部类的成员。 ## 常见疑难 接口与继承的区别： - 属性：接口中的所有属性都是公开静态常量，继承则无所谓 - 方法：接口中所有方法都是公开抽象方法，继承中所有方法不一定是抽象的 - 接口方法：接口没有构造器，继承有构造器 ## 抽象和封装 抽象就是讲拥有共同方法和属性的对象提取出来，提取后，重新设计一个更加通用、更加大众的类，这个类成为抽象类。 ### 抽象类 `abstract` 具有一个或多个抽象方法的类，本身就要被定义为抽象类。含有抽象方法的类一定是抽象类。 抽象类不仅可以有抽象方法，也可以又具体的方法，一个类中只要有一个抽象方法，就是抽象类。 抽象类中不一定含有抽象的方法，也可以全部都是具体的方法。 抽象类是可以继承的，如果子类没有实现抽象类的全部抽象方法，那么子类也是抽象类。如果实现了抽象类的全部抽象方法，那么子类就不是抽象类。 抽象类不可以被实例化。但是可以声明一个抽象类的变量指向具体子类的对象。 抽象类的好处在于，有的方法在父类中不想实现时，可以不用实现。 ```java package com.abstracttest; abstract class Door{ abstract void open(); abstract void close(); } class MyDoor extends Door{ @Override void open() { // TODO 自动生成的方法存根 System.out.println("i can open"); } @Override void close() { // TODO 自动生成的方法存根 System.out.println("i can close"); } } public class AbstractTest1 { public static void main(String[] args) { MyDoor myDoor = new MyDoor(); myDoor.close(); } } ``` ## 常见疑难 抽象与接口的区别： 共同点 - 都不能创建实例对象 - 可以声明变量，通过指向子类或实现类的对象类，来创建对象实例。 不同点 - Java 不支持多重继承，即一个子类只能有一个父类，但一个子类可以实现多个接口。 - 接口内不能有实例字段，只能有静态变量，抽象类可以拥有实例字段 - 接口内方法自动设置为 `public`的，抽象类中的方法必须手动声明访问控制符。 ## 枚举 `enum` ## 反射 程序自己能够检查自身信息。反射使得java语言具有了"动态性"，即程序首先会检查某个类中的方法、属性等信息，然后再动态的调用或动态的创建该类或该类的对象。 ### 反射类的基石 ――`Class`类 任何事物都可以用类表示，那么java中的类可以用一个什么类表示呢？ 从JDK1.2开始，就出现了Class类，该类描述Java中的一切事物，该类描述了关于类事务的类名字、类的访问属性、类所属的包名等。 ### 反射的基本应用 所谓反射就是把java类中的各种成分映射成相应的java类。 不仅java类，可以用`Class`类的对象表示，而java类的各种成员：成员变量、方法、构造方法、包等也可以用相应的类表示。 Java反射机制主要提供了以下功能： - 在运行时判断任意一个对象所属的类； - 在运行时构造任意一个类的对象； - 在运行时判断任意一个类所具有的成员变量和方法； - 在运行时调用任意一个对象的方法。 反射一般会设计如下类 ： - `Class` : 表示一个类的类 - `Field` : 表示属性的类 - `Method` ： 表示方法的类 - `Constructor` : 表示类的构造方法的类 > `Class`类位于java.lang包中，而后面3个的类都位于java.lang.reflect包中

编写Java反射程序的步骤：

- 必须首先获取一个类的Class对象
- 然后分别调用Class对象中的方法来获取一个类的属性/方法/构造方法的结构

现有一个类：

```java
package com.reflection;
public class TestReflection {

private String username;
private String password;
private int[] age;

public void setUserName(String username) {
this.username = username;
}

private void setPassWord(String password) {
this.password = password;
}
}
</code></pre>

获取一个类的Class对象：

<pre><code class="java">TestReflection tfReflection = new TestReflection();
Class c1 = TestReflection.class;
Class c2 = Class.forName("com.reflection.TestReflection");
Class c3 = tfReflection.getClass();
</code></pre>

获取指定的包名：

<pre><code class="java">String package01 = c1.getPackage().getName();
</code></pre>

获取类的修饰符:

<pre><code class="java">int mod = c1.getModifiers();
String modifier = Modifier.toString(mod);
</code></pre>

获取指定类的完全限定名：

<pre><code class="java">String className = c1.getName();
</code></pre>

获取指定类的父类:

<pre><code class="java">Class superClazz = c1.getSuperclass();
String superClazzName = superClazz.getName();
</code></pre>

获取实现的接口:

<pre><code class="java">Class[] interfaces = c1.getInterfaces();
for (Class t : interfaces) {
System.out.println("interfacesName = " + t.getName());
}
</code></pre>

获取指定类的成员变量:

<pre><code class="java">Field[] fields = c1.getDeclaredFields();
for (Field field : fields) {
modifier = Modifier.toString(field.getModifiers()); // 获取每个字段的访问修饰符
Class type = field.getType(); // 获取字段的数据类型所对应的Class对象
String name = field.getName(); // 获取字段名
if (type.isArray()) { // 如果是数组类型则需要特别处理
String arrType = type.getComponentType().getName() + "[]";
System.out.println("" + modifier + " " + arrType + " " + name + ";");
}
else {
System.out.println("" + modifier + " " + type + " " + name + ";");
}
}
</code></pre>

获取类的构造方法:

<pre><code class="java">Constructor[] constructors = c1.getDeclaredConstructors();
for (Constructor constructor : constructors) {
String name = constructor.getName(); // 构造方法名
modifier = Modifier.toString(constructor.getModifiers()); // 获取访问修饰符
System.out.println("" + modifier + " " + name + "(");
Class[] paramTypes = constructor.getParameterTypes(); // 获取构造方法中的参数
for (int i = 0; i < paramTypes.length; i++) { if (i > 0) {
System.out.print(",");
}
if (paramTypes[i].isArray()) {
System.out.println(paramTypes[i].getComponentType().getName() + "[]");
} else {
System.out.print(paramTypes[i].getName());
}
}
System.out.println(");");
}
</code></pre>

获取成员方法:

<pre><code class="java">Method[] methods = c1.getDeclaredMethods();
for (Method method : methods) {
modifier = Modifier.toString(method.getModifiers());
Class returnType = method.getReturnType(); // 获取方法的返回类型
if (returnType.isArray()) {
String arrType = returnType.getComponentType().getName() + "[]";
System.out.print("" + modifier + " " + arrType + " " + method.getName() + "(");
} else {
System.out.print("" + modifier + " " + returnType.getName() + " " + method.getName() + "(");
}
Class[] paramTypes = method.getParameterTypes();
for (int i = 0; i < paramTypes.length; i++) { if (i > 0) {
System.out.print(",");
}
if (paramTypes[i].isArray()) {
System.out.println(paramTypes[i].getComponentType().getName() + "[]");
} else {
System.out.print(paramTypes[i].getName());
}
}
System.out.println(");");
}
</code></pre>

反射调用方法，可以通过Method类的invoke方法实现动态方法的调用:

<code>public Object invoke(Object obj, Object... args)</code>
第一个参数代表对象
第二个参数代表执行方法上的参数

若反射要调用类的某个私有方法，可以在这个私有方法对应的Mehtod对象上先调用<code>setAccessible(true)</code>

<pre><code class="java">public static void test02() throws InstantiationException, IllegalAccessException, SecurityException,
NoSuchMethodException, IllegalArgumentException, InvocationTargetException {

Class c1 = TestReflection.class;
TestReflection t1 = (TestReflection) c1.newInstance(); // 利用反射来创建类的对象

Method method = c1.getDeclaredMethod("setUserName", String.class);
method.invoke(t1, "Java反射的学习");
method = c1.getDeclaredMethod("setPassWord", String.class);
method.setAccessible(true);
method.invoke(t1, "反射执行某个Private修饰的方法");

}

</code></pre>

<h3>反射的一些应用</h3>

既然String是不可变字符串对象，如何才能改变让其可变?[反射的一些应用][1]

<pre><code class="java">public static void stringReflection() throws Exception {

String s = "Hello World";

System.out.println("s = " + s); //Hello World

//获取String类中的value字段
Field valueField = String.class.getDeclaredField("value");

//改变value属性的访问权限
valueField.setAccessible(true);

char[] value = (char[]) valueField.get(s);

//改变value所引用的数组中的第5个字符
value[5] = '_';

System.out.println("s = " + s); //Hello_World
}
</code></pre>

既然String对象中没有对外提供可用的public setters等方法，因此只能通过Java中的反射机制实现。因此，前文中说到的String是不可变字符串对象只是针对"正常情况下"。而非必然。

<blockquote>
  Java的反射机制的概念：
  在Java运行时环境中，对于任意一个类，能否知道这个类的哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java语言的反射(Reflection)机制。
  
  Reflection是Java被视为动态(准动态)语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括modifiers(诸如static、public等等)、superclass(例如Object)、实现interfaces(例如Serializable)，也包括fields和methods的所有信息，并可于运行时改变fields内容或调用methods。
</blockquote>

<h2>标注 Annotation</h2>

在实际的应用中期可以部分或全部的取代传统的XML等部署描述文件。之所以要出现标注特性，是因为部署描述文件很复杂，在具体编写时很容易出错。

<h3>标注的简单使用</h3>

<code>@SuppressWarnings</code>

<pre><code class="java">public class SimpleAnnotation {
@SuppressWarnings("deprecation")
public static void main(String[] args) {
System.runFinalizersOnExit(true);
}
}
</code></pre>

<h3>几个简单的内置标注</h3>

<code>@Override</code>

<pre><code class="java">package com.Annotation;

class People{
public String toString() {
return "people name";
}
}

class Student extends People{
@Override
public String toString() {
return "student name";

}
}
public class Annotation_Test {
public static void main(String[] args) {
Student student = new Student();
System.out.println(student.toString());
}

}
</code></pre>

<blockquote>
  <code>@Override</code> 是方法标注，只能作用于方法，在覆盖父类方法却又写错了方法名的时候发挥作用。
</blockquote>

<code>@Deprecated</code>

很多时候，设计了一个包含<code>sayHello()</code>方法的类<code>Hello.java</code>，但是经过一段时间发现，<code>sayHello1()</code>可以更好更快的实现相同的功能。但是这个时候如果去掉方法<code>sayHello()</code>，那么调用该方法的类就会出现错误。为了兼容之前的类，而又不建议新设计的类使用方法<code>sayHello()</code>，就需要把<code>Hello.java</code>中的方法<code>sayHello()</code>做<code>@Deprecated</code>标注。

<pre><code class="java">package com.Annotation;

class Hello{

@Deprecated
public void sayHello(){
System.out.println("已经过时的方法");
}
public void sayHello1() {
System.out.println("现在的方法");
}
}
public class Deprecated_Test {
public static void main(String[] args) {
Hello hello = new Hello();
hello.sayHello();
hello.sayHello1();

}

}
</code></pre>

当一个类或者类成员使用<code>@Deprecated</code>修饰的话，编译器将不鼓励使用这个被标注的程序元素，而且这种修饰具有一定的"延续性"，即在代码中通过继承或者覆盖使用了这个过时的类型或者成员，虽然继承或者覆盖后的类型并不是被声明为<code>@Deprecated</code>，但是编译器仍要报警。

<blockquote>
  <code>@Deprecated</code>标注不仅可以用在方法前面，而且可以用在参数或类的前面。
</blockquote>

<code>@SuppressWarnings</code>

可以用作标注类，属性、方法等成员，主要用于屏蔽警告。该标注于前面两个标注最大不同点在于其带有参数，并且参数可以是一个，可以是多个。参数的值为警告的类型。如：

<ul>
<li>已过时的警告 ： deprecation</li>
<li>没有使用警告 ： unused</li>
<li>类型不安全警告 ： unchecked</li>
</ul>

<blockquote>
  当<code>@SuppressWarnings</code> 接收的参数为多个值得时候，必须使用数组的方式为参数赋值。例如@SuppressWarnings({"deprecation","unused","unchecked"})
</blockquote>

<h2>泛型 <code><E></code></h2>

所谓泛型，其本质就是实现参数化类型，也就是说所操作的数据类型被指定为一个参数。

<h3>泛型概念的提出:</h3>

<pre><code class="java">public class GenericTest {

public static void main(String[] args) {
List list = new ArrayList();
list.add("qqyumidi");
list.add("corn");
list.add(100);

for (int i = 0; i < list.size(); i++) { String name = (String) list.get(i); // 1 System.out.println("name:" + name); } } } ``` 运行结果 name:qqyumidi name:corn Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String at com.fan.GenericTest.main(GenericTest.java:15) > Java2的集合框架，抽其核心，主要有三种：List、Set和Map。
需要注意的是，这里的 Collection、List、Set和Map都是接口(Interface)，不是具体的类实现。 List lst = new ArrayList(); 这是我们平常经常使用的创建一个新的List的语句，在这里， List是接口，ArrayList才是具体的类。
常用集合类的继承结构如下：
Collection<--List<--Vector
Collection<--List<--ArrayList
Collection<--List<--LinkedList
Collection<--Set<--HashSet
Collection<--Set<--HashSet<--LinkedHashSet
Collection<--Set<--SortedSet<--TreeSet
Map<--SortedMap<--TreeMap
Map<--HashMap

定义了一个List类型的集合，先向其中加入了两个字符串类型的值，随后加入一个Integer类型的值。这是完全允许的，因为此时list默认的类型为Object类型。在之后的循环中，由于忘记了之前在list中也加入了Integer类型的值或其他编码原因，很容易出现类似于//1中的错误。因为编译阶段正常，而运行时会出现"java.lang.ClassCastException"异常。因此，导致此类错误编码过程中不易发现。

在如上的编码过程中，我们发现主要存在两个问题：

1.当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。

2.因此，//1处取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现"java.lang.ClassCastException"异常。

那么有没有什么办法可以使集合能够记住集合内元素各类型，且能够达到只要编译时不出现问题，运行时就不会出现"java.lang.ClassCastException"异常呢？答案就是使用泛型。

### 什么是泛型？

泛型，即"参数化类型"。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式(可以称之为类型形参)，然后在使用/调用时传入具体的类型(类型实参)。

```java
public class GenericTest {

public static void main(String[] args) {
/*
List list = new ArrayList();
list.add("qqyumidi");
list.add("corn");
list.add(100);
*/

List<String> list = new ArrayList<String>();
list.add("qqyumidi");
list.add("corn");
//list.add(100); // 1 提示编译错误

for (int i = 0; i < list.size(); i++) {
String name = list.get(i); // 2
System.out.println("name:" + name);
}
}
}

package com.threadtest;

class ThreadTest implements Runnable {
public void run() {
System.out.println("thread 1");
}
}
class ThreadTest2 implements Runnable{
public void run() {
System.out.println("thread 2");
}
}
public class ThreadTest1 {
public static void main(String[] args) {
ThreadTest test = new ThreadTest();
ThreadTest2 test2 = new ThreadTest2();
Thread thread = new Thread(test);
Thread thread2 = new Thread(test2);
thread.start();
thread2.start();
}

}

package com.threadtest;

class Threadtest_3 extends Thread {
public void run() {
System.out.println("thread 1");

}
}
class ThreadTest_4 extends Thread{
public void run() {
System.out.println("thread 2");

}
}
public class ThreadTest2 {
public static void main(String[] args) {
Threadtest_3 threadtest_3 =new Threadtest_3();
ThreadTest_4 threadTest_4 = new ThreadTest_4();

Thread thread3 = new Thread(threadtest_3);
Thread thread4 = new Thread(threadTest_4);

thread3.start();
thread4.start();

}
}

package com.threadtest;

class Threadtest_3 extends Thread {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(i);
}

}
}
class ThreadTest_4 extends Thread{
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("hello"+ i);
}

}
}
public class ThreadTest2 {
public static void main(String[] args) {

Threadtest_3 threadtest_3 =new Threadtest_3();
ThreadTest_4 threadTest_4 = new ThreadTest_4();

Thread thread3 = new Thread(threadtest_3);
Thread thread4 = new Thread(threadTest_4);

thread3.setPriority(3);
thread4.setPriority(Thread.MIN_PRIORITY);

thread3.start();
thread4.start();

}
}

package com.cjgong.avd;
///这是一个主运行类
///创建一个线程对象，让其运行
public class thread5
{
public static void main(String[] args)
{
compute27 t=new compute27();
t.start();
}
}
///创建一个线程类，在这个类中，通过休眠来输出不同结果
class compute27 extends Thread
{
int i=0;
public void run()
{
System.out.println("在工作中，不要打扰");
try
{
sleep(1000000);
}
catch(Exception e)
{
System.out.println("哦，电话来了");
}
}
}

package com.cjgong.avd;
public class thread6
{
public static void main(String[] args)
{
compute28 t=new compute28();
t.start();
t.interrupt();
}
}
///创建一个线程类，在这个类中，通过休眠，让线程运行输出不同的结果
class compute28 extends Thread
{
int i=0;
public void run()
{
System.out.println("在工作中，不要打扰");
try
{
sleep(1000000);
}
catch(Exception e){System.out.println("哦，电话来了");}
}
}

package com.cjgong.avd;
///这是一个主运行类
///在主运行方法中，通过创建两个线程对象，让其交替执行
public class thread7
{
public static void main(String[] args)
{
compute29 t=new compute29();
compute30 t1=new compute30();
t.start();
t1.start();
}
}
///创建一个线程类
///通过循环语句来输出十个整型数据
///通过让步程序让此线程停止运行
class compute29 extends Thread
{
int i=0;
public void run()
{
for(int i=0;i<10;i++)
{
System.out.println(i);
yield();
}
}
}
///创建一个线程类
///通过循环语句来输出说明语句
class compute30 extends Thread
{
public void run()
{
for(int i=0;i<10;i++)
{
System.out.println("这个数字是:"+i);
}
}
}

package com.cjgong.avd;
//这是一个主运行类
///在主运行方法中，通过创建两个线程对象，让其交替执行
public class thread8
{
public static void main(String[] args)
{
compute31 t=new compute31('a');
compute31 t1=new compute31('b');
t.start();
t1.start();
}
}
///创建一个线程类
///在这线程类中，使用循环语句输出字符
class compute31 extends Thread
{
char ch;
compute31(char ch)
{
this.ch=ch;
}

public void run()
{
for(int i=0;i<10;i++)
{
System.out.print(ch);
}
}
}

package com.cjgong.avd;
//这是一个主运行类
///在主运行方法中，通过创建两个线程对象，让其交替执行
public class thread8
{
public static void main(String[] args)
{
compute31 t=new compute31('a');
compute31 t1=new compute31('b');
t.start();
t1.start();
}
}
///创建一个线程类
///在这线程类中，使用循环语句输出字符
class compute31 extends Thread
{
char ch;
static Object bObject = new Object();
compute31(char ch)
{
this.ch=ch;
}

public void run()
{
synchronized (bObject) {

for(int i=0;i<10;i++) { System.out.print(ch); } } } } ``` ### 同步化方法 同步化方法就是对整个方法进行同步： 结构如下： synchronized void f() { 代码 } ```java //这是一个主运行类 ///在主运行方法中，通过创建三个线程对象，让其交替执行 public class thread11 { public static void main(String[] args) { compute34 t=new compute34(); new Thread(t).start(); new Thread(t).start(); new Thread(t).start(); } } ///创建一个线程类 ///在这线程类中，使用循环语句输出字符 ///在run方法中，使用同步块来给线程加一把锁 class compute34 extends Thread { int i=10; static Object obj=new Object(); public void print() { System.out.println(Thread.currentThread().getName()+":"+i); i--; } public void run() { while(i>0) { synchronized(obj) { print(); } try { sleep(1000); } catch(Exception e){} } } } ``` ## 异常的处理和内存管理 ## Java 输入和输出 Java程序类库中包含大量的输入输出类，提供不同情况的不同功能。其中包括： - 关于文件操作的类 `File` - 关于以字节方式访问文件的类 `InputStream`和类`OutStream` - 关于以字符方式访问文件的类`Reader`和类`Writer` > 在编写程序的过程中，若是要使用输入输出类的方法和属性值，就需要引入`java.io`类

## Java 的I/O操作

Java中I/O操作主要是指使用Java进行输入，输出操作.

Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。

总结的基本概念如下：

数据流：

一组有序，有起点和终点的字节的数据序列。包括输入流和输出流。

输入流：

程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…)，即是将数据源读入到程序的通信通道

输出流：

程序向输出流写入数据。将程序中的数据输出到外界(显示器、打印机、文件、网络…)的通信通道。

采用数据流的目的就是使得输出输入独立于设备。

数据流分类：

流序列中的数据既可以是未经加工的原始二进制数据，也可以是经一定编码处理后符合某种格式规定的特定数据。因此Java中的流分为两种：
1) 字节流：数据流中最小的数据单元是字节
2) 字符流：数据流中最小的数据单元是字符， Java中的字符是Unicode编码，一个字符占用两个字节。

### 标准I/O

### java.IO层次体系结构

在整个Java.io包中最重要的就是5个类和一个接口。

5个类指的是`File`、`OutputStream`、`InputStream`、`Writer`、`Reader`；

1个接口指的是`Serializable`.

掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了。

主要的类如下：

File(文件特征与管理)：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。
InputStream(二进制格式操作)：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。
OutputStream(二进制格式操作)：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。

Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。

Reader(文件格式操作)：抽象类，基于字符的输入操作。
Writer(文件格式操作)：抽象类，基于字符的输出操作。
RandomAccessFile(随机文件操作)：它的功能丰富，可以从文件的任意位置进行存取(输入输出)操作。

### 文件或目录信息的处理 `File`

`File` 类提供了与文件或目录相关的信息

文件处理方法：

```java
package com.filetest;

import java.io.File;

public class FileTest1 {
public static void main(String[] args) {

File file = new File("d:\\","file.txt");
System.out.println(file.getName());
System.out.println(file.getParent());
System.out.println(file.getPath());
}
}

package com.cjgong.chaozuo;

import java.io.*;

///通过print方法来判断这个文件类对象的性质
///通过print1方法来获取文件对象的信息
///通过print2方法来获取文件对象的信息
public class file1 {
public void print(File f) {
//通过print方法来判断这个文件类对象的性质
if (f.isDirectory()) {
//判断f对象是否为目录
System.out.println("这是一个目录！");
} else {
System.out.println("这不是一个目录！");
}
if (f.exists()) {
//判断f对象是否存在
System.out.println("这个文件存在的！");
} else {
System.out.println("抱歉，这个文件不存在的！");
try {
f.createNewFile();
//当文件不存在时，创建一个文件
} catch (Exception e) {
}
}
}

public void print1(File f) {
//通过print1方法来获取文件目录对象的信息
System.out.println(f.getName());
System.out.println(f.getParent());
System.out.println(f.getPath());
}

public void print2(File f) {
//通过print2方法来获取文件对象的信息
if (f.isFile()) {
System.out.println(f.lastModified());
System.out.println(f.length());
}
}

public static void main(String[] args) {
file1 f1 = new file1(); //创建一个f1对象
File f = new File("d:\\filetest");
//调用相应的方法
f1.print(f);
f1.print1(f);
f1.print2(f);
}
}