JavaSE

最新推荐文章于 2021-06-30 16:10:33 发布
最新推荐文章于 2021-06-30 16:10:33 发布
阅读量201 收藏
点赞数
分类专栏： SE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43660093/article/details/97159413
版权

文章目录

数组

  • 缓冲区定义，IO流，内存绘制

    int[] arr1 = new int[100];

  • 便捷式定义，基本类型+常量引用类型

    int[] arr2 = {1,2,3,4};

  • 标准定义

    int[] arr3 = new int[] {11,22,33,44};

    int a = arr1[1];	//索引从0开始
    		arr1[0] = 2000;
    		for(int i=0; i<arr1.length; i++) {
    			System.out.println(arr1[i]);
    		}
    		for(int c:arr2) {
    			System.out.println(c);
    		}
  • Arrays 数组工具类

copy,tostring,search,sort

变量

类型 变量名 = 值

  1. 局部变量 有效范围: 上级{ }有效 在大括号内有效 int a = 1; 临时变 量 中途运算使用, 可以被替代.
  2. 实例变量 定义在类里面
    1. 有效范围:
      (1) 当前类内,实例有效.
      (2) 在类实例 中也有效
    2. 用途:
      (1) 对象特征使用(对外使用)
      (2) 多个方法使用(内部处理的方法调用)
  3. 参数变量 实参 形参 方法内有效
    • 用途:行为的必然条件(方法运行的条件)
  4. 返回值变量
  5. 静态变量 (全局变量)
    • 有效范围是全部范围 (static int xx = 10;) 全部 只用一个值 book.xx = 0;
  6. 静态常量 全部范围 (枚举淘汰)
    • 用途:方法参数标注 (Font.BOLD) 类型 int 但又不是常量,用方法 + . 找到静态常量

基础类型8种

基础类型bytebooleanshortcharintfloatlongdouble
引用类型ByteBooleanShortCharacterIntegerFloatLongDouble
字节11224488

byte -128 到127
boolean 右边一位有效
short 无符号整数
char 系统编码集字符位置，两种形态
int 整型
float 单精度小数
double 双精度小数
long 长整型
基本类型默认值为0

引用类型

全部继承自Object，是一种包装类,服务于基本类型,两种类型可以直接相互转换.(默认)

  • 指针操作:
    1. 变量赋值 = 指针复制
    2. 方法参数进入或返回 = 指针复制
    3. 如果对象为null = 移除指针
    4. 使用 new 新对象 = 创建指针
    5. 基本类型默认值(字节) = 0; boolean = false;
    6. 引用类型默认值 = null;
  • 垃圾回收:
    1. 基本类型 – 有效范围
    2. 引用类型 – 指针关联
    3. 线程控制 -> 相对控制
    4. 垃圾回收 -> 回收100%基本不可能(子循环)
    5. finalize() 可以消除所有指针

虚拟机（容器）

  1. 变量栈: 基本类型值,引用类型指针
  2. 变量堆: 对象数据区域
  3. 方法栈

对象间通讯

  1. 方法参数
  2. static (全局公共变量)
  3. 接口通知 (为重要)
  4. 代理

方法

  • 构建方法是累加构建: 先在Object类中逐渐增加,到终的类实例
  1. 构造方法 : 创建实例,只能用于new 后面 无返回信息,名称为类名
  2. 实例方法 : 行为方法(指当前对象的实际行为) 对象实例的功能
  3. 静态方法 : 函数 代码过程的封装
  4. 静态块 : static{ … } 自动执行 类加载完成时执行一次 (配置信息加载)
  5. 动态块 : { … } 自动执行 每个实例创建完成时执行一次 (对象实例初始 化批量使用)

方法重写

@Override
把父类行为进行细节重写，方法内容替换

@override 
public String toString() { 
 	return super.toString(); 
 }

方法重载

  • (方法名一致,参数类型或顺序不同) 返回值不计(有返回值的不能重 载为无返回值)
  • 核心: 目标处理方法只有一个,其他只做类型转换和默认值处理
 public void jx(){ 
   	jx("OK",100); 
 } 
 public void jx(player e){
   	jx(e.name,e.age); 
  } 
 public void jx(String,int age){ 
   //寄信 目标处理方法 
  }

构造方法

  • (一个默认) 存在其他构造方法时,应把默认构造方法写出来,否则就消失了
  • 如果构造方法私有,将不能创建对象
  • eclipse右键 Source : using fields
 public player(){ 
 } 
 public player(String name){ 
  	name = "YC"; 
 }

属性方法

  • eclipse右键 Source : getters and setters;
  • 行为方法:出现find方法是容器
  1. 属性读写标准 : 以 get ,set ,is 打头的都为属性方法;
  2. 解释对象(方法排除) : 可以了解类的本质作用(存在即可控)

