Java (c++-)学习笔记

day1 4/14 2019

Java 核心优势:

跨平台/可移植性

Java 各个版本

javaEE(Java Enterprise Edition):企业版:定位在服务器上的应用<br>
JavaME:微型版----会被安卓取代<br>
JavaSE==:(Java Sandard Edition) :标准版:定位在个人计算机的应用<br>

Java 特点

简单,分布式,多线程,高性能,健壮

JVM/JRE/JDK

JVM(Java Virtual Machine)虚拟机执行字节码
JRE(Java Runtime Environment) :包含jvm,库函数,必须文件
JDK(Java Development Kit):包含Jre

day2 4/15 2019

抽象类和抽象方法

  • 1.有抽象方法的类只能是抽象类
  • 2.抽象类不能实例化(不能用new实例化抽象类),可以用子类实例
  • 3.抽象类可以包含属性、方法、构造方法,但是构造方法不能用来new实例,只能用来被子类调用
  • 4.抽象类只能被继承
  • 5.抽象方法必须被子类实现

    接口和多继承

    接口interface(接口就是规范)

  • 方法全部为抽象方法
  • 变量全为常量
  • 支持多继承
  • 不能创建实例 ,但是可以用于引用变量类型
  • jdk1.8后包含普通的静态方法

    实现implement(类似extends)

    内部类

    非静态内部类

day3 4/16 2019

容器类

  • collection 容器(集合)
    • List 有顺序,可重复
      • ArrayList
      • LinkedList
    • Set 无顺序,不可重复
      • HashSet
    • Map 键值对
      • HashMap
      • TreeMap

collection

方法

1
2
3
4
5
6
7
8
9
10
11
12
add()
toArrary()
isempty()
remove()
contains()
size()
clear()
-----------------------------------
addAll()
containsAll()
removeAll()
retainAll()

set

方法和collection基本相同
set 不允许`e1.equals(e2)==true`的对象放入

List

  • 有序:List中每个元素都有索引标记
  • 可重复:允许加入重复的元素
ArrayList(数组)
1
2
3
4
5
6
7
8
9
indexOf() 返回第一次出现的对象的索引值 
lastIndex() 返回最后一次出现的对象的索引值
copyOf(elementData , int)
copy
add(E)
add(int,E)
remove(int)
System.arraycopy(elementData ,index+1,elementData,index)
clear()
LinkedList(链表)
Vector(线程安全的数组)

泛型

Java中泛型的引入是通过泛型擦除机制来实现的

泛型只在编译中被编译器javac识别&使用，用来确保数据的安全性&免去强制类型转换的麻烦。

  • 可以用继承的方式限制参数类型

    extends Number类可以起到c#中 where T:struct的作用

day4 4/27 2019

Java异常类型机制

类结构

  • Thrwoable
    • Error
    • Exception
      • CheckedException
      • RuntimeException
        • uncheckException

          RutimeException

          运行时异常

          由JRE抛出通常需要程序员去修改

          checkedException

          由编译器处理，在编译时会及时报错

          处理方法

  • try catch finally 语法格式
  • 向外抛出，一直到抛到JRE

day5 4/29 2019

注解

注释是给人程序员看的，注解是给给程序看的

  • @Override：重写
  • @Deprecated：过时
  • @Suppress warning：压制警告

    元注解

  • 注释注解用的
    @Target
    修饰注解作用范围
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    ElemetnType.Type
    Type->
    PACKAGE-包
    TYPE-类、接口、枚举值、Annotation类型
        类型成员：
            1.CONSTRUCTOR-构造器
            2.FELD-描述域/字段
            3.METHOD-描述方法
    LOCAL_VARIABLE-描述局部变量
    PARAMETER-描述参数
    @Retention-保留
    表示需要在什么级别保存该注释信息（生命周期）
    取值 RetentionPolicy | 作用/保留域
  • -|–
    SOURCE | 在源文件中有效/源文件保留
    CLASS | 在class文件中有效/class保留
    RUNTIME | 在运行时有效/运行时保留可以被反射机制读数
