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) {
Person p = new Person() {
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` : 表示一个类的类 - `Filed` : 表示属性的类 - `Method` ： 表示方法的类 - `Constructor` : 表示类的构造方法的类 &gt; `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>@SuppressWarning</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>@SuppressWarning</code>

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

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

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

<h2>泛型 <code>&lt;E&gt;</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) &gt; Java2的集合框架，抽其核心，主要有三种：List、Set和Map。
需要注意的是，这里的 Collection、List、Set和Map都是接口（Interface），不是具体的类实现。 List lst = new ArrayList(); 这是我们平常经常使用的创建一个新的List的语句，在这里， List是接口，ArrayList才是具体的类。
常用集合类的继承结构如下：
Collection&lt;--List&lt;--Vector
Collection&lt;--List&lt;--ArrayList
Collection&lt;--List&lt;--LinkedList
Collection&lt;--Set&lt;--HashSet
Collection&lt;--Set&lt;--HashSet&lt;--LinkedHashSet
Collection&lt;--Set&lt;--SortedSet&lt;--TreeSet
Map&lt;--SortedMap&lt;--TreeMap
Map&lt;--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 提示编译错误</string></string>

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

public class GenericTest1 {

public static void main(String[] args) {

Box<string> name = new Box<string>("corn");
Box<integer> num = new Box<integer>(4);
System.out.println("name:" + name.getData());
System.out.println("num:" + num.getData());
}</integer></integer></string></string>

}

class Box<t> {</t>

private T data;

public Box() {

}

public Box(T data) {
this.data = data;
}

public T getData() {
return data;
}
}

public class GenericTest {

public static void main(String[] args) {

Box<string> name = new Box<string>("corn");
Box<integer> age = new Box<integer>(712);</integer></integer></string></string>

System.out.println("name class:" + name.getClass()); // com.qqyumidi.Box
System.out.println("age class:" + age.getClass()); // com.qqyumidi.Box
System.out.println(name.getClass() == age.getClass()); // true

}

}

public class GenericTest {

public static void main(String[] args) {

Box<number> name = new Box<number>(99);
Box<integer> age = new Box<integer>(712);</integer></integer></number></number>

getData(name);
getData(age); // 1

}

public static void getData(Box<number> data){
System.out.println("data :" + data.getData());
}</number>

}

public class GenericTest {

public static void main(String[] args) {

Box<string> name = new Box<string>("corn");
Box<integer> age = new Box<integer>(712);
Box<number> number = new Box<number>(314);</number></number></integer></integer></string></string>

getData(name);
getData(age);
getData(number);
}

public static void getData(Box<?> data) {
System.out.println("data :" + data.getData());
}

}

public class GenericTest {

public static void main(String[] args) {

Box<string> name = new Box<string>("corn");
Box<integer> age = new Box<integer>(712);
Box<number> number = new Box<number>(314);</number></number></integer></integer></string></string>

getData(name);
getData(age);
getData(number);

//getUpperNumberData(name); // 1
getUpperNumberData(age); // 2
getUpperNumberData(number); // 3
}

public static void getData(Box<?> data) {
System.out.println("data :" + data.getData());
}

public static void getUpperNumberData(Box<? extends Number> data){
System.out.println("data :" + data.getData());
}

}

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;

import org.omg.CORBA.PUBLIC_MEMBER;

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&gt;0) { synchronized(obj) { print(); } try { sleep(1000); } catch(Exception e){} } } } ``` ## 异常的处理和内存管理 ## Java 输入和输出 Java程序类库中包含大量的输入输出类，提供不同情况的不同功能。其中包括： - 关于文件操作的类 `File` - 关于以字节方式访问文件的类 `InputStream`和类`OutStream` - 关于以字符方式访问文件的类`Reader`和类`Writer` &gt; 在编写程序的过程中，若是要使用输入输出类的方法和属性值，就需要引入`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);
}
}

import java.io.*;

///创建一个文件类f
///创建一个输入流对象fis，并且以f作为参数
///使用循环语句将文本文件中的字符读出
public class file3 {
public static void main(String[] args) throws Exception {
File f = new File("d:\\filetest\\file.txt");
//创建一个文件类f
FileInputStream fis = new FileInputStream(f);
//创建对象f的文件输入流
char ch;
//声明一个字符串对象ch
for (int i = 0; i < f.length(); i++) {
//通过循环读取文件类f所对应的文件
ch = (char) fis.read();
System.out.print(ch);
}
fis.close();
}
}

import java.io.*;