类

  1. 主类
  2. 包类(辅类) 默认 friendly 同文件的其他类 (不能加描述)
  3. 子类(静态子类):
    • 不是静态子类new才能使用
      d1 d = new ss().new d1();
    • 静态子类直接使用
      d2 b = new ss.d2();
  4. 内部匿名类

String（定长字符串）

  • 有内部构建器，不用new实例化
  • final char[] value() 每定义一个新变量就会生成 一个新的内存常量池,再次使用时不会创建新的.

String str = “11”;
str += “333”;
其中有3个内存变量 : 11 str 333

  • 方法：
    1. str.indexOf() 按位置查找
    2. str.lastindexOf() 倒序位置查找
    3. str.equalsIgnoreCase() 忽略大小写判断是否相同
    4. str.toUpperCase().toLowerCase() 转换为大小写(返回一个新的字符 串) 方法连用
    5. str.subString() 剪切字符串
    6. str.charAt() 查询某个字符
    7. str.trim() 去除两边空格
    8. byte[] pos = str.getBytes() 将字符串转化为字节数组 new String(pos) 转化为字符串
    9. str.replace() 替换字符串
    10. str.split() 转化为数组
String str = "11,2,2,3,3,24,312231,21";
String[] pos = str.spilt(",");
for(String s:pos) {System.out.println(s); }

StringBuffer

  • StringBuffer(变长字符串,线程安全) 增删改查
  • synchronized 线程安全锁定

StringBuilder

  • (变长字符串) 真正的方法连用 增删改查
StringBuilder b = new StringBuilder();
b.append("1212");
String bb = b.toString();

BigDecimal

  • 超长常规运算类
  • 加减乘除绝对值5个方法

DecimalFormat

  • 字符串格式转化
 double s = 12; 
 DecimFormat f = new DecimalFormat("0.000");
 System.out.println(f.format(s));

Math

  • Math.floor() 四舍五入

Date

 Date d = new Date(); //默认为当天现在 
 long t = d.getTime(); //时间戳 : 1970年0时0分0秒 为起点到现在的毫秒数
  • SimpleDateFormat 日期数字格式转化
SimpleDateFormat f = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss ms"); //HH 是24小时制 , hh是12小时制 
System.out.println(f.format(new Date()));
  • Calendar(超类,抽象类) 日期运算
Calendar c = new Calendar(){ }
  • GregorianCalendar(万年历)
GregorianCalendar c = new GregorianCalendar(); 
‐‐‐‐‐‐‐波动日历‐‐‐‐‐‐‐‐‐
c.add(GregorianCalendar.YEAR,‐5000); //5000年前的今天 
c.add(GregorianCalendar.MONTH,‐10); //10月前的今天 
c.add(GregorianCalendar.DAY_OF_YEAR,‐20); //20天前
‐‐‐‐‐ ‐设置日历‐‐‐‐‐‐‐‐‐
c.set(GregorianCalendar.DAY_OF_WEEK,2); //本周的星期一 
 c.set(GregorianCalendar.MONTH,3); //本年的第4个月
‐‐‐‐‐‐‐获取日历信息‐‐‐‐‐
c.add(GregorianCalendar.YEAR,‐20); // 20年前的今天是星期几 11 c.get(GregorianCalendar.DAY_OF_WEEK);

Random

Random r = new Random(); 
	System.out.println(20015+r.nextInt(13)); //20015 ‐ 20027 之间的随机数 
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
public int Random(int min,int max){ 
	return new Random().nextInt(max‐min+1)+min; 
}

访问操作符

  1. public 全公开
  2. friendly 包内全公开
  3. protected 包内全公开,包外子类可用
  4. private 全私有 (只有自身类可用)
  5. static 静态的(脱离实例运行)
    变量 全局 方法 函数 子类 可直接访问的
  6. final 常量的(不可变更的)
    • 用于变量 代表常量：
      ①基本类型 完全不能改变
      ②引用类型 不能更改指针 可以改值（不能改栈）
    • 方法 ：不可重写 不能修改方法栈
    • 类 ：不可继承 类标识被封锁

面向对象

核心：
把细节忽略，先分块；
对象描述；
编写代码。

面向业务实施事务的开发思维

  1. 类的定义: 具体事物的抽象
  2. 对象特征:
    • 属性 : 特征 区别(无限) 按需求定制
    • 方法 : 行为 动词打头的方法名 修改自身属性为目标(方法内容) 自外向内发出的通知
    • 事件 : 对事的响应 自内向外发出的通知 全部由方法发起
  3. 面向对象特征:
    • 继承 : 复制
    • 封装 :
      • ①访问范围封装 public
      • ②功能封装(框架)
    • 多态 : 方法重写 方法重载

