作者QQ：1095737364    QQ群：123300273     欢迎加入！

1.数据类型：

 数据类型:1>.基本数据类型:1).数值型: 1}.整型类型(byte  8位   (byte)0,short  16位 (short)0,int  32位  0,long  64位  0L)

2}.浮点类型(float 32位 0.0f,double 64位 0.0d)

　　　　　　　　　　　　  2).字符型(char  2位 \u0000(空,''))

3).布尔型(boolean false)

2>.引用数据类型:1).类(class)

2).接口(interface)

3).数组

转义字符:  \f  换页      \\  反斜线     \b 倒退一格    \' 单引号     \r 归为     \" 双引号     \t 制表符Tab                \n 换行

转换类型： 转换前的数据类型与转换后的类型兼容， 转换后的数据类型的表示范围比转换前的类型大：自动转换， 强制转换 : (欲强制转换的数据类型) 变量名称;

中断语句： break 跳出当层的循环      continue 中止本次循环      return  终止方法

2.数组：

一维数组：存放数据类型相同的数据　　　

1. 数据类型 数据名[]=null;    栈内存里存放
2. 数据名=new 数据类型[长度]  分配内存,开辟长度空间,堆内存存放
3. 数据类型[] 数据名=null
4. 数组名.length   求数组的长度

二维数组：

1. 动态初始化：(1) 数据类型 数据名[][];  第一个[]是行,第二个[]是列,(2) 数据名[][]=new 数据类型[行的个数][列的个数]
2. 静态初始化: 数据类型 数据名[][]={{第0行初始值},{第1行初始值},{第0行初始值},…{第n行初始值}}

多维数组:  数组类型 数组名[][][],,,;

foreach输出:

for(数据类型 变量名称:数组名称){

      System.out.println(变量名称+”,”);

}

3.方法与方法的重载：

静态(status)方法只能调用静态方法：

方法的重载:方法名称相同,但参数的类型和参数的个数不同,通过传递参数的个数及类型不同以完成不同功能的方法调用，返回值类型不同不能算重载

可变参数:返回值类型 方法名称(类型 … 参数名称){}     参数名称通常是一个数组的名称

4.面向对象：

面向过程: 就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向过程: 是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

面向对象的三大特征：

　　1.封装(Encapsulation) 对外部不可见 可以保护程序中的某些内容

1. 1. 为属性封装:private 属性类型 属性名称;
   2. 为方法封装:private 方法返回值 方法名称(参数列表){};
   3. Setter(设置): public void setName(String name){};
   4. getter(取得): public String getName();

2.继承(Inheritance)  扩展类的功能

1. 1. 使用extends关键字完成继承关系
   2. 继承的限制: 只有单继承,一个类只能有一个父类,但可以有对个子类.可以多层继承.
   3. 访问限制:子类不能直接调用父类的私有成员.
   4. 实例化对象时,先调用父类的构造方法(super();表示),然后调用子类的构造方法
   5. 方法的覆写:子类定义了与父类同名的方法,被子类覆写的方法不能拥有比父类方法更加严格的访问权限(public >default(默认)> private)
2. 多态(Polymorphism)  方法的重载  对象的多态性

1.向上转型: 子类对象 -> 父类对象

• • • 对于向上转型,程序会自动完成.
    • 格式: 父类 父类对象=子类实例;

　　　　　　2.向下转型: 父类对象 -> 子类对象

• • • 对于向下转型时,必须明确的指明要转型的子类类型
    • 子类 子类对象=(子类) 父类实例;
    • 如果要向下转型,首先要向上转型

类 : 是对某一类事物的描述,是抽象的,概念上的定义;

对象: 是实际存在的该类事物的每个个体,因而也称实例(instance)

• • • 类名 对象名称=null;   //声明对象,句柄对象
    • 对象名称=new 类名();  //实例化对象
    • 类名 对象名称=new 类名();

URL类图：所示的图形分为三个层次

1. 第一层表示类的名称,类的名称与之前一样要求开头首字母大写
2. 第二层表示属性的定义,按照”访问权限 属性名称:属性类型”的格式定义;
3. 第三层表示类中的方法的定义,按照”访问权限 方法名称():方法返回值”的格式定义( “+”表示public “-”表示private)

调用属性 :  对象.属性名称;

调用方法 :  对象.方法名称();

构造方法：