@Documente
@Inherited

day6 5/1 2019

反射机制

在运行时加载、探知、使用、编译期间完全未知的类。

程序运行时，可以动态加载一个只有名称的类，对于任意一个已加载的类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个属性和方法；

加载完类后，在堆内存中，就产生了一个Class类型的对象(一个类只有一个Class对象)，这个对象包含了完整的累的结构信息。它的作用类似一个图纸的作用，这个对象就像是一面镜子，透过这个镜子看到类的结构，我们称之为反射。

  • 反射的根源是Class类

反射可以用来干什么？

  • 动态加载类、动态获取类的信息（属性、方法、构造器）
  • 动态构造对象
  • 动态调用类和对象的任意方法、构造器
  • 动态调用和处理属性
  • 获取泛型信息
  • 处理注解

java.lang.Class

  • 一个类被加载后，JVM会创建一个对应该类的Class对象,
    类的整个结构信息会被放到对应的Class对象中
  • JDK简介

    Instance of the class (Class) represent classes and interfaces in a running Java application.An
    enum type is a kind of class and an annotation type is a kind of interface.Every array also belongs
    to a class that is reflected as a
    object that is shared by all arrays with the same element type and number of dimensions.The primitive Java types,and the keyword(void) are also represented as objects.

    译:

    Class类的实例代表了正在运行的java类和对象。一个枚举class是一个类一个注解class是一个接口。每个数组从属于一个类，且相同数据类型同时维度相同的类从属于同一个类(同样的hashcode)。基本数据类型同和void关键字同样被视为一个类

Class类对象的获取方式

1
2
3
Class clazz = Class.forName("path") -最常使用
Class clazz = path.getclass()
Class clazz = class.class

day7 5/2 2019

### 反射操作类的名称、属性、方法、构造器 - 反射创建对象 
1
2
3
4
5
Class clazz = Class.forName(path);
User u1 = (User)clazz.newInstance();
or加上泛型 
Class<User> clazz = (Class<User>) Class.forName(path)
User u1 = clazz.newInstance();
  • 反射获取类的名称
    1
    2
    3
    4
    5
    6
    7
    try{
        Class clazz = Class.forName("com.sdz.")
        String name = clazz.getName()；
        String simplename = clazz.getSimpleName();
    }catch (Exception e){
        printStackTrace
    }
  • 反射获取类的属性
    1
    2
    3
    Field f1 = clazz.getDeclaredField(String)
    Field fields = clazz.getDeclareField()
    - 反射获取类的注解
  • 反射操作类的属性
    1
    2
    3
    4
    User u = clazz.newInstance();
    f1.setAccessible(true);//跳过安全检查，提高反射性能，大约是原来的4倍
    f1.set(u,"孙东哲");//通过反射写属性
    System.out.printle(f1.get());//通过反射读属性
  • 反射获取类的方法
    1
    2
    Method m1 = clazz.getDeclaredMethod("getUname");
    Method[] methods = clazz.getDeclaredMethods();
  • 反射调用普通方法
    1
    2
    User u = clazz.newInstance();
    m1.invoke(u,"孙东哲");
  • 反射获取类的构造器
    1
    2
    Constructor c1 = clazz.getDeclaredConstructor(int.class,int.class,String.class);
    Constructor[] constructors = clazz.getDeclaredConstructors();
  • 反射调用构造方法
    1
    2
    User u = clazz.newInstance();//无参构造器
    c1.newInstance(1001,18,孙东哲);

    反射的性能

    反射的速度很慢，大约是普通方法调用的30倍

    但是如果跳过反射的安全检查，反射的速度可以增加4倍

反射操作泛型

Java中泛型是给编译器看的，即生命周期仅限于编译期间
所以 ，Java增加了ParameterizedType，GenericArrayType,TypeVariable,WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型

  • ParameterizedType(参数化类型)

    例如：Collection
  • GenericArrayType

    表示一种元素类型是参数化类型或者类型变量的数组类型
  • TypeVariable

    是各种类型变量的公共父接口
  • WildcardType

    代表一种通配符类型表达式，比如？，？extends Number，？super Integer