Object类

  • 唯一性
  • 可描述
  1. 方法（IDE中的显示）：
    颜色：
    a. 红色：私有private
    b. 绿色：公有public
    c. 黄色：保护protect
    d. 蓝色：友好friendly
  2. Clone 克隆方法（protect）
    a. 浅克隆：把指针指向的内存内容直接复制（指针指向同一块内存）
    b. 深克隆：复制内容到另一块内存，指针不同
  3. hashCode 唯一标识
  4. Equals 两个指针（唯一标识）是否相等 （对象判断）
    “==”（基本类型判断）
  5. Finalize 通知垃圾回收
  6. getClass 获取类表述类（用于反射）
  7. Notify 、wait 线程锁处理
  8. toString 类描述信息

操作符

  1. %：3%5=3 周期运算
  2. +=：前自增++I 后自增i++ 顺序运算
  3. &&：逻辑运算符（前面flase后面不在处理）
  4. &：位运算符（处理全部条件）

位运算

  1. &：与
  2. |：或
  3. ^：异或
  4. ~：非
  5. “ >>”：右移位
  6. “>>>”：右移补零
  7. <<：左移位

强制转换

  1. byte = (byte) i ; 基本类型(位截取)
  2. 引用类型没有强制类型转换: 更改称呼
player y = new player(); 
Object o = new park(); 
player t = (player) o; 
Error: ClassCastException (类型转换错误) 

player y = new player(); 
Object o = y; // y 和 o 指针是同一个 
player t = (player) o;

抽象

抽象类

  1. 抽象类：
    a. 存在抽象方法的类必然为抽象类
    b. 不存在抽象方法也可以定义为抽象类（臆想）
  2. 抽象方法：abstract 只有描述，没有方法体
public abstract class abs { 
public abstract void save(); //没有方法体的方法,只有抽象描述 
}
  1. 内部匿名类：是一个类，在方法内定义，名称为父类的名称
    a. 通过重写抽象方法，完成类实例调用
    b. 通过重写抽象方法，完成接口实例调用
    c. 快捷类重写定义
    d. 内部定义变量、方法，外部将不能访问（反射通过内存访问）
    e. 可以直接调用所在方法内定义的final变量
    (Final : 基本类型是常量 引用类型是变量)
