java基础学习

JDK版本时间

1998年JDK1.2， Java->Java2
2005年，JDK1.5
2014年，JDK1.8，Lamda表达式、函数式编程
2017， JDK1.9
2018， JDK1.10

classpath路径

jdk1.6之后支持多国版本，jdk1.8之前只会显示“找不到主类”，jdk1.9之后会多显示“java.lang.ClassNotFoundException”。

在cmd查看和设置classpath：set classpath查看，set classpath=.;设置

对于classpath，一般不做这种操作：在classpath下配置类路径，达到全目录都可以访问的目的，因为这样会造成混乱。

Java注释

在代码处理之前，Unicode先处理， “\u0022+\u0022"其实是”"+""。
Unicode放在注释里也很危险，// \u00A0 is a newline 会换行，报错。
// Look inside c:\users， 后面没有跟四位十六进制字符

一些版本y特性

JDK1.4，出现assert关键字
JDK1.5，出现enum关键字
未使用到的关键子goto、const

基本数据类型

数据文件传输、文字编码转换用byte类型
处理中文用char来完成（可选）
描述内存、文件大小、主键列，用long

long num = 34352425234235253;会报错，因为数值超过int的范围

byte b = 20;这是可以的，java做了处理，没超过范围的可以直接由int转为byte

类型转换，常量在后面加L，变量加（long）

每个语言都没有String这种基本数据类型，它可以理解为一种操作。在Java中用String类来定义、描述。

x++;
result = x - y;
y–;

char c = ‘A’;
boolean flag = 65 == c; //true
char自动转为int进行比较

三目运算符，运算是从外到内

switch 支持int、char，到jdk1.5支持枚举，到jdk1.7支持String

do … while循环很少用，百分之一

方法的重载与返回值没有关系，只与参数的类型和个数有关。但是实际的开发中，建议：返回值一致

类与对象

对象的声明：
一.类 对象名 = new 类（）
二. 类 对象名 = null；

异常

exception
java.lang.ClassNotFoundException

runtimeException
java.lang.ArrayIndexOutOfBoundsException
java.lang.NullPointerException
java.lang.ArithmeticException
java.lang.NumberFormatException
java.lang.ClassCastException

error
java.lang.StackOverflowError
java.lang.NoClassDefFoundError

防止垃圾的产生

引用传递不会产生垃圾。
不可以频繁new对象

构造方法重载

降序排列，或者升序排列

简单Java类

代码块

普通代码块、构造代码块、静态代码块
静态代码块：jdk1.7之前有bug，用静态代码块跑程序；jdk1.7及之后修复。

foreach

jdk1.5及之后

数组排序

        int[] m = new int[]{7,4,9,78,34,1};
        for(int i = m.length - 1; i > 0; i--){
            for(int j = 0; j < i; j++){
                if(m[j] < m[j + 1]){
                    int temp = m[j];
                    m[j] = m[j+1];
                    m[j+1] = temp;
                }
            }
        }

		int[] m = new int[]{7,4,9,78,34,1};
        for(int x = 0; x < m.length - 1; x++){
            for(int y = 0; y < m.length - x - 1; y++){
                if(m[y] > m[y+1]){
                    int temp = m[y];
                    m[y] = m[y+1];
                    m[y+1] = temp;
                }
            }
        }

数组反转

        int i = 0;
        int j = m.length - 1;
        while(i < j){
            int temp = m[i];
            m[i] = m[j];
            m[j] = temp;
            i++;
            j--;
        }
        System.out.println(Arrays.toString(m));

		int term = m.length / 2;
        for(int i = 0; i < term; i++){
            int temp = m[i];
            m[i] = m[m.length - i - 1];
            m[m.length - i - 1] = temp;
        }
        System.out.println(Arrays.toString(m));

一些工具方法

