JAVA基础

int []a = new int[10];

char [] a = new char[10];

String a = new String("abcd");

int []a = new int[]{1, 2, 3};

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

int [][]b = new int [10][];

for(int i=0; i<b.length; i++){

b[i] = new int[i+1]; //为各行分配内存空间

for(j=0; j<b[i].length; j++){

b[i][j] = i*j + 2; //为行的数据赋值

}

}

int []a = {1, 2, 3};

for(int i=0; i<10; i++){

a[i] = 表达式（其中有i参与）;

}

d:

dir 列出这个磁盘中有哪些文件；列出这个文件夹中有哪些文件

md 文件夹名 创建一个文件夹

cd 文件夹名 进入到某个文件夹

cd..返回上一级文件夹路径

cd/ 返回根目录

rd 删除某个文件夹

JAVA_HOME: C:\Program Files\Java\jdk1.7.0_17

PATH: 继续添加 C:\Program Files\Java\jdk1.7.0_17\bin

CLASSPATH: .;%JAVA_HOME%;%JAVA_HOME%\lib\tools.jar

javac

java -version

编译：javac www.java

运行：java www.class

数据类型：

基本数据类型：byte/short/int/long/float/double(数值型) char(字符型) boolean(布尔型)

引用数据类型：字符窜、数组、类、接口、枚举型

byte short char 之间不进行强转

switch(byte/short/int/char/enum/String参数){

case 常量1: break;

case 常量2: break;

................

default: break;

}

面向对象的三大特征：

封装(private)、

继承(extends)、

多态(

Father father = new Son son();

father.sonOverrideFunction();//父类访问子类重写的构造方法（虚拟方法调用）

Son son = (Son)father;

son.sonNotOverrideFuncion();//父类访问子类非重写的构造方法（强转）

)

在同一个类中，函数名称相同，但是形参的个数 或 类型不同的，

称为：方法的重载

public void aaa(int a, int b){};

public void aaa(int a, int b, int c){};

public void aaa(double a, double b){};

构造方法的重载：

public Student(int stuAge, String stuName){

this.age = stuAge;

this.name = stu.Name;

}

public Student(int stuAge, String stuName, int stuGrade){

this.age = stuAge;

this.name = stu.Name;

this.grade = stu.stu.Grade;

}

this关键字：当前类对象的一个引用

public Student(int stuAge, String stuName){

this.age = stuAge;

this.name = stu.Name;

}

public Student(int stuAge, String stuName, int stuGrade){

this(age, stuName); //this调用重载的构造方法

this.grade = stu.stuGrade;

}

导入核心类：import java.lang.*;

导入工具类：import java.util.*;

导入输入输出类：import java.io.*;

导入网络有关类：import java.net.*;

private(只在当前类中使用)

public(使用范围最广，既可跨包，也可跨类)

protected(只在继承关系的类之间使用，即可跨包，也可跨类)

default(不能跨包，但可跨类)

@Override

方法的重写：（名称、类型、参数）要都相同，修饰符可以不同，但要有更大的访问权限

protected String getInfo(){

System.out.println(age + name);

}

@Override

public String getInfo(){

System.out.println(age + name + grade);

}

super: 在继承的关系中，子类中使用对父类对象的引用

public class Person{

public Person(int page, String pname){

this.age = page;

this.name = pname;

}

public void aaa(){};

}

public class Student extends Person{

public Student(int stuAge, String stuName, int stuGrade){

super(age, name);

this.grade = stuGrade;

}

boolean a = x instanceof A: x是A类的对象或x是A类的子类的对象

Object 类： 是所有类的根父类

String a = "abc";

String b = "abc";

boolean ww = a.equals(b);

System.out.println(ww); //ww是true

String str1 = new String("abc");

String str2 = new String("abc");

boolean ww = str1.equals(str2);

System.out.println(ww); //ww是false

Object根父类中有equals（）方法

可以重写方法

@Override

public boolean equals(Object obj) {

if(this==obj){

return true;

}

else if(obj instanceof MyDate){

MyDate myDate = (MyDate)obj;

return (this.year==myDate.year&&this.month==myDate.month&&this.day==myDate.day);

}else{

return false;

}

}

如果遇到比较大小的话，先要在包里面创建一个接口CompareObject：

package com.atguigu.javase.lesson5.ex;

public interface CompareObject {

int CompareTo(Object o);

}

然后在包的其他的某个类A中 实现CompareObject接口， ( implements CompareObject )

@Override

public int CompareTo(Object obj) {

if(obj instanceof Circle){

Circle c = (Circle)obj;

return (int)(this.radius-c.getRadius());

}else{

return 0;

}

}

其实这一步可以直接用“匿名内部类对象”的方式：

在其他类C中：

CompareObject compareObject = new CompareObject() {

@Override

public int compareTo(Object o1, Object o2) {

if(o1 instanceof C && o2 instanceof C){

C c1 = (C)o1;

C c2 = (C)o2;

return (c1.getRadius()-c2.getRadius());

}

}

};

Comparator是用在集合里面进行排序的

Comparator comparator = new Comparator() {

@Override

public int compare(Object o1, Object o2) {

if(o1 instanceof Person1 && o2 instanceof Person1){

Person1 p1 = (Person1)o1;

Person1 p2 = (Person1)o2;

return (p1.getAge()-p2.getAge());

}

throw new ClassCastException("不能转为Person1类型");

}

};

就可以在其他类C中使用A类的CompareTo()方法了

A a = new A();

a.某个属性的set方法();

A b = new A();

b.某个属性的set方法();

boolean c = a.compareTo(b);

System.out.println(c);

包装类（封装类）：都是静态类

int Integer

long Long

double Double

short Short

float Float

char Character

boolean Boolean

byte Byte

在建立一个类中，标配：

成员属性，get() set()方法，toString()方法，hashCode()方法，有参构造器，无参构造器

单子模式：某个类只能存在一个对象实例

public class Single {

// 1、在类的外部不能有new构造器的方式创建实例.

//把构造器私有化

private Single(){}

// 2、在类的外部不能创建构造器，那就只能在类的内部创建构造器

// 3、为了让外部都可以使用该实例，使用static修饰

// 4、不能在类的外部修改该属性，就必须将这个属性私有化private，只好提供公有的get方法去访问

private staticSingle instance = new Single();

public static Single getInstance() {

return instance;

}

public static void setInstance(Single instance) {

Single.instance = instance;

}

}

外部访问：

Single s1 = Single.getInstance();

Static关键字：

package com.java.atguigu.lesson5;

public class Chinese {

private static String country;

private String name;

private int age;

public Chinese(String country, String name, int age) {

super();

Chinese.country = country;

this.name = name;

this.age = age;

}

public String getCountry() {

return country;

}

public void setCountry(String country) {

Chinese.country = country;

}

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;

}

@Override

public String toString() {

return "Chinese [country=" + country + ", name=" + name + ", age=" + age + "]";

}

}