//内部匿名类
 abs1 = new abs1(){
    public void save(){ //必要性重写,抽象方法 } 
   }

接口

  • 具体事物的抽象的抽象
    ①多命名
    ②接口里面全部都是抽象方法
  • 作用
    ①标准化
    ②起别名
    ③批处理
    ④隐瞒角色
    ⑤减少耦合度
  • 可以放的东西：
    ①抽象方法
    ②静态常量 public static final int max = 1111;
    ③默认方法(通用型运算) defalut void xx(){ … }
  • 运动员实例
  • usb接口实例：见接口实例

关键字（this，super）

  • this： 当前实例本身
    ①特指当前实例

      int count; 
  public void setCount(int count){ 
  this.count = count; 
 }

    ②构造方法转接

      public computer(){ 
   this(100); 
  } 
  public computer(int count){ 
   this.count = count; 
  }

    ③在内部类里调用上级实例 (静态方法不能使用 Static)

      int count = 100; //上级实例 
  usb u = new usb() {
  public void sendMsg(String msg) { 
  telephone.this.count = 200; //调用count 
  } 
  };

  • super : 当前实例本身上级描述
    ①toString 调用上级方法

     public String toString(){ 
  return super.toString(); 
 }
 

     class ss extends computer{ 
  public ss(){ 
  super(123); 
  } 
 }

集合

  • 接口：（Collection 超类接口）
    1. List（按序放置，按索引获取）

      • ArrayList （典型的变长数组）

         ArrayList<String> list = new ArrayList<>(); 
 list.add("www");

      • Vector （线程安全 方法上加入关键字synchronized）对空值不支持

        Vector<String> vec = new Vector<>();

      • LinkedList （ 双向链表，插入快（队列处理，FIFO，LIFO））

        • +first-last先进先出
        • +pop-push后进先出
        LinkedList<String> list1 = new LinkedList<>();
    2. Set （按集合内置顺序放置，无索引，不重复，循环遍历）

      • HashSet（根据hash值放置）

        HashSet<String > set = new HashSet<>();

      • TreeSet（根据内容值放置，排序集合，必须支持Comparable接口）

    3. Map（键值对集合，以键（index）的内容进行处理）

      • HashMap

        • containsKey（判断键存不存在）

        • put（）；get（）；remove（）；

        • 遍历：
          Set<Entry<String, String>> set = map.entrySet();

           Set<String> set = map.KeySet();
 Collection<String> set = map.values();

      • TreeMap（根据Key值排序放置，必须支持Conparable接口）

      • Hashtable（线程安全，方法上加上synchronized）

异常

  • 常见异常
    1. Throwable 所有错误

      1. Error 不可捕获

        • Unresolved compilation problems：编译错误
        • Memory out error：内存超出错误

      2. Exception 可捕获
        //处理可能出现异常代码
        try {
        //正常运行代码
        }
        //解决方案（可多个，按上下顺序分别捕获）
        catch (Exception e) {
        // 解决错误
        }

        1. java.lang.NullPointerException：空指针异常
        2. java.lang.NumberFormatException：数字转换异常
        3. java.lang.ClassCastException：类转换异常（强制转换错误）
        4. java.lang.ArrayIndexOutOfBoundsException：数组索引超出范围
        5. java.lang.IoException：文件传输错误
        6. java.lang.SqlException：数据库异常

      3. 异常解决：（console窗口）

        1. 异常类型（名称）
        2. 异常信息错误描述
        3. 异常栈（异常用户代码行）

      4. 自定义异常：

        1. 创建异常类 继承exception
        2. 重写getMessage（）方法
        3. 触发异常：throw new AgeOutBoundException(age);
        4. 在异常内加入属性+构造方法，详细描述异常信息：return age+“岁-年龄已经超出范围”;

      5. Throw：抛出异常到catch（有错误要解决）

      6. Throws：抛出异常到方法外（调用方解决）

      7. Finally ：必须运行（return时使用）

      8. printStackTrace()；

    2. Debug调试
      1. 断点：运行到断点时线程挂起
      2. debug运行：程序在断点挂起
      3. 查看修改变量/断点管理
      4. 控制运行：F5（跳入到方法里），F6（下一行），F7（跳出到上一级），F8（继续下个断点）

IO流

  • BIO同步阻塞IO流：（单线程）
    适用：链接少，数据量小，频率低
    读（read）：输入流
    写（write）：输出流
    1. 创建流
    2. 读写
    3. 关闭流

  1. 字符流：
    Reader r；
    Writer w；
    //写

    FileWriter f = new FileWriter("c://a.txt");
			f.write("aaa");
			f.close();

    //读

    FileReader w = new FileReader("c://a.txt");
			char[] data = new char[1000];	//内存缓冲区
			int len = w.read(data);
			data = Arrays.copyOf(data, len);
			System.out.println(new String(data));
			w.close();

  2. 字节流：
    InputStream i;
    OutputStream o;
    //写

    FileOutputStream f = new FileOutputStream("c://a.txt");
			f.write("aaaaa".getBytes());
			f.close();

  3. 流对象：
    ByteArrayOutputStream 获取字节数组 toByteArray()
    DataOutputStream 获取各种类型数据
    ObjectOutputStream 对象序列化
    FileOutputStream 文件流
    ZipOutputStream 压缩文件处理

    1. 流管道：
      有目的地的管道
      FileOutputStream f = new FileOutputStream("c://b.txt");
      目的位其他流
      ObjectOutputStream o = new ObjectOutputStream(f);

    2. 对象序列化（Serializable接口）：自动序列化

      FileOutputStream f = new FileOutputStream("c://b.data");
			ObjectOutputStream o = new ObjectOutputStream(f);
			o.writeObject(new stu("12",123));
			o.close();
			f.close();

    3. 反序列化：

      	FileInputStream f = new FileInputStream("c://b.data");
			ObjectInputStream o = new ObjectInputStream(f);
			stu t = (stu) o.readObject();
			o.close();
			f.close();

      版本号：serialVersionUID （号码相同可用）
      序列化内容：

      1. 版本信息
      2. 类描述信息（类全名）
      3. 属性值信息（要求全部支持序列化）

    4. 自定义序列化接口：Externalizable

      Public void writeExternal（ObjectOutput out）throws IOException{
		Out.writeInt（age）；
	}
	Public void readExternal（ObjectInput in）throws IOException，ClassNotFoundException{
		Age = in.readInt（）；
}

  4. zip压缩流

    	 try{ 
 		  FileOutPutStream f = new FileFileOutPutStream("C://b.zip"); 
		  ZipOutPutStream z = new ZipOutPutStream(f); 
 		  inputfile(z,new File("d://aaaa/")); 
 			 z.close; 
 		 	f.close; 
 		 }catch(Exception e){ 
 		  e.printStackTrace(); 
 	 }

     private static void inputfile(ZipOutputStream z, File f) throws Exception{ 
  	if(f.isDirectory()){
 		 File[] fs = f.listFiles(); 
	  for(File f1:fs) inputfile(z,f1); 
 		 return; 
 	 } 
 	 z.putNextEntry(new ZipEntry(f.getName()));
	  System.out.println(f.getPath()); 
 	 FileInputStream fi = new FileInputStream(f); 
 	 byte[] tempbytes = new byte[100]; 
 	 int byteread = 0; 
 	 while((byteread = fi.read(tempbytes))!=‐1){ 
 	 z.write(tempbytes,0,byteread); 
 	 } 
 	 fi.close(); 
	 }
  • blocking IO 同步阻塞 (以上) ->频率低,数据量小
  • NON blocking IO 同步非阻塞 ->网络处理 ,频率高,数据量小
  • asynchronous NON blocking IO 异步非阻塞 ->超大并发 ,频率高, 数据量大
  • AsynchronousFileChannel
    Buffer : 缓存区
    Channel : 频道
    Selector : 网络通信

    1. 创建

      	FileInputStream  fi1  =  new  FileInputStream(f);//创建
	FileChannel  c  =fi1.getChannel();//创建频道

    2. 缓存区

       ByteBuffer buf = ByteBuffer.allocate(48); //创建缓冲区

    3. 读写

      int bytesRead = inChannel.read(buf); //从缓冲区读取

    4. 完成

      	buf.flip(); //重置读取过程
	buf.clear(); //清空完成.

枚举

  • 枚举: 无法继承, 不需构造方法 sex s = sex.nan;

    1. 定义

       enum { 
  nan ,nv 
 }

    2. 分支使用 Switch选择:

      	switch(s){
	case nan:
	break;
	case nv:
	break;
 }

    3. 高级定义 : 访问时可以通过 .getVal() 获取选择值

      1. 项目有值

      2. 只读属性

      3. 私有构造方法+参数

        enum sex{
	nan=100 ,nv=101;
	private int val;
	public int getVal(){
	return val;
	}
	private sex(int val){
	this.val = val;
	}
  }

泛型 - 广泛

  1. 定义:
    1. 类定义
      public class ff <T extends Number,R,S,D> { ... }
    2. 接口定义
      interface b1<T>{ ... }
    3. 方法定义: 决定方法内的类型
      Public <C> Void test(C c) { ... }
    4. 继承引用
      public class ff <T extends Number,R,S,D> implements b1<T >{ ... }
    5. 泛型约束
      public class ff <T extends Number>
  2. 使用:

    1. 容器使用 ArrayList 创建时确定类型,获取时同样明确类型,不需强制转换或判断 不适合对泛型数据进行业务处理,只能取放 核心: 不必强制转换

    2. 类型传递

      	public  class  a2<T>  implements  b1<T>  {
	public  static  void  main(String[]  args)  {
	a2<Integer> a = new a2<Integer>();
	a.add(123123);
	a.get(index);
	}
	ArrayList<T>  list  =  new  ArrayList<>();
	public T get(int index) {
	return list.get(index);
	}
 }

反射

  • JAVA源码文件 ,类文件(磁盘上) ,类加载器 ,字节码(内存里)

    • 创建对象 : 字节码描述过程
    • 反射原理 : 对字节码直接操作完成类的操作
    1. ①找到字节码
      Class 指向字节码的描述 (类 - 字节码 的描述类)
      1. Class cls = 类名.class;
      2. Class cls = 类实例[new a1()] .getClass();
      3. Class cls = Class.forName(“包名+类名”);
      4. 类加载器通过地址加载(类不在项目里面)
    			URL[]  urls  =  new  URL[]  {  new  URL("file:///C:/a/")  };
			URLClassLoader  loader  =  new  URLClassLoader(urls);
			Class  cls  =  loader.loadClass("zz.math");

    1. 创建对象 : 多参 & 私有

      1. 即将淘汰 (1.9)
        Object o = cls.newInstance(); //创建实例

      2. 默认构造方法
        Constructor c = cls.getConstructor(); //获取默认构造方法 Object o = c.newInstance();

      3. 指定参数构造方法
        Constructor c = cls.getConstructor(String.class); //获取指定参数String构造 方法 Object o = c.newInstance("ssss");

      4. 获取public的全部构造方法
        Constructor[] cs = cls.getConstructors();

      5. 获取定义的全部构造方法
        Constructor[] cs = cls.getDeclaredConstructors(); cs.setAccessible(true); // 忽略访问权限

      6. 获取方法修饰

        int a = c.getModifiers() //获取方法修饰 
		if (a|Modifier.PUBLIC==0){ 
		  多个修饰按位获取; 
		   }

    2. 属性处理

       Field f = cls.getField("count"); 
 f.set(obj,value); 
 Object o = f.get(obj);

    3. 方法处理 : Static 方法运行不需实例 o = null;

      1. 获取方法
        Method m = cls.getMethod("add",int.class,int.class);
      2. 执行 invoke + 返回值
        Object V= m.invoke(o,203,306).toString(); // o:实例对象
      3. 忽略访问权限
        m.setAccessible(true);

    4. 其他处理 获取返回值

       Method m = cls.getMethod("add",int.class,int.class); 
 Class <?> returncls = m.getReturnType(); 
 System.out.println(returncls.getName()); 
  cls.getSuperClass(); 
  cls.getInterface();

  • 核心:

    1. Class对象获取
    2. 可获取类内全部描述
      1. 获取public的一个 getConstructor();
      2. 获取定义的一个 getDeclaredConstructor();
      3. 获取public的全部 getConstructors();
      4. 获取定义的全部 getDeclaredConstructors();
      5. 设置安全检验 setAccessible(true);
    3. 执行时需要实例(Static时为null)
    4. 参数对应(查询时和执行时)

  • 反射的目的是控制反转

    	public  void  exec(String  classname,String  mname,Object...parms)  {
	try {
	Class<?>  cls  =  Class.forName(classname);
	Object  o  =  cls.newInstance();
	Class  []  parameterTypes  =  new  Class[parms.length];
	for(int  i  =0;i<parms.length;i++)
	parameterTypes[i]=parms[i].getClass();
	Method  m  =  cls.getDeclaredMethod(mname,parameterTypes);
	m.setAccessible(true);
	System.out.println(m.invoke(o,  parms));
	} catch (Exception e) {
	e.printStackTrace();
	}
 }
	public  static  void  main(String[]  args){
	new  math().exec("zz.jsp",  "reduce",  128,123);
	}
 }

    	public class jsp {
	public  int  add(Integer  a,Integer  b)  {
	return a+b;
	}
	public  int  reduce(Integer  a,Integer  b)  {
	return a‐b;
	}
 }

  • 控制反转 : ioc