///创建一个文件类f
///创建一个输入流对象fis，并且以f作为参数
///将所有的字节都保存到一个字节数组b中。
///使用循环语句将b中的字符读出
public class file4 {
public static void main(String[] args) throws Exception {
File f = new File("d:\\filetest\\file.txt");
//创建一个文件类f
FileInputStream fis = new FileInputStream(f);
//创建一个输入流对象fis，并且以f作为参数
byte[] b = new byte[(int) f.length()];
//创建一个字节数组对象b
fis.read(b);
//读取到的内容存储到字节数组对象b
for (int i = 0; i < f.length(); i++) {
//通过循环输出相应内容
System.out.print((char) b[i]);
}
fis.close();
}
}

public class file1 {
public static void main(String[] args) {
int x = 12; //创建一个整形类型变量x
String str = "13579"; //创建一个字符串类型变量str
//把变量x，str转换成对象类型t1和t2
Integer t1 = new Integer(x);
Integer t2 = new Integer(str);
//通过tostring()把对象转换成字符串。
System.out.println(t1);
System.out.println(t2);
}
}

>>> 100+200
300

>>> print('hello, world')
hello, world

>>> print('hello, world')

>>> print('The quick brown fox', 'jumps over', 'the lazy dog')
The quick brown fox jumps over the lazy dog

>>> print(300)
300
>>> print(100 + 200)
300

>>> print('100 + 200 =', 100 + 200)
100 + 200 = 300

>>> name = input()
Michael
name = input()
print('hello,', name)

>>> True
True
>>> False
False
>>> 3 > 2
True
>>> 3 > 5
False

>>> True and True
True
>>> True and False
False
>>> False and False
False
>>> 5 > 3 and 3 > 1
True

>>> not True
False
>>> not False
True
>>> not 1 > 2
True

if age >= 18:
print('adult')
else:
print('teenager')

>>> 10 / 3
3.3333333333333335

>>> 9 / 3
3.0

>>> 10 // 3
3

>>> print('包含中文的str')
包含中文的str

>>> ord('A')
65
>>> ord('中')
20013
>>> chr(66)
'B'
>>> chr(25991)
'文'

>>> len('ABC')
3
>>> len('中文')
2

>>> len(b'ABC')
3
>>> len(b'\xe4\xb8\xad\xe6\x96\x87')
6
>>> len('中文'.encode('utf-8'))
6

>>> 'Hello, %s' % 'world'
'Hello, world'
>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'

>>> 'Age: %s. Gender: %s' % (25, True)
'Age: 25. Gender: True'

>>> 'growth rate: %d %%' % 7
'growth rate: 7 %'

>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']

>>> len(classmates)
3

>>> classmates[0]
'Michael'
>>> classmates[1]
'Bob'
>>> classmates[2]
'Tracy'
>>> classmates[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
​```</module></stdin>

如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：

​```python
>>> classmates[-1]
'Tracy'

>>> classmates[-2]
'Bob'
>>> classmates[-3]
'Michael'
>>> classmates[-4]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
​```</module></stdin>

list是一个可变的有序表，所以，可以往list中追加元素到末尾：
​```python
>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']

>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4

>>> classmates = ('Michael', 'Bob', 'Tracy')

>>> t = (1, 2)
>>> t
(1, 2)

>>> t = ()
>>> t
()

>>> t = (1)
>>> t
1

>>> t = (1,)
>>> t
(1,)

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

age = 20
if age >= 18:
print('your age is', age)
print('adult')

age = 3
if age >= 18:
print('adult')
elif age >= 6:
print('teenager')
else:
print('kid')

names = ['Michael', 'Bob', 'Tracy']
for name in names:
print(name)

sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
sum = sum + x
print(sum)

sum = 0
for x in range(101):
sum = sum + x
print(sum)

names = ['Michael', 'Bob', 'Tracy']
scores = [95, 75, 85]

``
如果用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。用Python写一个dict如下：
​```python
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

>>> d['Adam'] = 67
>>> d['Adam']
67

>>> d['Jack'] = 90
>>> d['Jack']
90
>>> d['Jack'] = 88
>>> d['Jack']
88

>>> 'Thomas' in d
False

>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}

>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}

>>> s.remove(4)
>>> s
{1, 2, 3}

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']

>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'

>>> abs(100)
100
>>> abs(-20)
20
>>> abs(12.34)
12.34

>>> max(1, 2)
2
>>> max(2, 3, 1, -5)
3

>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False

>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1

def my_abs(x):
if x >= 0:
return x
else:
return -x

import math

def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny

>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print(x, y)
151.96152422706632 70.0

def power(x):
return x * x

>>> power(5)
25
>>> power(15)
225

def power(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s

>>> power(5, 2)
25
>>> power(5, 3)
125

def fact(n):
if n==1:
return 1
return n * fact(n - 1)

>>> fact(1)
1
>>> fact(5)
120
>>> fact(100)
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

def fact(n):
return fact_iter(n, 1)

def fact_iter(num, product):
if num == 1:
return product
return fact_iter(num - 1, num * product)