1.数据类型：

基本数据类型：

数值型：

整数类型：字节型byte(1个字节)短整型short(2个字节)整型int(4个字节)长整型long(8个字节)

浮点类型：单精度float(4个字节)双精度(8个字节)

字符型:char(2个字节)

布尔型：boolean(1个字节)

引用数据类型：

类：class  （String属于类不属于基本数据类型）

接口：interface

数组[]

2.属性自带默认值：

int--0

double --0.0

char--空格--0

boolean--false

String--null--不赋值调用会报空指针异常，直接输出不会

3.基本数据类型和String类型转换：

①基本类型-->String:

基本类型的值+""即可；

②String-->基本数据类型：

通过调用基本类型的包装类调用parse()方法即可

例：String str = "123";

int n = Integer.parseInt(str);

double d = Double.parseDouble(s);

float f = Float.parseFlost(s);

long l = Long.parseLong(s);

byte b = Byte.parseByte(s);

boolean boo = Boolean.parseBoolesn("true");

short sr = Short.parseShort(s); 

4.基本数据类型转换：

①自动类型转换：

低精度向高精度转换（自动）

byte-->short-->int-->long-->float-->double

char-->int-->long-->float-->double

②强制类型转换：

将容量大的数据类型转换成容量小的数据类型，使用时要加上强制转换符()，但可能造成精度降低或溢出；

例：int i = (int)1.9;

system.out.println(i);

i = 1;

③对象的强制类型转换：

子类对象无条件强制类型转换成父类类型，父类 对象名 = （父类）子类对象；

父类对象不能转换成子类类型，除非父类的引用里存放的本来就是该子类对象

对象之间的强制类型转换必须要有继承关系草可以转换

5.单一实例：

①构造方法私有

②私有静态自己本身的对象

③公共静态方法 将对象返回

public class Test

{

   private Test(){}

   private static Test test = new Test();

   public static Test newInstense()

   {

       return test;

   }

}

main...{Test t = Test.newInstense();}

6.C/S:

Client 客户端：主动连接服务器

Server 服务器：设置端口，等待客户端连接

端口：port

计算机运行的网络程序的唯一编号，范围：1025~65535

ip地址：在网路中计算机的唯一编号

127.0.01是一个特殊的ip地址表示自己电脑本身

客户端连接服务器：

客户端端口系统分配

Socket socket = new Socket("127.0.0.1,6666");

设置服务器端口,等待客户端连接：

ServerSocket ss = new ServerSocket(6666);

Socket socket = ss.accept();

发送：

OutputStream os = socket.getOutputStream();

OutputStreamWriter osw = new OutpurStreamWriter(os);

osw.write("长夜难明\n");\n 表示停止接收

清理缓存：osw.flush();

接收：

InputStream is = socket.getInputStream();

InputStreamReader isr = new InputStreamReader(is);

BufferedReader br = new BufferedReader(isr);

String str = br.readline();以\n作为停止接收的标志

7.继承：

public class 子类 extends 父类

{

   java中所有的类都是Object类的"子类"，如果声明一个类，没有继承父类，默认继承Object

   一个子类只能有一个父类

   子类会将父类中间所有的属性和方法都复制一份，除构造方法

   覆盖从父类继承的属性名相同的属性

   重写从父类继承的返回类型、方法名、参数一致的方法；

   重写访问权限修饰符可以相同，也可以不同，不同要写作用域更大的

   自类中间还会有新增加的属性、方法， 以父类的身份，不能使用子类新增加的属性和方法

   私有属性和方法不能继承，父类的构造方法不能继承

}

8.接口：

接口可以理解为规范、通行证

可以实现多个接口  

public interface 接口

{

  public abstract 返回类型 方法名(形参)；

  public static final 属性；

  //int a = 10;默认公共、静态、最终

  //void set();默认公共、抽象

}

public class 类名 implements 接口名

{

   接口中可能有抽象方法，而类中间不能有抽象方法

   所以如果接口中抽象方法，类实现接口时要重写抽象方法

}

9.动态数组：

java.util.ArrayList类

void add(Object){}，形参的数据类型是Object 超级父类 

ArrayList list = new ArrayList();

使用add(实参)方法向ArrayList类中间的容器里添加数据 

调用add()方法的时候，需要实参，实参的数据类型没有任何的限制

调用get(下标)方法取出数组里的元素，返回的元素就是以给定的下标为参数，在ArrayList中间对应的数据，取出的元素不会影响ArrayList里面的数据