设计模式

工厂模式（背）

  • 简单工厂（工厂，产品，由工厂方法返回产品实例）
  1. 创建工厂类
  2. 创建生产方法
  3. 执行生产方法，获得产品实例
  • 抽象工厂
  1. 产品类加入接口（多个产品类）
  2. 工厂类加入接口（多个工厂类，每个工厂生产不同产品）
  3. 创建总工厂类，根据名称选择工厂生产商品

建造者模式

  • 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
    • Product
    • Builder（产品建造方法）
    • Director

单态模式（背）

  • 只能创建唯一实例
public class Singleton {
    
    private static Singleton sing;

    private Singleton() {
        
    }
    
    public static Singleton getInstance() {
        if (sing == null) {
            sing = new Singleton();
        }
        return sing;
    }
}

原型模式：

  • 通过克隆完成实例构建（克隆方法）

代理模式（背）

观察者模式（背）

代理

  • Java代理模式
  • Jdk代理
		stu t= new stu();
		myadd p= (myadd) Proxy.newProxyInstance(stu.class.getClassLoader(),
					stu.class.getInterfaces(), 
					new InvocationHandler() {
						@Override
						public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
							System.out.println("代理的额外内容");
							   Object returnValue = method.invoke(t, args);
							 return returnValue;
						}
					});
		p.add();
  • Cglib代理