• 只要一有实例化则就会调用构造方法
• 构造方法的名称必须与类名称一致
• 构造方法的声明处不能有任何返回值类型的声明
• 不能在构造方法中使用return返回一个值
• 如果一个类中没有明确的声明一个构造方法,则会自动生成一个无参的什么都不做的构造方法.
• 匿名对象:没有名字,在java中如果一个对象只使用一次,则就可以将其定义成匿名对象.比之前的对象少了一个栈内存的引用关系.
• 构造方法的私有化:减少实例化对象,在类内部产生对象,这是单太设计模式,所谓的单太就是在入口处(构造方法)限制了对象的实例化操作.

代码块：

• 普通代码块：直接定义在方法中的代码块称为普通代码块
• 构造块： 直接在类中编写代码块,称为构造块
• 静态代码块
  • 使用static关键字声明的代码块称为静态代码块
  • 静态快优先于主方法执行
  • 如果在普通类中定义的静态快,优先于构造块执行,
  • 不管有多少个实例化对象产生,静态代码块只执行一次
  • 静态代码块的主要功能就是为静态属性初始化
• 同步代码块：synchronized

内部类：

• 在一个类的内部还有类,称为内部类
• 缺点:正常的一个类操作时,在类中最好只定义属性或方法.如果定义一个类的话.则肯定破坏了程序的一个结构.
• 优点:如果要想发现优点,则必须通过代码的拆分来观察,将以上的内部类和外部类变为两个类的形式,再完成同样的效果
• 使用static声明内部类:可以直接通过 外部类.内部类 进行访问.
• 调用格式:外部类.内部类 内部类对象=外部类实例.new内部类();

抽象类：

• 抽象类的概念:包含一个抽象方法的类就称抽象类
• 抽象方法:只声明而未实现的方法称为抽象方法,必须使用abstract关键字声明.
• 抽象方法是需要声明不需要实现
• 抽象方法不行被子类继承,子类(如果不是抽象类)必须覆写抽象类中的全部抽象方法
• 不能使用final关键字声明,抽象类是必须有子类的

接口：

• 接口可以理解为一种特殊的类,里面全部是由全局常量和公共的抽象方法组成
• 格式 :  interface 接口名称{}
• 实现格式: class 子类名称 implements 接口1,接口2,…{}
• 一个子类可以同时继承抽象类和多个接口
• 一个接口不能继承一个抽象类,但可以通过extends关键字同时继承多个接口,实现接口的多继承.
• 格式: interface 子类接口名称 extends 父类接口1,父类接口2,…{}

this:

• 表示类中的属性
• 使用this调用构造方法,但必须放在一个方法的起始位置
• 使用this表示当前对象
• 使用this作为参数传递

static:

• 使用static声明属性,表示全局变量
• java内存区域
  1. 栈内存:可以保持对象的名称(保存,访问的堆内存的地址)
  2. 堆内存:保存每个对象的具体属性
  3. 全局数据区:保存static类型的属性
  4. 全局代码区:保存所有方法的属性
• 使用static声明方法: 此方法可以使用类名称进行调用,使用的static方法不能调用非static的属性或反法

final:

• final在java中表示的意思是最终的意思,也可以称为完结器
• 使用final声明的类不能有子类;
• 使用final声明的方法不能被子类所覆写;
• 使用final声明的变量即成为了常量,常量不可以修改.
• 使用 static final联合声明的变量为全局常量.

instanceof:

• 使用instanceof关键字判断一个对象到底是哪个类的实例
• 格式: 对象1  instanceof 对象2;  返回的值是个boolean型的;

Object:

• Object是所有的类的父类
• public int hashCode();取得Hash码
• public String toString(); 对象打印时调用

String:字符串的内容不容易改变

String. valueOf(int i);将数字转换成字符串

String.substring(int 开始点, int结束点),  按位截取字符串

String. toCharArray(); 将字符串变成一个字符数组

String. trim();  清除字符串两边的空格

String.indexOf(String str); 返回一个整数,表示这个字符串在String中的位置

String.indexOf(String str , int  开始查找的位置); 从某一位置开始查找

String. charAt(int index);取出字符串中的一个字符

String. split(String regex);按regex字符串截取String字符串  返回一个字符串数组

String.split(String regex, int limit);limit是截取多少次

String. toUpperCase();将字符串变成大写

String. toLowerCase();将字符串变成小写

String. startsWith(String prefix);判断字符串是否以指定的字符串开始的

