发布于 2017-04-13 14:15:58 | 138 次阅读 | 评论: 0 | 来源: 网友投递

这里有新鲜出炉的Java并发编程示例，程序狗速度看过来！

Java程序设计语言

java 是一种可以撰写跨平台应用软件的面向对象的程序设计语言，是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台（即JavaEE(j2ee), JavaME(j2me), JavaSE(j2se)）的总称。

---

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:字符串的内容不容易改变

1. 1. String. valueOf(int i);将数字转换成字符串
   2. String.substring(int 开始点, int结束点), 按位截取字符串
   3. String. toCharArray; 将字符串变成一个字符数组
   4. String. trim; 清除字符串两边的空格
   5. String.indexOf(String str); 返回一个整数,表示这个字符串在String中的位置
   6. String.indexOf(String str , int 开始查找的位置); 从某一位置开始查找
   7. String. charAt(int index);取出字符串中的一个字符
   8. String. split(String regex);按regex字符串截取String字符串 返回一个字符串数组
   9. String.split(String regex, int limit);limit是截取多少次
   10. String. toUpperCase;将字符串变成大写
   11. String. toLowerCase;将字符串变成小写
   12. String. startsWith(String prefix);判断字符串是否以指定的字符串开始的
   13. String. endsWith(String suffix);判断字符串是否以指定的字符串结尾
   14. String.equals (Object anObject);判断两个字符串是否相等
   15. String.equalsIgnoreCase(String anotherString);不区分大小写判断两个字符串是否相等
   16. String.replace(char oldChar, char newChar);替换字符串;

System:

1. 1. public static long currentTimeMillis 返回以毫秒为单位的当前时间
   2. public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length) 数组拷贝操作
   3. public static Properties getProperties 取得当前的系统全部属性(如:System.getProperties.list(System.out);)
   4. public static String getProperty(String key) 根据键值取得属性的具体内容(如:System.out.println(“系统用户:”+System.getProperty(“user.name”));)
   5. protected void finalize throws Throwable{} 在对象被回收之前进行调用,以处理对象回收前的若干操作,例如释放资源等等.
   6. System.exit(int status);如果status为非0就直接退出程序.
   7. System.gc.运行垃圾回收机制,调用的是Runtime类中的gc方法
   8. System.out.println;向显示屏上输出.
   9. System.errprintln;输出错误信息
   10. 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.StackOverflowError 堆栈溢出异常

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. 终止状态(死亡状态):线程执行完毕了,不再使用了.

主要方法：

1. public Thread(Runnable target) 接收Runnable接口子类对象,实例化Thread对象
2. public Thread(Runnable target,String name) 接收Runnable接口子类对象,实例化Thread对象,并设置线程名称
3. public Thread(String name) 实例化Thread对象,兵设置线程名称
4. public static Thread currentThread 返回目前正在执行的线程
5. public final String getName 返回线程的名称
6. public final int getPriority 发挥线程的优先级
7. public boolean isInterrupted 判断目前线程是否被中断,如果是返回True,否则返回false.
8. public final boolean isAlive 判断线程是否在活动,如果是返回true,否则返回false.
9. public final void join throws interruptedException 等待线程死亡(强制运行)
10. public final synchronized void join(long millis)throws InterruptedException 等待millis毫秒后,线程死亡
11. public void run 执行线程
12. public final void setName(String name) 设定线程名称
13. public final void setPriority(int newPriority) 设定线程的优先值
14. public static void sleep (long millis) throws InterruptedException 使目前正在执行的线程休眠millis毫秒
15. public void start 开始执行线程
16. public final void setaemon(boolean on) 将开一个线程设置成后台运行
17. public final void setPriority(int newPriority) 更改线程的优先级
18. 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类对线程的支持

1. public final void wait throws InterruptedException 线程等待
2. public final void wait(long timeout) throws InterruptedException 线程等待,并指定等待的最长时间,以毫秒为单位
3. public final void wait(long timeout,int nanos) throws InterruptedException 线程等待,并指定等待的最长毫秒及纳秒
4. public final void notity 唤醒第一个等待的线程
5. public final void notityAll 唤醒全部等待的线程,谁的优先级高先唤醒谁

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