7.17实习培训日志-java基础

总结

今天主要是学习了java基础，java面向对象方面的知识，然后下午老师讲了软件的设计模式，今天看了一部分，印象深刻的是单例模式，用枚举实现单例模式。晚上主要讲了maven的一些基础知识和idea的一些配置修改，编码修改成utf-8,换行改成'\n'模式，idea的terminal换成git-bash等等，maven package打jar包，生成class文件，maven install 打jar包，放到本地仓库，生成class文件,maven jar只打jar包等等，dependencies和dependencyManament(统一子模块版本)区别等。

Java基础

计算机进制转换

进制表示

16进制表示：0x或0X前缀

进制转换

十进制转二进制：不断除以2，保留余数，商为0时不再除以2，将所有余数倒序排列。

十进制转十六进制：不断除以16，保留余数，商为0时不再除以16，将所有余数倒序排列。

变量与数据类型

数据类型

八种基本数据类型

类型	占用空间(字节)
byte	1
short	2
int	4
long	8
float	4
double	8
char	2
boolean	1或4

Unicode/GBK/gb2312/gb18030： 中文2字节

UTF-8： 中文3字节

因为Java编译器默认使用Unicode编码。所以char在Java中占用2字节。

char a= (char) Integer.MAX_VALUE;
System.out.println((int)a);
char b= (char) Integer.MIN_VALUE;
System.out.println((int)b);
运行结果为65535 0

《Java虚拟机规范》

虽然定义了boolean这种数据类型，但是只对它提供了非常有限的支持。在Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达式所操作的boolean值，在编译之后都使用Java虚拟机中的int数据类型来代替，而boolean数组将会被编码成Java虚拟机的byte数组，每个元素boolean元素占8位

字符编解码的故事（ASCII，ANSI，Unicode，Utf-8区别）

引用数据类型

对象、数组、接口

JAVA中数组也是对象，基本类型数组是一个由JVM创建的对象，其他数组是类,也是对象。

引用类型:引用类型继承于Object，都是按照Java里面存储对象的内存模型来进行数据存储的，使用Java内存堆和内存栈来进行这种类型的数据存储，“引用”是存储在有序的内存栈上的，而对象本身的值存储在内存堆上的;

基本类型只在栈中

引用类型引用在栈中数据在堆中

自定义数据类型

类就是数据类型，自定义类是一种自定义数据类型

变量

基本概念

字面量是指由字母，数字等构成的字符串或者数值，它只能作为右值出现，所谓右值是指等号右边的值

int a;//a 变量
final int b = 10;//b 常量 10 字面量

计算机高级语言用变量管理内存存储的数据。

变量名实际是一个内存栈的地址

作用域

1. java用一对大括号作为语句块范围，称为作用域。
2. 作用域变量不能重复定义。
3. 离开作用域，变量所分配的内存空间将会别jvm回收。

包装类

1. 包装类中有实用的方法和常量。MIN_VALUE，parseInt。
2. 包装类作为集合元素的类型。

补码

正数是其本身，负数符号位不变，其他位取反，再加1.

两数相加，符号位有进位，进位被舍弃。

补码好处最大好处：变减法为加法。

模

模：某钟类型数据的总和。

正数加负数=模

整数类型

java默认整数计算结果为int类型

byte a =1,b =2;
byte c = a+b;//compiler error
int d = a+b;//ok

浮点类型

类型	指数位	尾数位
float	8	23
double	11	52
int	0	31
long	0	63

float[double]存储数据范围大于int[long]类型，但精度比int[long]小(int：31位,float:23位)

在做数值运算中，尽量用整数运算，浮点数有误差。

double d = 2.7;
double result = d-2;
//0.7000000000000002
System.out.println(result);

注意浮点数比较不要用==。

字符类型

ASCII码对应：1:48,A:65,a:97

转义符

转义符：\

\u4e2d表示Unicode码的'中'

类型转换

小类型到大类型转换[自动转换]

1. 符号位自动扩展，负数补1，正数补0。
2. 整数自动转换成浮点数可能会损失精度(int->float,long->double,精度丢失)。int->double不会丢失精度。

大类型到小类型转换[强制转换]

1. 注意符号位丢失

int和char类型自动转换

获取数据

1. String[] args获取数据
2. Scanner 获取数据

自增自减自乘自除

1. i+=n/i-=n/i*=n/i/=n
2. i++ ++i i-- --i

交换a b值

a = a+b
b = a-b
a = a-b

运算符先后顺序

单算移比按逻三赋

1. 单目运算符（一元运算符，即一个变量）：+，-，++，--
2. 算数运算符：+，-，*，/，%
3. 移位运算符：<<,>>
4. 关系运算符：>,<,>=,<=,==,!=
5. 位运算符：&，|，~，^,
6. 逻辑运算符：&&，||
7. 三目运算符：表达式1？表达式2：表达式3;
8. 赋值运算符：=等

System.out.println(1+1<<1);//4

短路运算

&& ||