java.util.Arrays.sort(array)
System.arraycopy(源数组，源数组开始点，目标数组，目标数组开始点）

任意参数变量

可以传递数组类型

常量池

静态常量池：在类加载的时候，字符串、普通的常量、类和方法的信息等等全部进行分配。

运行时常量池：

String修改

不要频繁修改String对象的内容，会产生大量的垃圾

String[] args

cmd接收参数，如果参数本身有空格，要用""括起来。

String

jdk1.8之前使用char[]，jdk1.9使用byte[]

javadoc

jdk1.8之前， jdk1.9实现模块化

字符串查询

indexOf contains jdk1.5之后

字符串格式化

String.format() jdk1.5

方法覆写

权限只能放宽
private方法覆写不了
方法调用，如果该方法被覆写，调用覆写的。

属性覆盖

private进行属性封装，就没有覆盖了。
private修饰属性，子类就不能用super访问了

final

final String a=“A” //放在常量池
String b=“AB”
Stirng c = a + “B”
System.out.println(b == c) //true

Annotation

jdk1.5

向上转型

统一接受的对象类型

Object类

因为数组是引用类型，所以Object可以接受
Object obj = new int[]{1,2,3};
System.out.println(obj instanceof int[]); //true

模块化设计

设计常量命令
public static final int EAT = 1;
public static final int SLEEP = 5;
public static final int WORK = 10;

包装类

jdk1.0 就有了
jdk1.5提供自动拆装箱，jdk1.9才将构造方法过期

Integer x = 127;
Integer y = 127;
Integer k = new Integer(127);
System.out.println(x == y);   //true, -128-127可以用"=="
System.out.println(x == k);  //false

接口

抽象类还是有一些细节写在里面，想完全隐藏可以用接口
接口一开始只允许定义常量和抽象方法

同一个子类的接口之间，可以通过强转来进行互转。
Object可以接收接口类型、类、数组、基本数据类型。

泛型

1. jdk1.5之后追加

//泛型类
public class className<T>{
}
className<Integer> c = new className<>()

//泛型接口以及类的两种实现
interface name<T>{
}
class className<T> implements name<T>{
}
class className implements name<String>{
}

//泛型方法
public static <T> T[] get(T ... args){
}

3.泛型通配符 解决泛型传递问题

4.不加通配符，数据有可能会被修改

package org.example;

class Mes<T>{
    T t;
    public void setT(T t){
        this.t = t;
    }

    public T getT() {
        return this.t;
    }
}

public class Send {
    public static void main(String[] args) {
        Mes<Integer> a = new Mes<>();
        Mes<String> b = new Mes<>();
        a.setT(100);
        send(a);
        b.setT("hello");
        send(b);
    }

    public static void send(Mes mes){
        mes.setT(11.9);
        System.out.println(mes.getT());
    }
}

包

1.编译
javac -d . Hello.java
java name.name.nama.className

2.把编译顺序交给编译器
javac -d . *.java

3.静态导入
jdk1.5
导入类的静态方法
import static name.name.className.Method;

4. jar 打包
   jar命令，以前直接打jar可以有使用说明，jdk1.9需要加上–help
   jar -cvf my.jar cn
   -c 创建jar文件
   -v 输出详细过程
   -f 命名

5. jdk1.9 不用在classpath配置rt.jar,tools.jar

6. 常用的包
   java.lang jdk1.1自动导入

UML

unified modeling language
工具：Rational Rose、PowerDesigner
普通类直接写，抽象类斜体，当一般都再加上abstract
属性“访问权限 属性名称：属性类型”
方法“访问权限 方法名称（）： 返回类型”
访问权限 public（+） protected（#） private（-）

枚举类

enum Color{
RED,GREEN,BLUE;
}

Color.values()

2.枚举对象要写在第一行

异常

自定义异常：继承Exception、RuntimeException

内部类

1.局部内部类
对于方法参数和局部变量的直接访问是从jdk1.8开始的；之前如果要访问方法的参数和局部变量，则参数必须要追加final。

函数式编程

haskell、Scala

编程注意问题

1.过渡抽象类； jdk1.8接口可以定义default方法，这属于补救功能
2.泛型写工厂类

设计模式

1.工厂设计模式
2.代理设计模式
3.单例设计模式