多线程：

  • 进程：程序运行资源（操作系统分配）
  • 线程：自上向下的执行过程（main 主线程入口）
  • 多线程：一个程序同时多个执行过程（垃圾回收也是一个线程）
    • 线程同步：线程协同
    • 线程异步：线程之间没有关联，无业务交叉
    • 同步线程：排队等待处理，阻塞
    • 异步线程：非阻塞

线程类使用

  • Threa类+Runnable接口：
	Thread th = new Thread(new Runnable() {
			@Override	//子线程入口
			public void run() {
				for(int i=0; i<10; i++) {
					System.out.println("a"+i);
				}
			}
		});
		th.start();//启动线程
		for(int j=0; j<10; j++) {
			System.out.println("a"+j);
		}
  • 将当前线程休眠，毫秒数

Thread.sleep(500);

  • 释放线程方法（让其他线程有进来的机会，并不是真的释放）

Thread.yield();

  • 重置当前线程的中断状态（把中断状态重置为非中断状态）

Thread.interrupted();

  • 获取当前线程

Thread.currentThread();

  • 创建线程

Thread th = new Thread();

  • 启动线程

th.start();

  • 设置为守护线程（守护非主线线程，当主线程结束，其他线程关闭，非守护线程全部结束，将自动结束）

th.setDaemon(true);

  • 线程唯一标识

th.getId();

  • 设置线程启动优先级（线程启动时间相近时）

th.setPriority(0);

  • 获取状态

State s = th.getState();

  • 线程礼让

th.join();

  • 休眠（lock）