长路运算

&``|

java中int和boolean不自动转换，不能在该用true/false时用int数值。

数组

1. 动态初始化
2. 静态初始化(int a[] = {2,3,4})

字符串

1. 使用时直接赋值更好
2. 字符串内容不可改变

String为字符串常量，而StringBuilder和StringBuffer均为字符串变量

运行速度快慢为：StringBuilder > StringBuffer > String

StringBuilder：线程不安全

StringBuffer：线程安全

java面向对象

方法与类

方法重载

重载：方法名称相同，参数类型和个数不同。

封装继承多态

匿名对象：回收机制

引用传递

值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

String说:其值不可变,引用可变

Java中只有按值传递，没有按引用传递！

JAVA中只有值传递，基本类型传递的是值的副本，引用类型传递（不是上面说的引用传递）的是引用的副本

值传递和引用传递（不是引用类型的传递）的区别

public static void main(String[] args) {
    String str1 = "hello";
    change(str1);
    System.out.println(str1);
}
static void change(String str2){
    str2 = "yes";
}
结果：hello(String 不可改变)

class Ref{
    String str = "ref";
}
public class Main {
    public static void main(String[] args) {
        Ref r = new Ref();
        System.out.println(r.str);
        r.str="ref1";
        System.out.println(r.str);
        change(r);
        System.out.println(r.str);
    }
    static void change(Ref r){
        r.str="ref2";
    }
}
结果为
ref
ref1
ref2

this关键字

1. 表示类中属性和调用方法
2. 调用本类中构造方法
3. 表示当前对象

this()和super()都指的是对象，均不可以在static环境中使用。

从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

static关键字

static块可以用来优化程序性能，只会在类加载的时候执行一次。

static关键字不会影响到变量或者方法的作用域。

final关键字

1. 修饰变量(基本数据类型：值不可更改，引用数据类型：指向不可更改)
2. 修饰方法(方法不可被子类覆盖,重写)
3. 修饰类(类不可被继承)
4. 类的private方法会隐式地被指定为final方法。

重写

定义：方法名称相同，返回值类型相同，参数相同。

重写限制：被子类重写的方法不能比父类方法有更严格的访问权限。

多态

三大要素：

1. 继承
2. 重写
3. 父类引用指向子类对象

多态的弊端：不能使用子类特有的成员属性和子类特有的成员方法。

静态方法，静态和类相关，算不上重写，所以会访问父类静态方法，而不是子类静态方法。

泛型

注意事项：

1. 泛型的类型参数只能是类类型，不能是简单类型。
2. 不能对确切的泛型类型使用instanceof操作。

• 泛型类:在实例化类的时候指明泛型的具体类型
• 泛型方法:在调用方法的时候指明泛型的具体类型

Gen<Integer> g = new Gen<>();
System.out.println(g instanceof Gen); // true
System.out.println(g instanceof Gen<Integer>); //compiler error

构造方法使用泛型

public class GenericTest<T> {
    public T t;
    public GenericTest(T t){
        this.t = t;
    }
}

设置多个泛型

class Gen<K,T>{
    private K k;
    private T t;
}

通配符

class Info<T>{
    private T value;
    public T getValue() {
        return value;
    }
    public void setValue(T value) {
        this.value = value;
    }
}
public class GenericTest<T> {
    public static void main(String[] args) {
        Info<String> i = new Info<>();
        i.setValue("value");
        tell(i);
    }
    public static void tell(Info<?> i){
        System.out.println(i.getValue());
    }
}

泛型接口

抽象类访问修饰符：public和protected

接口访问修饰符：public

泛型方法

public <T> T method(T t)

返回值前面的<T>声明是一个泛型方法。

静态方法无法访问类上定义的泛型,需要把方法声明在方法上。

泛型上下边界

1. 上边界，传入的类型实参必须是指定类型的子类型
2. 下边界，传入的类型实参必须是指定类型的父类型
3. 泛型的上下边界添加，必须与泛型的声明在一起

<? extends Number>
public int compareMobEntity(Comparator<? super EntityMob> comparator)

泛型数组

不能创建一个确切的泛型类型的数组

List<String>[] ls = new ArrayList<String>[10];  //error
List<?>[] ls = new ArrayList<?>[10];  //ok
List<String>[] ls = new ArrayList[10]; //ok

java 泛型详解

软件设计模式

1. 工厂模式
2. 抽象工厂模式
3. 单例模式
4. 装饰器模式
5. mvc模式
6. 状态模式
7. 数据访问对象模式
8. 前端控制器模式
9. 拦截过滤器模式
10. 传输对象模式

单例模式

单例模式最好用枚举类实现(线程安全，自由序列化，保证单例)

enum类用分号分开枚举实例后，可以声明变量或者成员方法。

enum类默认私有构造方法,且只能由编译器调用。

enum类只能覆盖toString方法，其他都用final修饰。

java 1.7后switch也对字符串进行了支持。

深入理解Java枚举类型(enum)