反射操作注解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
try   
{
    //获取Class对象
    Class clazz = Class.forName("com.bjsxt.test.annotation.SxtStudent");
    //获得类的所有有效注解
    Annotation[] annotations=clazz.getAnnotations(); for (Annotation a : annotations) {
    System.out.println(a); }
    //获得类的指定的注解
    SxtTable st = (SxtTable) clazz.getAnnotation(SxtTable.class); System.out.println(st.value());
    //获得类的属性的注解
    Field f = clazz.getDeclaredField("studentName");
    SxtField sxtField = f.getAnnotation(SxtField.class); System.out.println(sxtField.columnName()+"--"+sxtField.type()+"--"+sxtField.length());
    //根据获得的表名、字段的信息，拼出DDL语句，然后，使用JDBC执行这个SQL，在数 据库中生成相关的表
} catch (Exception e) {
e.printStackTrace();
}

IO流

文件创建

  • mkdir()

  • mkdir()

  • List()

day3 5/14 2019

final和conset的区别

final 修饰的变量定义时就需要初始化但是他的值是在运行时确定
例如 

1
int final a = fn();

const 修饰的变量在编译时就被确定了

day1 5/25 2019

Java的回调函数

  • 回调函数是由指针实现的，即在特定的事件或条件发生时由另外的一方调用的，作为该事件或条件的响应
  • 而java中删除了指针的概念，但是可以通过接口和内部类来实现回调的功能：

步骤

  • 1 定义接口Callback，包含回调方法callback()
  • 2 在一个类Caller中声明一个Callback接口对象mCallback
  • 3 在程序中赋予Caller对象的接口成员(mCallback)一个内部类对象例如
    1
    2
    3
    4
    5
    new Callback(){
        callback(){
            //具体实现
        }
    }

    这样就可以在需要的时候，用Caller对象的mCallback接口成员，调用callback()方法，完成回调。

总结

  • 1 声明回调函数的统一接口(实现可以不同)interface A，包含func()
  • 2 在调用类caller中将该接口设置为私有成员private A xxx;
  • 3 在caller内提供一个public的方法，可以将外部“改接口的实现类的引用”通过形参传给XXX;
  • 4 caller的某个方法call()中会用到xxx.fun()方法；
  • 5 在caller的实例中，将实现了A接口的对象的引用传给caller，后调用caller()方法

day10 6/7 2019

单例模式

  • 1.懒汉式
  • 2.恶汉式
  • 3.双重锁模式
  • 4.静态内部类实现
  • 5.枚举实现

uml绘制

  • rational rose
  • metamill

工厂模式

原则

  • 1.OCP开闭原则
  • 2.DIP依赖倒置原则
  • 3.LoD迪米特原则

简单工厂模式

方法工厂模式

抽象工厂模式

原型模式

适配器模式

day11 6/16 2019

桥接模式

针对不稳定的情况(解决多继承，多个维度)

组合模式

  • 关键

    对整个树结构里的部分对象和整体对象都是一个统一的处理模式.

    在其中有天然的递归

装饰模式

针对稳定的，增加新的功能

外观模式

封装

享元模式

  • 1内部状态 可共享
  • 2外部状态
    相似或相同对象——》

优点

1 减少对象数量，节省内存

2 外部状态相对独立

缺点

1 模式较复杂
2 节省运行时间

责任链模式（chain of responsibility)

代替大量的if else 语句

处理同一类请求的对象

迭代器模式 (iterator)/游标模式cursor

提供一种可以遍历聚合对象的方式

通常以内部类的形式出现在聚合对象，便于操作外部对象

JDK中的set/List等会使用

中介者模式 (Mediator)

应对复杂结构

day12 8/6 2019

枚举类

枚举是一个特殊的类,域成员均为常量

命名时在结尾加上Enum

如:ProcessStatusEnum

变量全部用大写并用下划线隔开