String. endsWith(String suffix);判断字符串是否以指定的字符串结尾

String.equals (Object anObject);判断两个字符串是否相等

String.equalsIgnoreCase(String anotherString);不区分大小写判断两个字符串是否相等

String.replace(char oldChar, char newChar);替换字符串;

System:

public static long currentTimeMillis() 返回以毫秒为单位的当前时间

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length) 数组拷贝操作

public static Properties getProperties() 取得当前的系统全部属性(如:System.getProperties().list(System.out);)

public static String getProperty(String key) 根据键值取得属性的具体内容(如:System.out.println(“系统用户:”+System.getProperty(“user.name”));)

protected void finalize() throws Throwable{}  在对象被回收之前进行调用,以处理对象回收前的若干操作,例如释放资源等等.

System.exit(int status);如果status为非0就直接退出程序.

System.gc().运行垃圾回收机制,调用的是Runtime类中的gc方法

System.out.println();向显示屏上输出.

System.errprintln();输出错误信息

System.in;从键盘接受的输入流,是字节流;

5.异常：

• 格式:

　　　　　　　　tyr{ //有可能出现异常的语句 }catch(异常类 异常对象){ //编写异常的处理语句 }finally{ //一定会运行到的程序代码; }

• 在整个java的异常结构中,实际上有以下两个最常见的类:Exception ,Error,这两个类全都是Throwable的子类
• Exception:一般表示的是程序中出现的问题,可以直接使用try…catch处理
• Error:一般指的是JVM错误,程序中无法处理
• throws关键字:使用throws声明的方法表示此方法不处理异常,而是交给反法的调用处进行处理
• 格式:

　　　　　　　　public 返回值类型 方法名称(参数列表…)throws异常类(如:Exception){}

• throw关键字:作用是在程序汇总抛出一个异常,抛出的时候抛出的是一个异常类的实例化对象.
• 断言(assert):就是肯定某一个结果的返回值是正确的,如果最终此结果返回值是错误的,则可以通过断言检查肯定会为用户提示错误信息.
• 格式:
  • • (1) assert boolean 表达式;
    • (2) assert boolean 表达式:  想要输出的信息;
• 查看运行命令: java –ea 编译文件名
• 常见的异常：

Java.lang.NullPointerException 空指针异常

java.lang.ClassNotFoundException 没有发现class异常

java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常

java.lang.ArithmeticException  数学运算异常

java.lang.IllegalArgumentException 方法参数异常

java.lang.IllegalAccessException 没有访问权限异常

java.lang.*Error  堆栈溢出异常

6.多线程：

线程:是程序的一次动态执行过程,它经历了从代码加载,执行到执行完毕的一个完整过程,这个过程也是进程本身从产生,发展到最终消亡的过程.

多线程：是实现并发机制的一种有效手段,进程和线程一样,都是实现并发的一个基本单位.

实现多线程：

1. 继承Thread类：Thread类是在java.lang包中定义的,一个类只要继承了Thread类,此类就称为多线程操作类.在Thread子类之中,必须明确的覆写Thread类中的run()方法.此方法为线程的主体.但调用的时候应该调用start()方法,才能实现并发机构.
2. 实现Runnable接口
   1. Runnable接口中只定义了一个抽象方法: public void run();
   2. 调用Runnable是应该:Thread 线程名字=new Thread(子类方法实例名称);
   3. 线程名称.start();
3. Thread类也是Runnable接口的子类.
4. 区别:使用Thread类在操作多线程的时候无法达到资源共享的目的, 每个Thread实例都是在独自运行自己的线程.使用Runnable接口实现多线程操作可以实现资源共享.
5. Runnable接口比继承Thread类的优点:
   1. 适合多个相同程序代码的线程去处理同一个资源
   2. 可以避免由于单继承局限所带来的影响
   3. 增强了程序的健壮性,代码能够被多个线程共享,代码与数据是独立的.

线程状态：

1. 创建状态:准备好了一个多线程的对象:Thread t=new Thread();
2. 就绪状态:调用了start()方法,等待CUP进度调度
3. 运行状态:执行run()方法;
4. 阻塞状态:暂时停止执行,可能将资源交给其他线程使用
5. 终止状态(死亡状态):线程执行完毕了,不再使用了.

主要方法：

public Thread(Runnable target)   接收Runnable接口子类对象,实例化Thread对象

public Thread(Runnable target,String name)  接收Runnable接口子类对象,实例化Thread对象,并设置线程名称

public Thread(String name)  实例化Thread对象,兵设置线程名称

public static Thread currentThread() 返回目前正在执行的线程

public final String getName()  返回线程的名称

public final int getPriority()   发挥线程的优先级

public boolean isInterrupted() 判断目前线程是否被中断,如果是返回True,否则返回false.

public final boolean isAlive() 判断线程是否在活动,如果是返回true,否则返回false.

public final void join() throws interruptedException 等待线程死亡(强制运行)

public final synchronized void join(long millis)throws InterruptedException 等待millis毫秒后,线程死亡

public void run() 执行线程

public final void setName(String name) 设定线程名称

public final void setPriority(int newPriority) 设定线程的优先值

public static void sleep (long millis) throws InterruptedException 使目前正在执行的线程休眠millis毫秒

public void start() 开始执行线程

public final void setaemon(boolean on) 将开一个线程设置成后台运行

public final void setPriority(int newPriority) 更改线程的优先级

public static void yield() 暂停当前正在执行的线程对象,并执行其他线程

　　注意：如果线程没有名称,则系统会自动的为线程分配一个名称.

优先级：

1. MAX_PRIORITY 最高优先级  10级
2. NORM_PRIORITY  中等优先级 5级
3. MIN_PRIORITY 最低优先级 1级

　　　　注意：主方法的优先级是NORM_PRIORITY

Java运行时至少运行两个线程：

1. java主线程 main方法
2. GC 垃圾收集机制

7.同步与死锁：

同步:就是指多个操作在同一个时间段内只能有一个线程进行,其他线程要等待此线程完成之后才可以继续执行.要想解决资源共享的同步操作问题,可以使用同步代码块及同步方法两种方式完成

同步代码块：

1. 使用synchronized关键字声明的代码块,称为同步代码块
2. 定义格式:  synchronized (同步对象){ 需要同步的代码; }   对象一般是当前对象,使用this表示当前对象
3. 同步代码块没有异步的效率快

同步方法:  和同步代码块运行效果一样;格式: synchronized 方法返回值 方法名称(参数列表){需要同步的代码块;}

死锁: 是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种相互等待的现象,若无外力作用,他们都将无法推进下去,程序中过多的同步会产生死锁

等待与唤醒:Object类对线程的支持

public final void wait() throws InterruptedException 线程等待

public final void wait(long timeout) throws InterruptedException 线程等待,并指定等待的最长时间,以毫秒为单位

public final void wait(long timeout,int nanos) throws InterruptedException 线程等待,并指定等待的最长毫秒及纳秒

public final void notity() 唤醒第一个等待的线程

public final void notityAll() 唤醒全部等待的线程,谁的优先级高先唤醒谁

标志位:设置标志位解决生产者消费者重复取的问题;

8.泛型 Generic：

泛型：可以解决数据类型的安全性问题,它主要的原理,是在类声明的时候通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型,这样在类声明或实例化的时候只要指定好需要的类型即可.

泛型类的定义格式:

[访问权限] class 类名称 <泛型类型1, 泛型类型2,…>{

             [访问权限]泛型类型标识 变量名称;

             [访问权限]泛型类型标识 方法名称(){};

             [访问权限]返回值类型声明 方法名称(泛型类型标识 变量名称){};

}

泛型对象定义：

类名称<具体类> 对象名称=new 类名称<具体类>();

构造方法中使用泛型:  构造方法可以为类中的属性初始化,那么如果类中的属性通过泛型指定,而又需要通过构造设置属性内容的时候,那么构造方法的定义与之前并五不同,不需要像声明类那样指定泛型.

• 格式: [访问权限]构造方法([<泛型类型> 参数名称]){}

9.通配符“？”：

 受限泛型:在引用传递中泛型操作中也可以设置一个泛型对象的范围上限和范围下限.范围上限使用extends关键字声明,表示参数化的类型可能是所指定的类型,或者是此类型的子类,而范围下限使用super进行声明,表示参数化的类型可能是所指定的类型,或者是此类型的父类型,直至Object类

设置上限:

1. 声明对象:类名称< ? extends 类> 对象名称
2. 定义类:[访问权限] 类名称<泛型标识 extends 类>{}

设置下限:

1. 声明对象:类名称<? super 类>对象名称
2. 定义类:[访问权限] 类名称<泛型标识 extends 类>{}

泛型与子类继承的限制:一个类的子类可以通过对象多态性,为其父类实例化,但是在泛型操作中,子类的泛型类型是无法使用父类的泛型类型接收的.

泛型接口:声明泛型类的语法类似,也是在接口名称后面加上<T>

[访问权限]interface 接口名称<泛型标识>{}

定义泛型方法:泛型方法中可以定义泛型参数,此时,参数的类型就是传入数据的类型,使用如下的格式定义泛型方法:

 [访问权限]<泛型标识> 泛型标识 方法名称([泛型标识 参数名称])

泛型数组:使用泛型方法的时候,也可以传递或返回一个泛型数组

10.定时调度：

定时调度:每当一端时间,程序会自动执行,称为定时调度.必须保证程序始终运行着才可以,也就是说是想当于定时调度是在程序之外又启动了一个新的线程.

Timer：是一种线程设施,可以用来实现在某一个时间或某一端时间后,安排某一个任务执行一次,或定期重复执行.该功能要与TimerTask配合使用,TimerTask类用来实现由Timer安排的一次或重复执行的某一个任务.每个Timer对象对应的是一个线程,因为次计时器所执行的任务应该迅速完成,否则可能会延迟后续任务的执行,而这些后续的任务就有可能堆在一起,等到该任务完成后才能快速连续执行.

常用方法：

public Timer()  用来创建一个计时器并启动该计时器

public void cancel() 用来终止该计时器,并放弃所有已安排的任务.对当前正在执行的任务没有影响

public int purge() 将所有已经取消的任务移除,一般用来释放内存空间

public void schedule(TimerTask task,Date time) 安排一个任务在指定的时间执行,如果已经超过该时间,则立即执行.

public void schedule(TimerTask task,Date firstTime,long period) 安排一个任务在指定的时间执行,之后以固定的频率(单位:毫秒)重复执行.

public void schedule(TimerTask task,long delay) 安排一个任务在一端时间(单位:毫秒) 后执行.

public void schedule(TimerTask task,long delay,long period) 安排一个任务在一段时间(单位:毫秒)后执行,之后以固定的频率(单位:毫秒)重复执行

public void scheduleAtFixedRate(TimerTask task,Date firstTime,long period) 安排一个任务在指定的时间执行,之后以近似固定的频率(单位:毫秒)重复执行

public void scheduleAtFixedRate(TimerTask task,long delay,long period) 安排一个任务在一段时间(单位:毫秒)后执行,之后以近似固定的频率(单位:毫秒)重复执行.

schedule()与scheduleAtFixedRate()方法的区别： 两者的区别在与重复执行任务时,对于时间间隔出现延迟的情况处理:

• • schedule() 方法的执行时间间隔永远是固定的,如果之前出现了延迟的情况,之后也会继续按照设定好的时间间隔时间来执行
  • scheduleAtFixedRate()方法可以根据出现的延迟时间自动调整下一次间隔的执行时间.

TimerTask:要想执行具体的任务,则必须使用TimerTask类. TimerTask类是一个抽象类.如果要使用该类,需要自己建立一个类来继承此类,并实现其中的抽象方法.

1) public void cancel() 用来终止此任务,如果该任务只执行一次且还没有执行,则永远不会再执行,如果为重复执行任务,则之后不会再执行(如果任务正在执行,则执行完成不会再执行).

2) public void run() 该任务所要执行的具体操作,该方法为引入的接口Runnable中的方法,子类需要覆写此方法.

3) public long scheduleExecutionTime() 返回最近一次要执行该任务的时间(如果正在执行,则返回此任务的执行安排时间),一般在run()方法中调用,用来判断当前是否有足够的时间来执行完成该任务.

简单示例:

import java.util.TimerTask ;

import java.util.Date ;

import java.text.SimpleDateFormat ;

class MyTask extends TimerTask{ // 任务调度类都要继承TimerTask

     public void run(){

         SimpleDateFormat sdf = null ;

         sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS") ;

         System.out.println("当前系统时间为：" + sdf.format(new Date())) ;

     }

};

import java.util.Timer ;

public class TestTask{

    public static void main(String args[]){

        Timer t = new Timer() ; // 建立Timer类对象

        MyTask mytask = new MyTask() ; // 定义任务

        t.schedule(mytask,1000,2000) ; // 设置任务的执行，1秒后开始，每2秒重复

    }

};

篇幅太长，分为下节：

Java 基础知识总结 2