th.suspend();

  • 唤醒

th.resume();

用法

new Thread() {
			public void run() {
			}
		}.start();

接口用法

  1. 接口实现类，接口使用为类实例对象（自身类本身）
  2. 内部匿名类，接口使用为接口实例（重写方法）
  3. 接口变量定义，接口使用为变量

线程同步

  1. synchronized关键字 （对象锁）
  2. wait();（等待）
  3. notify(); （释放）

线程池

  1. 容器：有多个线程
  2. 状态：线程的启用，关闭状态
  3. 一旦建立线程池，所有线程都是启用状态，闲置时挂起

定时器

  • timer()
public class time(){
	public static void main(String args[]){
		Timer t = Timer();
		t.schedule(new TimerTask(){
			public void run(){
				System.out.println(111);
			}
		},2000,1000);	//2000毫秒后执行，每隔1000毫秒执行一次
	}
}

Properties

配置文件处理（本质：map集合）
对中文处理特别不友好

  • 生成保存配置：
Properties p = new Properties();	//key value 只能字符串和数字
		p.put("day", "123");
		p.store(new FileOutputStream("d://a.properties"), "lhy");//保存文件
  • 获取配置：
Properties p = new Properties();
			p.load(new FileInputStream("d://a.properties"));//读取文件
			String v = p.getProperty("day", "");//获取值，如未配置，提供默认值
			System.out.println(v);
  • 中文支持：