static方法里面不能有super和this关键字

static静态方法只能访问static静态成员，如果想要访问非静态方法的话，就要用new 一个对象然后去访问才行 public static void main(String []args)

public static void main(String []args){

int i = Integer.parseInt(args[0]); arg[0]、arg[1]:命令行参数

int j = Integer.parseInt(arg[1]);

Person p = new Person();

person.getInfo(){

}

int result = ecm(1,2);

}

public static void ecm(int i, int j){

.......

}

你好，我觉得一句话就能说清楚，说的多了，反而让你理解的更加模糊。记住这点：

静态方法是属于类的，而普通方法是属于对象的。

属于类的静态方法可以在对象不存在的时候就能访问到，而普通方法必须先new一个对象才能用这个对象访问。当我们访问调用静态方法的时候（使用类名.静态方法名）这个时候就没有对象创建，所以普通方法是访问不到的。为了避免这种错误，所以java就不允许在静态方法中访问非静态方法。

还有纠正你的错误，main方法也满足我上面说的，你仔细看下，main方法中是不是先创建的对象，然后用对象去访问的呀。

如果不希望类的属性和方法不因为对象的不同而发生改变时，就要设置为类的静态属性和静态方法

认清静态代码块和非静态代码块：

int age;

{

age = 26;---------------------------非静态代码块

}

public static int total;

static{

total = 100;----------------------------静态代码块

}

abstract抽象类和抽象方法：

有抽象方法的类一定是抽象类

抽象类中不一定要有抽象方法

抽象类不能被实例化

abstract class

abstract int aaa();----无方法体

以下错误：

abstract private--------------私有成员和函数不能抽象

abstract Custom(){}-------------构造器不能抽象

abstract static int aaa(){}-----------静态方法不能抽象

abstract static int b-------------成员不能抽象

abstract int aaa(){}------------抽象方法无方法体

interface接口（里面只有抽象方法和常量，而且无构造器）

一个类只能有一个父类，但可以有很多的接口

public class OrderDao implements BaseDao1,BaseDao2{

@Override

...

@Override

...

}

public abstract class OrderDao implements BaseDao1,BaseDao2{

@Override

...

少了些方法的重载

}

类是可以实现接口的（implements），一个类可以有多个接口，但一个类只能有一个父类，

public class OrderDaoextends BaseDaoImpl implements Dao,Test

接口和接口之间是可以继承的

package com.atguigu.javase.lesson5;

public interface BaseDao extends Dao{

Object getSingleInstance();

}

输出时间中的年/月、日

Calender calender = Calender.getInstance();

String curentTime = calender.get(Calender.Month)+1;

不用的版本如下

Date currentTime = new Date();

String currentDate = currnetTime.getMonth();

有抽象方法的类一定是抽象类，但抽象类不一定必须有抽象方法

普通类中可以有静态方法，也可以有普通方法

DateFormat可以将日期进行格式化：

Date date = new Date();

System.out.println(date);

DateFormat dateFormat = new SimpleDateFormat("yyyy-mm-dd hh:mm:ss");

Date date = new Date();

String strDate = dateFormat.format(date)

System.out.println(strDate);

String dateStr = "1990-12-12 12:12:12";

Date date2 = dateFormat.parse(dateStr);

System.out.println(date2);

DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);

Date date = new Date();

String dateStr = dateFormat.format(date);

System.out.println(dateStr);

如果在创建类中，有静态成员的时候，构造器就会变成：

package com.java.atguigu.lesson5;

