Java不完全教程
第一章Java预备知识
常用DOS命令
help,dir,md,cd,rd,del,copy,move,start,type,cls,attrib
配置环境变量
JAVA_HOME C:softJavajdk1.6.0_37
Path %JAVA_HOME%bin
第一个程序
public class Hello {
public static void main(String[] args) {
System.out.println("Hello");
}
}
Java三种注释
文档注释 /***/
多行注释 /**/
单行注释 //
启动记事本程序 - DEMO
public static void main(String[] args) throws IOException {
Runtime.getRuntime().exec("notepad");
}
第二章 Java基本语法
Java常量 - 固定不变值
Java变量 - 在内存中分配一块内存,用于保存数据
空: null
基本数据类型
布尔值: boolean
字符: char
整形: byte,short,int,long
浮点型: float,double
引用数据类型
类: String
数组: int[]
类型转换
自动转换 - 低字节类型数据和高字节类型数据参与运算会自动提升类型
强制转换 - 将高字节数据强制转换成低字节数据,会丢失精度或者结果错误
第三章 运算符与逻辑判断循环
算数运算符 + - * / % ++ --
赋值运算符 = += -= *= /= %=
比较运算符 == != = instanceof
逻辑运算符 & | ^ ! && ||
位运算符 & | ^ > >>>
三元运算符 boolean?"":"";
选择结构 if…else switch
循环结构 for while do…while
控制循环 continue break return
在不知道x和y值的情况下,交换这个两个变量中的值
int x=10, y=6; x+=y; y-=x; x+=y; y*=(-1); System.out.println(x+" "+y);
int a=10, b=6; a+=b; b=a-b; a-=b; System.out.println(a+" "+b);
int i=10, j=6; i^=j; j=i^j; i^=j; System.out.println(i+" "+j);
在三个数中找到最大的那个数
int x=10,y=20,z=30;
int max = x>y?(x>z?x:z):(y>z?y:z);
System.out.println(max);
计算1+2+3+…+100的和
int sum=0,i=0;
for(;i0) {
sb.append(num%2);
num/=2;
}
sb.reverse();
System.out.println(sb);
第四章 函数和数组
函数 - 代码在程序中需要多次使用,就可以定义成函数,在需要使用的时候调用
函数的重载 - 函数名称相同,参数列表不同,返回值不同
数组 - 类型一致长度不可变通过索引操作元素的容器
数组相关函数
Arrays.toString() 数组转换成字符串
System.arraycopy() 数组深拷贝
将数组中所有元素打印成一行并以逗号分割
private static String arrayToString(int[] array) {
if (array!=null && array.length>0) {
String s = array[0]+"";
for (int i = 1; i array[middle]) {
start = middle + 1;
}else if (key number?line:number;
}
System.out.println(number);
}
递归求1+2+...
public static int getSum(int n) {
return n==1?1:getSum(n-1)+n;
}
第五章 面向对象
封装 – 对内部变量私有化,对外部提供公有方法
代码块 - 在创建对象时代码块会自动运行
构造函数 – 函数名与类名相同没有返回值类型
this - 那个对象调用该方法,this就代表那个对象
static - 内存中对象是唯一的
extends - 子类继承父类的方法和属性
super - 子类调用父类的方法和属性
向上转型 - 子类当做父类使用,不能调用子类特有的方法
向下转型 - 子类当做父类使用,需要调用子类特有的方法,需要将父类强制转化成子类
方法重写 - 子类必须与父类具有相同函数名,参数列表和返回值
多态 – 将函数的形参定义为父类类型,传入不同的子类而实现不同的功能
abstract – 父类定义抽象方法,需要在子类实现该方法
final – 对象不能继承,方法不能重写,变量不能修改
interface – 接口中所有的方法都需要在子类中实现
implements – 一个类实现接口
内部类 – 在一个类中嵌套另一个类
package – 定义类所属的包
import – 导入包中的类
定义对象
public class Person {
private String name;
private Integer age;
}
创建对象
public static void main(String[] args) {
Person p = new Person();
}
模拟电脑开/关机
public class ComputerDemo {
private static class Computer {
private String name;
private MainBoard mainBoard;
private Boolean state;
public Computer(){}
public Computer(String name, MainBoard mainBoard) {
this.name = name;
this.mainBoard = mainBoard;
this.state = false;
}
public void trunOn(){
if(mainBoard==null){
System.out.println(name+" 没有安装主板不能开机");
}else{
if (state) {
return;
}
mainBoard.run();
System.out.println(name+" 开机成功");
state = true;
}
}
public void trunOff(){
if (state) {
mainBoard.stop();
System.out.println(name+" 关机成功");
state = false;
}else {
System.out.println("电脑还没有开机");
}
}
}
private static class MainBoard {
private String name;
public MainBoard(){}
public MainBoard(String name) {
this.name = name;
}
public void run(){
System.out.println(name+" 已启动");
}
public void stop() {
System.out.println(name+" 停止运行");
}
}
public static void main(String[] args) {
Computer c = new Computer("ThinkPad T420", new MainBoard("华硕主板"));
c.trunOn();
c.trunOff();
}
}
模拟超市购物
@SuppressWarnings("unused")
public class ShoppingDemo {
private static class Product {
private String name;
public Product() {}
public Product(String name) {
this.name = name;
}
}
private static class Market {
private String name;
private Product[] products;
public Market(){}
public Market(String name, Product[] products) {
this.name = name;
this.products = products;
}
public Product sell(String name){
for (int i = 0; i =4) {
c.add(c.DATE, 1);
c.set(c.HOUR_OF_DAY, 4);
c.set(c.MINUTE, 0);
c.set(c.SECOND, 0);
}
Timer timer = new Timer();
timer.schedule(new MyTask(), c.getTime(), 1000*60*60*24);
}
}
线程之间共享数据
public class SharedThreadData {
private static class ShareadData {
private static ThreadLocal threadLocal = new ThreadLocal();
private String name;
public void setName(String name) {
this.name = name;
}
public static ShareadData getShareadData() {
ShareadData data = threadLocal.get();
if (data == null) {
data = new ShareadData();
threadLocal.set(data);
}
return data;
}
public String toString() {
return "ShareadData [name=" + name + "]";
}
}
private static class A {
public void get(){
System.out.println(Thread.currentThread().getName()+" A.get Data: "+ShareadData.getShareadData());
}
}
private static class B {
public void get(){
System.out.println(Thread.currentThread().getName()+" B.get Data: "+ShareadData.getShareadData());
}
}
public static void main(String[] args) {
new Thread(){
public void run() {
ShareadData data = ShareadData.getShareadData();
data.setName("张三");
System.out.println(Thread.currentThread().getName()+" set Data: "+data);
new A().get();
new B().get();
}
}.start();
new Thread(){
public void run() {
ShareadData data = ShareadData.getShareadData();
data.setName("李四");
System.out.println(Thread.currentThread().getName()+" set Data: "+data);
new A().get();
new B().get();
}
}.start();
}
}
原子类型 – 数据在操作的过程中不会执行其他线程
import java.util.concurrent.atomic.AtomicInteger;
public class Exercise {
private static class Service {
private AtomicInteger integer = new AtomicInteger();
public void increment() {
System.out.println(Thread.currentThread().getName()+" incr,x = "+integer.addAndGet(3));
}
public void decrement() {
System.out.println(Thread.currentThread().getName()+" decr,x = "+integer.addAndGet(-3));
}
}
public static void main(String[] args) {
final Service service = new Service();
for (int i = 0; i submit = cachedThreadPool.submit(new Callable() {
public String call() throws Exception {
System.out.println("任务开始");
Thread.sleep(3000);
System.out.println("任务结束");
return "result";
}
});
cachedThreadPool.execute(new Runnable() {
public void run() {
try {
System.out.println("等待结果");
System.out.println("执行成功:"+submit.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
});
cachedThreadPool.shutdown();
System.out.println("执行其他任务");
}
}
批量添加任务之后获取最先完成的任务的返回结果
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPool {
public static void main(String[] args) throws Exception {
ExecutorService executorService = Executors.newCachedThreadPool();
ExecutorCompletionService completionService = new ExecutorCompletionService(executorService);
for (int i = 0; i () {
public String call() throws Exception {
int ms = new Random().nextInt(3000);
System.out.println("任务"+task+", 需要"+ms+"毫秒");
Thread.sleep(ms);
return "任务"+task+"已完成";
}
});
}
for (int i = 0; i tl = new ThreadLocal