p.load(new InputStreamReader(new FileInputStream(“d://a.properties”),“utf-8”));

xml文件处理

  • 写
Document doc =DocumentHelper.createDocument();
      	Element root=doc.addElement("aaaa");
	//add(）   节点，属性，备注，文本（接口  ctrl+t 实现类）
	Element el1=new DefaultElement("bbbb");
      	el1.add(new DefaultAttribute("asd", "egg记得给人家"));
      	root.add(new DefaultText("dddddddddddddd"));
     	 root.add(el1);
	XMLWriter writer =new XMLWriter(    new FileOutputStream("c:/a.xml"),
             	 		OutputFormat.createPrettyPrint());
      	writer.write(doc);
      	writer.close();
是海洋啊
关注
专栏目录
《JavaSE系列教程》
緑水長流*z
08-10 7万+
本专栏内容是为零基础正在学习Java的学习者量身定制的学习路线及方案，本教程字数超20w+，插图超过400+，知识体系极其全面，案例极其丰富。本配备有专门的学习群及学习视频，读者可加学习群与正在学习该阶段的人一同学习，有任何不懂的也可以观看于此教程配套的学习视频。
JAVA程序进阶——注解
lost_gost的博客
03-23 381
JAVA程序进阶——注解 注解：说明程序。给计算机看的 注释：用于文件描述程序 给程序员看的 作用 编写文档：通过代码的标识的注解生成文档 代码分析：通过标识的注解对代码进行分析【使用反射】 编译检查：通过代码里标识的注解能够实现基本的编译检查 一、系统部分自带注解 1. @Override 检测被该注解标注的方法是否是继承自父类（接口）的 @Override public String toString() { return super.toString(
public String toString() {}方法
qq_28764223的博客
05-14 1万+
新建一个ＪａｖａＢｅａｎ：public class AdminUser { private Integer uid; private String username; private String password;／／ｇｅｔｅｒ（）加ｓｅｔｔｅｒ（）方法．．．．．．．@Override public String toString() { return " username=" + usern...
java的decimalFormat_Java中 DecimalFormat 用法详解
weixin_36242382的博客
02-12 319
我们经常要将数字进行格式化，比如取2位小数，这是最常见的。Java 提供DecimalFormat类，帮你用最快的速度将数字格式化为你需要的样子。下面是一个例子：import java.text.DecimalFormat;public class TestNumberFormat{public static void main(String[]args){double pi = 3.141592...
关于String类之toString()方法的细节
jiaobuchong的专栏
07-23 1万+
Object是所有类的父类，编译器在编译我们的自定义类文件时，会自动将Object类加入到我们的class文件中，toString()是定义在Object中的一个方法，String类是Object的子类，String类重写了这个方法，看java源码：     同样StringBuilder类中也重写了toString()方法：     源码中new了一个String对象，实则是
实体类 @Override public String toString()的意义
kevin_loving的博客
05-30 9007
System.out.println（entity）必须实现toString方法
三年JavaEE开发积累的那些代码之一：JavaSE篇完整实例源码
12-15
三年JavaEE开发积累的那些代码之一：JavaSE篇 有什么？ 1)自己写的例子：或是为了项目中应用写的demo，或是为了学习某项技术写的demo。 2)网上下载的例子：或改过或没改过，或完善过或原封没动。 没什么？ 1)公司...
黑马程序员Javase笔记
01-18
"黑马程序员Javase笔记"是一个自学者在学习黑马程序员提供的Java全套课程过程中整理的笔记，主要涵盖了Java Standard Edition (Javase) 的核心内容。下面将详细讨论其中的关键知识点。 首先，DOS命令是操作系统中的...
javase-2.2-API文档-中文版.zip
07-13
赠送jar包：javase-2.2.jar； 赠送原API文档：javase-2.2-javadoc.jar； 赠送源代码：javase-2.2-sources.jar； 赠送Maven依赖信息文件：javase-2.2.pom； 包含翻译后的API文档：javase-2.2-javadoc-API文档-中文...
JavaSE:JavaSE演示
05-14
JavaSE / ├─expert │ ├─anotation │ │ ├─AnnotationTest.java │ │ └─JavaDocTest.java │ ├─aop │ │ ├─Interceptor.java │ │ ├─Logger.java │ │ ├─LoginManage.java │ │ ├─...
关于IDEA在debug时私自调用toString()方法的问题
lkforce
05-23 4414
1，IDEA在debug时，当debug到某个对象时，会调用对象的toString()方法，用来在debug界面显示对象信息。 2，IDEA调用toString()方法时，即使在toString()方法中设置了断点，该断点也不会被触发，也就是说，开发者多数情况下不会知道toString()方法被调用了。 3，多数情况下调用一下toString()方法没有什么问题，但是也有例外，比如重写了toS...
JAVA面向对象之代码块 继承 方法的重写 super关键字与重写toString()方法介绍
沙漠皇帝本拉登
01-10 2710
JAVA面向对象之代码块与继承 代码块分类 局部代码块 作用:限制变量生命周期 书写位置:在方法中 构造代码块 开发中很少使用 书写位置:类中 方法外 调用时机:如果你有构造代码块 系统会帮你调用 帮你在创建对象时调用 静态代码块(一定是被static修饰) 依赖类 随着类的加载而加载 注意:只加载一次(系统只创建一次 不管你调用多少对象) 应用场景:U...
【lombok】@ToString - 不再需要自己覆写toString，让lombok帮你生成
树洞
01-19 3万+
@ToString 任何类定义都可以用@ToString注释，让lombok生成toString（）方法的实现。默认情况下，它会按顺序打印您的类名称以及每个字段，并以逗号分隔。通过将includeFieldNames参数设置为true，您可以为toString（）方法的输出添加一些清晰度（但也有一些长度）。 默认情况下，将打印所有非静态字段。如果要跳过某些字段，可以使用@ ToStrin...
91.vido.ws v.php,"token" parameter not in video info for unknown reason;
热门推荐
weixin_35307279的博客
03-29 92万+
youtube-dl -v --dump-pages https://www.youtube.com/watch?v=USg3NR76XpQ output[debug] System config: [][debug] User config: [u'--add-metadata', u'--user-agent', u'Mozilla/5.0 (X11; Ubuntu; Linux x86_64...
http://www.stpeterschelsea.com/wholesalejerseys.html
cujian2116的博客
07-15 3174
n ?t Women were not afraid to make a fashion statement, and footwear quickly became the new must-have accessory ...
toString方法学习
weixin_51113331的博客
06-30 309
toString方法 toString方法作为Object中的一个重要方法，应用广泛。 我们在软件构造实验一和实验二中应用修改过它的继承方法，现做个总结。 （1） 绝大多数的toString方法都遵循这样的格式：类的名字+[域值]。但实际上，这可以优化一下设计，通过调用getClass().getName()获得类名的字符串，而不是将类名强加到toString方法中去。 例如，Employee类中的toString方法改进如下：` public String toString() { retur
The Way to Make and Upload Videos into Youtube
iteye_19160的博客
12-10 2203
In the past, we always feel difficulty to make a good video and upload it to youtube, because most of us are newbie about this technology field. Don't worry, now there is a good and easy device can he...
谁在乎toString的性能？
weilin705的博客
11-26 218
简介 谁在乎toString的性能？没有人！ 除非你批量处理大量数据，追求算法高性能，否则将使用toString进行大量日常类型转换。然后，你会研究为什么它很慢，认识到toString()主要是使用内部实现的并且可以优化。 首先，让我们看一下Javadoc的描述  Object.toString 应该做什么：“ 返回对象的字符串表示形式。通常，该 toS...
DecimalFormat基本用法
将军何处觅功名的博客
04-13 3万+
1.保留两位小数(截断） double num = 11.255; DecimalFormat df = new DecimalFormat("#.##"); //指定RoundingMode df.setRoundingMode(RoundingMode.DOWN); String str = df.format(num); double formatNum = Double.parseDouble(str);
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值