public class Chinese {

private static String country;

private String name;

private int age;

public Chinese(String country, String name, int age) {

super();

Chinese.country = country;

this.name = name;

this.age = age;

}

静态内部类和非静态内部类

外部类和内部类的成员变量尽量设置为不同

package com.atguigu.javase.lesson5;

public class OuterClass {

static class staticInnerClass{

}

class InnerClass{

}

}

非静态内部类访问：

OuterClass oc = new OuterClass();

InnerClass in = oc.new InnerClass();

静态内部类访问：

staticInnerClass sic = new OuterClass.staticInnerClass();

Java异常：

1、error

2、exception(RuntimeException和编译时候的异常)

（1）数学异常 ArithmeticException

（2）空指针异常 NullPointerException

（3）数组下标越界异常 ArrayIndexOutOfBoundsException

（4）类型转换异常 ClassCastException

抓抛：

try{

...

}catch(Exception e){

e.printStackTrace();

}finally{

System.out.println(....) //finally一定会执行的

}

try{

}catch(ClassNotFoundExceptione){

e.printStackTrace();

}catch(RuntimeExceptione){

e.printStackTrace();

}

用户自定义异常类：

public class UserNotExistException extends RuntimeException{

private static final long serialVersionUID = 1L;

public UserNotExistException(){}

public UserNotExistException(String msg){

super(msg);

}

}

使用：

if(users.contains(user)){

return new User();

}else{

throw new UserNotExistException("用户不存在");

}

有关遍历输出的方式：

for(Object obj: person){

System.out.println(obj);

}

for(int i=0; i<person.length; i++){

System.out.println(person[i])

}

Java集合：多个对象的引用放入容器

1、List，有序，可重复 实现类有：LinkedList

2、Set，无序，不可重复 实现类有：HashSet LinkedHashSet TreeSet

3、Map，具有映射关系的集合 实现类有：HashMap LinkedHashMap TreeMap

Java集合中：Collection（包含List/Set） Iterator Map 是一个级别，都是接口

ArrayList集合在后面，它是实现类

1、Collection集合

Collection collection = new ArrayList();

Person person = new Person("WangJZ", 12);

collection.add(person);

colection.remove(person);

int aa = collection.size();

boolean flag1 = collection.isEmpty();

boolean flag2 = collection.contains(new Person("WangJZ",12))

Collection collection = new ArrayList();

Collection collection2 = new ArrayList();

Person person = new Person();

collection2.add(person);

collection.addAll(collection2);

collection.removeAll(collection2);

boolean flag3 = collection.containsAll(collection2);

collection.clear();

Object []obj = collection.toArray();

for(Object o1:obj){

System.out.println(o1);

}

保留增加retainAll(没有retain)的那个部分的元素,用retainAll()需要和add()连用

Collection collection2 = new ArrayList();

collection2.add(new Person("WangJZ1",12));

collection2.add(new Person("WangJZ2",13));--------------------new Person("WangJZ1",12)和new Person("WangJZ2",13)如果在原来的collection集合中没有，就在这个集合中添加这两个

collection2.retainAll(collection);

2、Set集合

（1）Set是无顺序的，按照元素的hashCode值存放，hashCode()可以在Source中生成

Set set = new HashSet();

set.add(new Person("WangJZ", 12));

set.remove();

set.addAll(set2);

set.removeAll(set2);

boolean flag1 = collection.isEmpty();

boolean flag2 = set.contains(new Person("WangJZ", 12));

boolean flag3 = set.containsAll(collection2);

（2）TreeSet

TreeSet set = new TreeSet();

set.add(new Person("AA", 12));

set.add(new Person("CC", 16));

set.add(new Person("EE", 18));

Iterator it = set.iterator();

while(it.hasNext()){

System.out.println(it.next());

}

//1、TreeSet用Comparator来实现排序，创建Comparator接口的实现类的对象

//实现Compare方法，来比较两个对象的大小

Comparator comparator = new Comparator() {

@Override

public int compare(Object o1, Object o2) {

if(o1 instanceof Person1 && o2 instanceof Person1){

Person1 p1 = (Person1)o1;

Person1 p2 = (Person1)o2;

return (p1.getAge()-p2.getAge());//这是按照年龄“升序排列”

}else{

throw new ClassCastException("不能转为Person1类型");

}

}

};

//2、创建TreeSet对象，然后传入Compare实现类的对象

TreeSet set = new TreeSet(comparator);

set.add(new Person1("AA", 12));

set.add(new Person1("CC", 16));

set.add(new Person1("EE", 18));

set.add(new Person1("DD", 11));

set.add(new Person1("BB", 10));

Iterator it = set.iterator();

while(it.hasNext()){

System.out.println(it.next());

}

（3）LinkedHashSet集合

LinkedHashSet是有顺序的，顺序按照add的前后顺序存放

Set set = new LinkedHashSet();

set.add(new Person("AA", 12));

set.add(new Person("BB", 13));

set.add(new Person("CC", 14));

（4）

TreeSet set = new TreeSet(comparator);

set.add(new Person("AA", 12));

set.add(new Person("BB", 13));

set.add(new Person("CC", 14));

set.subSet(new Person("AA", 12), new Person("CC", 14));---------------获取两者元素之间的元素----------[ )

set.headSet(new Person("CC", 14));--------------------------获取小于这个元素的所有元素

set.tailSet(new Person("AA",12));--------------------------获取大于这个元素的所有元素

3、List集合

List 有序，可重复

List list = new ArrayList();

List list = Arrays.asList("A","B","C"); //这样的写法，获得的集合是只读的，不能对集合进行相关操作

（1）

list.add(new Person1("AA", 12));

list.add(new Person1("BB",11));

list.add(new Person1("CC", 10));

list.add(new Person1("DD",9));

Iterator it = list.iterator();

while(it.hasNext()){

System.out.println(it.next());

}

还有一种变量方式：（只有list才有）

for(int i=0;i<list.size();i++){

Object object = list.get(i);

System.out.println(object);

}

//List集合涉及的几个方法：

// 1. void add(int index, Object ele):把元素添加到指定的位置，原来的元素后移

// 2. boolean addAll(int index, Collection eles):把一组元素添加到指定的位置

// 3. Object get(int index):获取指定索引的元素

// 4. int indexOf(Object obj):获取指定元素的索引值,若元素不存在，则返回-1

int index = list.indexOf(new Person1("CC", 10));

System.out.println(index);

// 5. int lastIndexOf(Object obj): List中可以存放重复的元素，获取重复元素的

list.add(new Person1("CC", 10));

System.out.println(list.lastIndexOf(new Person1("CC", 10)));

// 6. Object remove(int index):移除指定索引的元素

// 7. Object set(index, Object ele):设置index位置的元素为ele，原来的元素被替换

// 8. List subList(int fromIndex, int toIndex)

可变形参：

（1）记住，如果有能匹配定长的方法（这里面的test( )方法），那么优先匹配该方法，含有不定参数的重载方法被最后匹配

（2）一个方法最后只能有一个长度可变的形参

（3）调用包含一个可变形参的方法时，可以为该形参传入多个参数或一个数组,不传入任何参数也可以

public void test(String...args){

}

使用：

test("aa","bb","cc","dd","ee");

test(new String[]{"MM","NM"});;

test("aa","bb");

4、Map集合

（1）HashMap 无序

Map map = new HashMap();

map.put("AA",new Person1("AA", 12));

map.put("BB",new Person1("BB", 12));

map.put("CC",new Person1("CC", 12));

map.put("DD",new Person1("DD", 12));

Set keySet = map.keySet();--------------------------map独有

map.size()

map.clear();

boolean flag = map.isEmpty();

boolean flag2 = map.containsKey("DD");

boolean flag3 = map.containsValue(new Person1("AA", 12));

V get(Object key): 根据Key返回对应的Value

Object obj = map.get("CC");

System.out.println(obj);

Collection<V> values(): 返回Value对应的集合。

Collection values = map.values();

System.out.println(values);

(2) LinkedHashMap，有顺序，顺序是元素先后添加的顺序

Map map = new LinkedHashMap();

map.put("AA",new Person1("AA", 12));

map.put("BB",new Person1("BB", 12));

map.put("CC",new Person1("CC", 12));

map.put("DD",new Person1("DD", 12));

（3）TreeMap: 有顺序，但要和Comparator的compare()方法连用，不用它的话就无法实现排序，以及equals()和hashCode()都要创建

Comparator comparator = new Comparator() {

@Override

public int compare(Object o1, Object o2){

if(o1 instanceof Person1 && o2 instanceof Person1){

Person1 p1 = (Person1) o1;

Person1 p2 = (Person1) o2;

return p1.getAge()-p2.getAge();

}

return 0;

}

};

Map map2 = new TreeMap(comparator);

map2.put("AA",new Person1("AA", 12));

map2.put("BB",new Person1("BB", 12));

map2.put("CC",new Person1("CC", 12));

map2.put("DD",new Person1("DD", 12));

关于集合的迭代器：

Iterator迭代器：

Iterator it = collection/set/list.iterator();

while(it.hasNext()){

System.out.println(it.next());

}

另外

List独有迭代器：

for(int i=0; i<list.size();i++){

Object obj = list.get(i);

System.out.println(obj);

}

还有Map的迭代器：

Iterator it = keySet.iterator();

while(it.hasNext()){

Object key = it.next();

Object value = map.get(it);

System.out.println(key + value);

}

jdbc.properties:

//读取jdbc.properties文件

//1. 创建properties对象

Properties properties = new Properties();

//2. 调用properties的load()方法，加载属性文件对应的输入流

InputStream inStream = PropertiesTest.class.getClassLoader().getResourceAsStream("jdbc.properties");

properties.load(inStream);

//3. 调用getProperties(String key)方法获取属性值

String user = properties.getProperty("user");

System.out.println(user);

Collections工具类（是一种可以操作Set集合、List集合、Map集合的一种工具类）

1、获取进程安全：

Collections.synchronizedList(list);

Collections.synchronizedSet(set);

Collections.synchronizedMap(map);

如：

List list = new ArrayList();

List list2 = Collections.synchronizedList(list);//可以得到进程安全的对象

2、排序(只能用在List集合中)

Comparator comparator = new Comparator() {

@Override

public int compare(Object o1, Object o2){

if(o1 instanceof Person1 && o2 instanceof Person1){

Person1 p1 = (Person1) o1;

Person1 p2 = (Person1) o2;

return p1.getAge()-p2.getAge();

}

return 0;

}

};

Collections.sort(list,comparator);

for(Object obj: list){

System.out.println(obj);

}

3、获取最大/最小

先要排序之后，再做。。。

Object min = Collections.min(set/map/list);

泛型（Generic）

先建立一个Person类 还有Person类的子类Student类

普通方式把对象添加到集合中：

List persons = new ArrayList();

persons.add(new Person("AA",12));

persons.add(new Person("BB",13));

persons.add(new Person("CC",14));

persons.add(new Person("DD",15));

persons.add("ABCD");

for(int i=0;i<persons.size();i++){

Object obj = persons.get(i);

Person person = (Person)obj; //对obj要进行强制类型转换

System.out.println(person.getName());//会出现类型转换异常

}

集合中泛型方式添加：

List<Person> persons2 = new ArrayList<Person>();//就是Person类型的List了

persons2.add(new Person("AA",12));

persons2.add(new Person("BB",13));

persons2.add(new Person("CC",14));

persons2.add(new Person("DD",15));

persons2.add(new Student());//也可以放Person的子类对象

Person person2 = persons2.get(2);

System.out.println(person2);

集合中泛型+Comparator排序：

Set<Person> persons = new TreeSet<>(new Comparator<Person>() {

@Override

public int compare(Person p1,Person p2){

return p1.getAge()-p2.getAge();//这里使用compare函数的时候，就不必使用强制类型转换了

}

});

persons.add(new Person("AA",16));

persons.add(new Person("BB",13));

persons.add(new Person("CC",11));

persons.add(new Person("DD",18));

Iterator<Person> it = persons.iterator();

while(it.hasNext()){

Person person = it.next();

System.out.println(person);

}

public void printPersons(List<Person> persons){ }

public void printPersons2(List<? extends Person> persons){ }

泛型类以及函数创建：

public class Dao<T> {

public T get(int id){

T result = null;

return result;

}

//在泛型类中使用类声明的泛型

public void save(T entity){

}

//在类(不一定是泛型类)中使用的泛型方法：

//1. 在方法的返回值使用<>前面声明泛型，则在方法的参数，方法体中，都可以使用该类型

//public <E> E getProperty(int id, E obj){内容} 也是可以的

public <E> E getProperty(int id) {

return null; //返回值是什么类型，那么E就是什么类型

}

//public <E> void test(E[] a, Collections<T> c ){内容}

public <E> void test(E entity){ //传的参数是什么类型，那么E就是什么类型

}

}

使用：

Dao<Peron> dao = new Dao<>();

Person person = new Peson();

person.get(1);

Dao<Peron> dao = new Dao<>();

Person person = new Person();

dao.save(person);

使用：

String name2 = dao.getProperty(1);

int age = dao.getProperty(2);

toArray()方法的妙用：

toArray()方法可以把该集合转为Person类型的数组

Collection<Person> persons = new ArrayList<>();

persons.add(new Person());

persons.add(new Person());

persons.add(new Person());

Person []personArray = persons.toArray(new Person[0]);

System.out.println(personArray.length);

枚举型：

枚举类 希望这个类中只有这几个固定的元素

（1）第一种情况

package com.atguigu.javase.lesson9;

public enum Season2 {

//枚举类的实例需要在枚举类的第一行列出

SPRING("春天","春风又绿江南岸"),

SUMMER("夏天","印日荷花别样红"),

AUTUMN("秋天","秋水共长天一色"),

WINTER("冬天","窗含西岭千秋雪");

final String SEASON_NAME;

final String SEASON_DESC;

private Season2(String seasonName, String seasonDesc){

this.SEASON_DESC = seasonDesc;

this.SEASON_NAME = seasonName;

}

}

（2）第二种情况（需要实现某个接口的话）

package com.atguigu.javase.lesson9;

public enum Season4 implements Info{

//枚举类的实例需要在枚举类的第一行列出

SPRING("春天","春风又绿江南岸"){

@Override

public String getInfo(){

return "^^A";

}

},

SUMMER("夏天","印日荷花别样红"){

@Override

public String getInfo(){

return "^^B";

}

},

AUTUMN("秋天","秋水共长天一色")

{

@Override

public String getInfo(){

return "^^C";

}

},

WINTER("冬天","窗含西岭千秋雪"){

@Override

public String getInfo(){

return "^^D";

}

};

final String SEASON_NAME;

final String SEASON_DESC;

Season4(String seasonName, String seasonDesc){

this.SEASON_DESC = seasonDesc;

this.SEASON_NAME = seasonName;

}

如何使用注解：（Annotation） 可以用IDE创建一个注解

注解可以是程序在编译的时候被读取，并执行相应结果，可以在不改变原有逻辑的情况下，在源文件中嵌入一些信息

@Rentention:注解的保留位置

@Rentention(RetentionPolicy.RUNTIME)

@Target:注解的作用目标

@Target(value={ElementType.TYPE, ElementType.METHOD})

@Deprecated:表示（这个成员、方法、类）已经过时

@SuppressWarnings: 可以抑制编译器发出的警告信息 @SuppressWarnings("unchecked")

(1)示例1

//使用@interface来声明注解

package com.atguigu.javase.lesson9;

@Target(value={ElementType.TYPE,ElementType.METHOD})

@Retention(RetentionPolicy.RUNTIME)//定义为运行时可见

public @interface HelloAnnocation {

//使用接口中声明方法的方式来声明注解的属性

String major();

int age();

String school() default "atguigu";

}

（2）示例2

package com.atguigu.javase.lesson9;

public class AnnotationTest {

@SuppressWarnings("rawtypes")//抑制警报器响应：“必须要传递带泛型的参数”

@Test

public void helloAnnotation(){

@SuppressWarnings("unused")

List list = new ArrayList();

}

}

@HelloAnnocation(age = 12, major = "Java")

class A{

@HelloAnnocation(age = 13, major = "Oracle")

void test(){}

void test2(@Deprecated String name){

}

@Deprecated

void test3(){

}

}

class B extends A{

@Override

void test() {

super.test();

}

}

使用：

反射和注解连用

先创建一个注解：

package com.atguigu.javase.lesson12;

@Retention(RetentionPolicy.RUNTIME)

@Target(value = {ElementType.METHOD})

public @interface AgeValidator {

public int min();

public int max();

}

再创建一个类：

package com.atguigu.javase.lesson12;

public class Person {

String name;

private int age;

private void test(){

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public void setName(String name, Integer age){

System.out.println("name:" + name);

System.out.println("age:" + age);

}

public int getAge() {

return age;

}

@AgeValidator(min=18, max=35)

public void setAge(int age) {

this.age = age;

}

public Person(String name, Integer age) {

super();

this.name = name;

this.age = age;

System.out.println("有参数的构造器");

}

/*

* 无参构造器是留给反射使用的，所以一个类里面要写两个构造器

* */

public Person() {

// System.out.println("无参数的构造器");

}

private String method2(){

return "private String method2";

}

private Object method3(String name, Integer age){

Person person = new Person();

return person;

}

@Override

public String toString() {

return "Person [name=" + name + ", age=" + age + "]";

}

}

文件IO流：

字节输入输出流：InputStream/OutputStream

FileInputStream/FileOutputStream(文件)

BufferedInputStream/BufferedOutputStream(缓冲)

字符输入输出流：Reader/Writer

FileReader/FileWriter(文件)

BufferedReader/BufferedWriter(缓冲)

使用：

package com.atguigu.javase.lesson10;

public void testStream(){

InputStream inputStream = new FileInputStream("1.txt");

BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);

OutputStream outputStream = new FileOutputStream("2.txt");

BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);

byte []Buffer = new byte[1024];

int len = 0;

while((len = bufferedInputStream.read(Buffer))!=-1){

bufferedOutputStream.write(buffer,0,len);

}

bufferedInputStream.close();

bufferedOutputStream.close();

}

public void testRW(){

InputStream inputStream = new FileInputStream("1.txt");

Reader reader = new InputStreamReader(inputStream);-----------------------使用转换流，字节流转为字符

BufferedReader bufferedReader = new BufferedReader(reader);

OutputStream ouputStream = new FileOutputStream("2.txt");

Writer writer = new OutputStreamWriter(ouputStream);-----------------------使用转换流，字节流转为字符

BufferedWriter bufferedWriter = new BufferedWriter(writer);

String str = null;

int i = 0;

while((str = bufferedWriter.readLine())!=-1){

if(i!=0){

bufferedWriter.write("\n");

}

bufferedWriter.write(str);

i++;

}

bufferedReader.close();

bufferedWriter.close();

}

RandomAccessFile类既可以读，也可以写-------------------用来在文件里面添加内容

public void testRandomAccessFile2() throws IOException{

RandomAccessFile access = new RandomAccessFile("hello.txt","rw");

//先读一行

String line = access.readLine();

//把第一行后面的内容先读取到一个byte数组中。

byte [] buffer = new byte [(int)(access.length()-line.length())];

access.read(buffer);

//移动指针到第一行的后面

access.seek(line.length());

//写入要写的字符窜

access.writeBytes("\n I love Gongfu...\n");

//再写入先前的内容

access.write(buffer);

//关闭

access.close();

}

String 类：

/*

* 1. String 是不可变的字符序列！!!!!!

* 2. 关于字符窜缓冲池: 直接通过 = 为字符窜赋值，会先在缓冲池中查找有没有一样的字符窜，如果有，就把那个引用赋给字符窜变量，否则，就会创建一个新的字符窜，并会把对应的字符窜放入到缓冲池中

* 3. 字符窜的一个常用方法：

* 3.1 去除前后空格的trim()方法,只能是前后空格

* 3.2 求子字符窜的方法：subString()

* 从fromIndex开始，包含fromIndex，且String的字索引从0开始

* 3.3 subString(fromIndex, toIndex): [fromIndex, toIndex)

* 3.4 indexOf(): 求指定字符的索引

* 3.5 split(String regex): 把字符窜拆分成字符窜数组

* 3.6 equals(): 比较字符窜内容是否相等，必须使用该方法，而不能直接使用 ==

*

* */

（1）String类一旦被创建，就是固定的了

public void testNewString(){

String str1 = "hello world";

String str2 = "hello world";

System.out.println(str1.equals(str2)); //true

System.out.println(str1.hashCode());

System.out.println(str2.hashCode());

String str3 = new String("abcd");

String str4 = new String("abcd");

System.out.println(str3==str4); //false

}

（2）

public void testSubString(){

String str = "http://www.atguigu.org/index.jsp?name=Tom";

//subString(fromIndex):从fromIndex开始，包含fromIndex，且String的字索引从0开始

String str1 = str.substring(7);

System.out.println(str1);

String str2 = str.substring(1, 5);

System.out.println(str2);

}

public void testIndexOf(){

String str = "http://www.atguigu.org/index.jsp?name=Tom";

System.out.println(str.indexOf("//")); //5

System.out.println(str.lastIndexOf("/"));

int beginIndex = str.indexOf("//")+2;

int endIndex = str.lastIndexOf("/");

System.out.println(str.substring(beginIndex, endIndex));--------------输出的结果是：www.atguigu.org

}

（3）

public void testSplit(){

String str = "a-b-c-d-e-f";

String [] values = str.split("-");

for(String s: values){

System.out.println(s);

}

}

（4）

/* * 给定一个字符窜：acmfnz

* 经过运算后打印：每个字符都向后窜一位 bdngoa

* 若某个字符已经是z，则返回到最开始的a

* * */

public void testTranstorString(){

String str = "acmfnz&AcceeEMM";

System.out.println(str);

for(int i=0;i<str.length();i++){

char ch = str.charAt(i);

if(ch>='a'&&ch<='z'){

if(ch=='z'){

ch = 'a';

}

else{

ch = (char)(ch+1);

}

}else if(ch>='A'&&ch<='Z'){

if(ch=='Z'){

ch = 'A';

}

else{

ch = (char)(ch+1);

}

}

System.out.print(ch);

}

}

(5)

String 变为可变的话，就用StringBuffer()和StringBuilder(),一般用StringBuilder()

StringBuilder stringBuilder = new StringBuilder("abc");

stringBuilder = stringBuilder.replace('a','c');

stringBuilder = stringBuilder.append("aaa").append("bbb").apend("ccc");

Math类：为了获取一些数学值

double aa = Math.sin(Math.PI);

Random类：为了获取随机数

Random random = new Random();

int bb = random.nextInt();-------------------获取随机数

int cc = random.nextInt(10);-----------------获取10以内的随机数

反射Reflection

（1）clazz为Class类的对象

和Class类（是一种描述类,封装了当前类对象的一些信息）

用反射的时候，Person类里面一定要有无参构造器

Person person = new Person();

Class clazz = Person.class;

Class clazz = person.getClass();

Class clazz = Class.forName("类文件名com.atguigu.aaa");

Object obj = clazz.newInstance();-----------创建Person类的实例

（2）类加载器是用来把类装进JVM的

public void testClassLoader() throws Exception{

//1. 获取一个系统的类加载器

ClassLoader classLoader = ClassLoader.getSystemClassLoader();

System.out.println(classLoader);

//2. 获取系统类加载器的父类加载器

classLoader = classLoader.getParent();

System.out.println(classLoader);

//3. 获取扩展类加载器的父类加载器

classLoader = classLoader.getParent();

System.out.println(classLoader);

//4. 测试当前类是由哪个类加载器进行加载的

classLoader = Class.forName("com.atguigu.javase.lesson12.Person").getClassLoader();

System.out.println(classLoader);

//5. 测试JDK提供的Object类由哪个加载器加载

classLoader = Class.forName("java.lang.object").getClassLoader();

System.out.println(classLoader);

//6. 关于类加载器的一个主要方法

//调用getResourceAsStream获取类路径下的文件对应的输入流 ---------用的很多

// InputStream in = new FileInputStream("test.properties");

InputStream in = null;

in = this.getClass().getClassLoader().getResourceAsStream("com/atguigu/javase/lesson12/test.properties");

System.out.println(in);

}

（3）Method类

public void testMethod() throws Exception{

Class clazz = Class.forName("com.atguigu.javase.lesson12.Person");

//1. 得到clazz对应的类中有哪些方法，不能获取private方法

Method []methods = clazz.getMethods();

for(Method method:methods){

System.out.println("^" + method.getName());

}

//2. 获取所有方法，不包括private方法，且只获取当前类声明的方法

Method []methods2 = clazz.getDeclaredMethods();

for(Method method:methods2){

System.out.println("~" + method);

}

//3. 获取指定的方法

Method method = clazz.getDeclaredMethod("setName", String.class);

System.out.println(method);

method = clazz.getDeclaredMethod("test");

System.out.println(method);

method = clazz.getDeclaredMethod("setName", String.class, Integer.class);

System.out.println(method);

//4. 执行方法

Object obj = clazz.newInstance();

method.invoke(obj, "尚硅谷",12);

System.out.println();

}

重写invoke()方法：

2个

（1）

/* *

* obj: 方法执行的那个对象

* methodName: 类的一个声明，该方法也可能是一个私有方法

* args: 调用该方法需要传入的参数

* return: 调用方法后的返回值

* */

public Object invoke(Object obj, String methodName,Object...args) throws Exception{

//1. 获取Method对象

Class []parameterTypes = new Class [args.length];

for(int i = 0; i<args.length; i++){

parameterTypes[i] = args[i].getClass();

System.out.println(parameterTypes[i]);

}

try {

Method method = obj.getClass().getDeclaredMethod(methodName, parameterTypes);

return method.invoke(obj, args);

} catch (Exception e) {

e.printStackTrace();

}

//2. 执行Method方法

//3. 返回方法的返回值

return null;

}

（2）

/* *

* className: 某个类的全类名

* methodName: 类的一个声明

* args: 调用该方法需要传入的参数

* return: 调用方法后的返回值

* */

public Object invoke(String className, String methodName, Object...args){

Object obj = null;

try {

obj = Class.forName(className).newInstance();

return invoke(obj, methodName, args);

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

（6）获取当前类的父类

/* * 获取当前类的父类:

* 直接调用Class对象的getSuperclass()方法

* */

public void testGetSuperClass() throws Exception{

String className = "com.atguigu.javase.lesson12.Student";

Class clazz = Class.forName(className);

Class superClazz = clazz.getSuperclass();

System.out.println(superClazz);

}

（7）method.setAccessible(true);

public class Student extends Person {

private void method1(Integer age){

System.out.println("private void method1");

}

}

public void testInvokePrivateMethod() throws Exception{

Object obj = new Student();

Class clazz = obj.getClass();

Method method = clazz.getDeclaredMethod("method1", Integer.class);

System.out.println(method);

//若需要通过反射执行私有方法

method.setAccessible(true);

method.invoke(obj, 10);

}

代理Proxy:（把类的对象包起来，成为代理对象） 面向对象编程的补充---面向切面编程，如果从各个模块里面收集出“横切关注点”

一些固定的非业务的需求很多的话，把这些固定的非业务需求用代理去完成

用代理类的代理对象去实现

（1）创建代理对象：

final PersonDo personDo = new PersonDo();----------被代理的对象一定要是final修饰的

PersonDo proxy

= (PersonDo)Proxy.newProxyInstance(clazz.getClassloader(), new Class []{PersonDo.class},

new InnvocationHandler(){

@Override

public Object invoke(Object proxy, Method method, Object []args){

...............一些非业务代码块

调用被代理类的目标方法

Object result = method.invoke(personDo, args);

System.out.println(result);

}

});

（2）使用代理对象实现方法

int ress = proxy.add(1, 2);

线程 Thread类(是一个接口)： 把程序放在线程里面运行

进程，也叫任务（程序运行的基本单位）-------多个线程（线程是独立运行的，不受其他线程干扰）

（1）创建单线程Thread

public class MyThread extends Thread{

@Override

public void run(){

线程需要的执行的内容...

}

}

Thread thread = new MyThread();

给线程命名：thread.setName("WangJZ");

获取线程的名字：thread.getName();

（2）启动单线程

thread.start();

（3）获取当前线程：

Thread thread = Thread.currentThread();

String threadName = Thread.currentThread().getName();

String myThreadName = MyThread.currentThread().getName();

（4）创建多线程,需要使用Runnable（是一个接口）----------------------------可能会有线程安全的问题

public class MyRunnable immplements Runnable{

@Override

public void run(){

线程需要执行的内容...

}

}

MyRunnable myRunnable = new MyRunnable();

Thread thread1 = new Thread(myRunnable);

Thread thread2 = new Thread(muRunnable);

（5）启用多线程

thread1.start();

thread2.start();

（6）使进程休息一段时间：thread.sleep(1000);----休息1秒

（7）判断线程是否已经死亡了：

boolean flag = thread.isAlive();

（8）把正在运行的线程变为“可运行的线程”,在后面，紧接着还会运行run()方法的

thread.yield();

（9）解除线程阻塞：

tread.interrupt();

（10）当A线程在运行的时候，加入B线程，

此时A线程停止了，直到B线程运行结束之后，再运行A线程。

thread.join();

Thread thread = new MyThread();

@Override

public void run(){

线程需要执行的内容...

}

for(int i=0; i<100; i++){

System.out.println(Thread.currentThread().getName() + i);

thread.join();

}

（11）线程通信：

1、

和线程优先级相关,默认为 5 main()方法中的线程优先级最高

thread.getPriority();

thread1.setPriority(MIN_PRRIORITY);

thread2.setPriority(MAX_PRRIORITY);

2、

在同步方法里面，调用一些方法： 注：前面不需要加线程对象去调用

wait();

notify();

notifyAll();

（12）线程同步：线程和线程之间相互协作，消除线程安全问题

在进程类里面创建同步方法

public synchronized void method(){

方法实现...

}

@Override

public void run(){

method();

}

网络编程：Java中提供有网络类库

网络主机进行通信：IP地址，TCP/IP参考模型（TCP/IP协议）

应用层--传输层--IP层--网络接口层

服务器--------客户端（C/S，开发）

TCP/IP 编程：

域名：www.baidu.com

IP地址：定位主机 202.108.35.210（DNS域名服务器转化得到）

端口：定位程序

（1）获得域名和IP:

InetAddress address = InetAddress.getByName("www.baidu.com");

InetAddress address = InetAddress.getByName("202.108.35.210");

InetAddress address = InetAddress.getLocalHost();

（2）Socket网络套接字（IP和端口的集合）：需要和InputStream连用才能使得客户端和服务器进行交互

1、客户端使用Socket， 客户端--->文件

Socket socket = new Socket(address, 端口号);

InputStream in = socket.getInputStream();

OutputStream out = new FileOutputStream("文件名");

byte []buffer = new byte[1024];

int len = 0;

while((len = in.read(buffer))!=-1){

out.write(buffer,0,len);

}

socket.close();

2、服务器端使用ServerSocket, 文件--->服务器端

ServerSocket serverSocket = new ServerSocket(端口号);

Socket socket = serverSocket.accept();

InputStream in = new FileInputStream("文件名");

byte []buffer = new byte[1024];

int len = 0;

OutputStream out = socket.getOutputStream();

while((len = in.read(buffer))!=-1){

out.write(buffer,0,len);

}

out.close();

in.close();

socket.close();

serverSocket.close();

URL编程,（B/S）开发,URLConnetcion类，也是需要和InputStream连用

URL地址：http://对方主机地址:端口号/文件夹名/文件名

URL url = new URL("URL地址");

URLConnection urlConnection = url.openConnection();

InputStream in = urlConnection.getInputStream();

OutputStream out = new FileOutputStream("文件名");

byte []buffer = new byte[1024];

int len = 0;

while((len = in.read(buffer))!=-1){

out.write(buffer,0,len);

}

in.close();

out.close();