如果存放的是子类的对象，以父类的身份是不可以使用子类新增加的属性和方法的，所以需要进行对象的强制类型转换才可以使用

类 对象名 = (类)(list.add(3));

int 变量名 = list.size();可以获取数组内元素的个数

list.remove(下标);删除指定元素，删除后后一个元素会自动补位

Collections.sort(list);实现对动态数组从小到大排序

泛型：

ArrayList<类> list = new ArrayList<>();<存放类>

int-->Integer   double-->Double  char-->Character   boolean-->Boolean

byte-->Byte    short-->Short   long-->Long  float-->Float  String-->String

动态数组与数组的区别：

数组：

数组一旦被定义，数组元素的个数就确定了，不能更改，数组中只能存放一种数据类型

动态数组：

可以根据需要自动的增加元素的个数，数组中可以存放任何类型的数据

也可以用泛型指定添加的数据类型，可以自由的添加、插入、移除数组中的元素

10.修饰符：修饰符没有顺序

①类的权限访问修饰符：

public 公共 类名和文件名需要保持一致 

friendly--package 友好/缺省 

②属性、方法访问修饰符：

private 私有 类本身可用，同一个包、包外子类、包外不可用

friendly 友好 类本身、同一个包可用，包外子类、包外不可用

protected 保护 类本身、同一个包、包外子类可用，包外不可用

public 公共 类本身、同一个包、包外子类、包外皆可用

③最终修饰符：final

修饰类：类不能被继承；final class 类名{}

修饰属性：属性必须初始化值，属性的值不能改变；final 数据类型 变量名 = 值；

例如：public class JFrame{public static final int EXIT_ON_CLOSE = 3;}

修饰方法：方法不能被重写；final void 方法名（形参）{}

④静态修饰符：static

修饰属性：静态属性 private static 数据类型 变量名；

静态属性的访问方式可以通过对象调用，也可以通过类名调用

例：对象名.静态属性；类名.静态属性

修饰方法：静态方法 public static 返回类型 方法名（形参）{}

静态方法的访问方式可以通过对象调用，也可以通过类名调用

例：对象名.静态方法；类名.静态方法

static {} 静态程序块：执行类中间的任何内容之前，先执行静态程序块里的内容，只执行一次，后面不再执行

静态方法中间，只能调用静态属性及静态方法，不能调用非静态属性及方法

非静态方法中间，可以使用静态，也可以使用非静态

静态方法中不能使用关键字this、super

⑤抽象修饰符：abstract

抽象类：

修饰类：public abstract class 类名{属性、方法、抽象方法}，抽象类不能创建对象，可以有抽象方法

类能继承抽象类、抽象类可以继承类、抽象类可以继承抽象类且都是单一继承，抽象类可以实现接口，类继承抽象类必须重写抽象类中间所有的抽象方法

修饰方法：访问修饰符 abstract 返回值类型 方法名（形参）{}；没有方法体，必须重写，只能在抽象类和接口中使用

11.线程：

java.util.Thread类

继承Thread类

public void run(){}方法

在run方法中间的循环还没有之行结束之前，其他代码就已经可以执行

需要重写run()方法，启动线程要通过调用public void start(){}方法，不能直接调用run()方法

12.递归：

①递归：我自己调用我自己

递归有去有回，先递进，在回归，使用递归时必须有终止条件

理解递归可以用分而治之的思想，将一个问题划分为若干个规模小而与原问题相同或相似的子问题

然后分别解决这些问题，最终合并这些问题的解

②递归跟循环的区别:

1.递归：你打开面前这扇门，看到屋里面还有一扇门

你走过去，发现手中的钥匙还可以打开它，你推开门，发现里面还有一扇门，你继续打开它

若干次之后，你打开面前的门后，发现只有一间屋子，没有门了

然后你开始原路返回，每走回一间屋子，你数一次，回到入口的时候，你可以回答出你到底用这你把钥匙打开了几扇门

2.循环：你打开面前这扇门，看到屋里面还有一扇门

你走过去，发现手中的钥匙还可以打开它，你推开门，发现里面还有一扇门

若前面两扇门都一样，那么这扇门和前两扇门也一样

如果第二扇门比第一扇门小，那么这扇门也比第二扇门小

你继续打开这扇门，一直这样继续下去直到打开所有的门

但是，入口处的人始终等不到你回去告诉他答案