呆呆啊噗g
呆呆啊噗g

跟着楠哥学java（javase笔记）

JAVA介绍（4.14）

JDK

JDK(Java Development Kit Java开发工具包)

JDK是提供给Java开发人员使用的，其中包含了java开发工具，也包含了JRE。所以安装了JDK，就不用单独安装JRE了

JRE

JRE(Java Runtime Environment JAVA运行环境)

包括java虚拟机（JVM）和和Java程序所需的核心类库等，如果想要运行一个开发好的JAVA程序，计算机只需要安装JRE即可。

class

首先将后缀名为.java的文件编译为.class的可在JVM上运行的文件

cmd使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w3pLCPAG-1635652961140)(assets/cmd使用.png)]

cd ：转移路径

-version：查看版本

配置环境变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3R2h4hUX-1635652961143)(assets/1618366391307.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kHogEhVL-1635652961146)(assets/1618366452228.png)]

安装java jdk

可以直接将压缩包解压到C：盘java文件夹中

jshell的使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YTSpbE5N-1635652961150)(assets/1618369091139.png)]

可以直接在cmd中写一下Java的小程序（一般不用）

JAVA总体命名规则

1、项目名全部小写

2、包名全部小写

3、类名首字母大写，其余组成词首字母依次大写

4、变量名，方法名首字母小写，如果名称由多个单词组成除首字母外的每个单词的首字母都要大写

5、常量名全部大写

所有命名规则必须遵守以下规则：

  • 命名只能由字母、数字、下划线、$符号组成

  • 不能以数字开头

  • 名称不能使用JAVA中的关键字

  • 坚决不允许出现中文及拼音名。

    java语言有51个关键字，其中const和goto虽然被保留但未使用。不能使用保留关键字来命名类、方法、变量。

注释的书写格式

单行注释

//单行注释

多行注释

/*多行注释*/

文档类型注释

/**文档类型注释*/

数据类型

1、数据类型

基本数据类型   byte 1个字节 short 2个字节int  4个字节long  8个字节float   4个字节double  8个字节char  2个字节boolean 一个字节

  • 源码补码反码的取值范围

    正数的源码补码反码都相同

    负数的源码是本身，反码是除符号位其他位取反，补码是反码+1

  • 科学计数法表示浮点数

    • 将十进制变成二进制输出

    System.out.println(“Integer.toBinaryString()”)

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CfhtjiuT-1635652961151)(JAVA 笔记.assets/image-20210414173429389.png)]

    字符编码扩展

    GBK

    GB2312

    UTF-8

    unicode(万国码)

    ISO–8859

2、定义变量

变：能保存一些可变的量，比如年龄，收入等

便： 方便，一次定义，“到处”（作用域内）使用

快：实际上是一个内存地址，c指针，java引用

（1）过程

定义 int i;

赋值 i = 5; 定义和赋值可以一起 int i = 5;

使用；

（2）定义变量的规则

1、变量名字里不能有空格。

2、避免使用关键字，class public int static

3、避免使用汉字

4、整体是驼峰命名，首字母小写

5、$和_可以到处使用

6、数字不能开头

定义在main函数外面的变量为成员变量

成员变量和局部变量的区别

成员变量：

​ 1、成员变量定义在类中，在整个类中都可以被访问。

​ 2、成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。

​ 3、成员变量有默认初始化值。

局部变量：

​ 1、局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

​ 2、局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。

​ 3、局部变量没有默认初始化值

在使用变量时需要遵循的原则为：就近原则

首先在局部范围找，有就使用；接着在成员位置找。

3、布尔运算-真值表

与

条件1 condition1 条件2 condition2 结果
1 1 1
1 0 0
0 1 0
0 0 0

或

条件1 condition1 条件2 condition2 结果
1 1 1
1 0 1
0 1 1
0 0 0

非

条件1 condition1 结果
1 0
0 1
（1）符号表示

& | ！ && ||

&& 短路运算符 如果是false 直接 结果就是false 不会继续运算

|| 短路运算符 如果是true直接 结果就是true 不会继续运算

4、算术运算符

  +  -  *  /   %    ++   --   +=      -=(1+2)*3

5、定义数组

定义

int[]  array = new int[10];

定义及初始化

int[]  array = new int[]{1,2,3};int[]  array = {1,2,3};

6、三目运算符

条件 ？ 结果1 ： 结果二；

条件的结果一定是boolean ，true ，false；

条件是可以复杂的

boolean condition1 = 5 > 3;boolean condition2 = 5 > 3;boolean condition3 = 5 > 3;int num = (condition1 && (condition2 || condition3)) ? 1 : 2;

7、位移运算符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vyH9ig3B-1635652961153)(JAVA 笔记.assets/image-20210415202244232.png)]

基础数据类型定义（4.15）

byte b = 10;short s = 100;int i = 1000;long l = 100L;float f = 0.1F;double d = 0.2D;boolean is = true;char c = 'b';

如果有两个不同类型变量之间的加减，自动转成int，或者手动强转

输入输出

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cHHIfGNh-1635652961154)(JAVA 笔记.assets/image-20210415212304745.png)]

循环 判断（4.16）

一、switch用法

String next = scanner.next();int grade  = 1;switch (next){    case "宝军":        grade ++;        break;    case "主宰":        System.out.println("欢迎打主宰。");        grade += 2;        break;    default:        grade += 3;        break;}不能是long型 可以 byte shor int     （不是基础类型）String

二、循环

1、for

for (int j = 1; j <= 9 ; j++) {    for (int i = 1; i <= j ; i++) {        System.out.print("1 * " + i + " = " + i*1 + "\t");    }    System.out.println();}定义条件变量    进入条件   ; 变量改变    自增为了达到退出条件

三、while 和 do while

int i = 0;while( i < 5){    ......        i++;}do{    ......    i = i + 8;}while(i < 7)定义 条件变量    进入的条件  变量改变    变量的改变是为了满足退出条件

区别

do while无论如何都要先执行以下，然后才去判断

while 满足条件才能进入

四、几个关键字

break

无论如何都要结束当前的全部循环，程序会继续向下执行。

contiune

跳过本次循环继续下一次循环。

打标签

for循环可已打标签，使用break + 标签名可以 退出 被打标签的循环

flag:for (int i = 0; i < 2; i++) {        for (int j = 0; j < 2; j++) {                if( j > 0 ){                        break flag;               }                System.out.println("===="+j);        }}

数组

一、数组的定义

int[] nums = {1,2,3};int[] nums = new int[3];类型[] 名字 = new 类型[长度];

二、数组的性质

1、数组一旦建立不能改变长度。

2、每个位置只能存一个值，多了会覆盖。

3、编号从0开始，下标。

4、他有个长度的属性，最后一个位置的编号是 长度-1。

5、数组里边可以是基本类型，也可以是引用类型。

三、数组的简单实用

1、打擂台的形式找最大值

int[] salary = {4,5,0,6,7,8};int maxIndex = 0 ;for (int i = 1; i < salary.length; i++) {    if(salary[i] > salary[maxIndex]){        maxIndex = i;    }}System.out.println("经过了n轮比赛得到的最大值得下标是："+maxIndex+"。值是："+salary[maxIndex]);

2、通循环遍历打印数组的每一个值

for (int i = 0; i < salary.length; i++) {    System.out.print(salary[i] +  " ");}

3、查找一个数组里存在的值。

int targetIndex = -1;for (int i = 0; i < salary.length; i++) {    if(salary[i] == 9){        targetIndex = i;    }    break;}

4、元素的位移。

int[] salary = {4,5,0,6,7,8};int temp = salary[0];salary[0] = salary[1];salary[1] = temp;

四、排序算法

1、选择

每一轮都是在找一个最小值放在未排好序的元素的第一个

int[] nums = {4,6,0,8,7};for (int j = 0 ; j < nums.length -1 ; j++){    int minIndex = j;    for (int i = j+1; i < nums.length; i++) {        minIndex =  nums[i] < nums[minIndex] ? i : minIndex;    }    int temp = nums[minIndex];    nums[minIndex] = nums[j];    nums[j] = temp;}for (int i = 0; i < nums.length; i++) {    System.out.print(nums[i] + " ");}

​

	//选择排序		int[] array = {12,4,3,43,56,23,555,14,87,354,65,37,28,54,43,94,56};	//1、找最小值	for (int y = 0; y < array.length - 1; y++){		int targetArray = y;	for (int i = y + 1; i < array.length; i++){		if (array[targetArray] > array[i]){			targetArray = i;		}	}	//2、将最小值与首位交换	int middle = 0;	middle = array[y];	array[y] = array[targetArray];	array[targetArray] = middle;	}	//输出数组每一个值	for (int i = 0 ;i < array.length; i++){		System.out.println(array[i]);	}

2、冒泡

每一轮都是两两相比，会将最大的冒到最后边

int[] nums = {3, 7, 4, 9, 5, 4, 1};for (int j = 0; j < nums.length - 1 ; j++) {    for (int i = 0; i < nums.length - 1 -j ; i++) {        if (nums[i] > nums[i + 1]) {            int temp = nums[i];            nums[i] = nums[i + 1];            nums[i + 1] = temp;        }    }}for (int i = 0; i < nums.length; i++) {    System.out.print(nums[i] + " ");}

//冒泡排序	int[] array = {12,4,3,43,56,23,555,14,87,354,65,37,28,54,43,94,56};	for (int i = 0; i < array.length - 1; i++){		for (int y = 0; y < array.length - i - 1; y++){			if (array[y] > array[y + 1]){				int middle = array[y];				array[y] = array[y + 1];				array[y + 1] = middle;			}		}	}	for(int i = 0; i < array.length; i++){		System.out.println(array[i]);	}

3、插入排序

默认前面的每一个数都是有序的，将后一个数插入到前面有序的数列中去

//插入排序	int[] array = {12,4,3,43,56,23,555,14,87,354,65,37,28,54,43,94,56};	for(int i = 1; i < array.length; i++){		//将要排的数字保存下来		int temp = array[i];		for(int j = i-1; j >= 0; j--){			if (array[j] > temp){				array[j+1] = array[j];				if (j == 0){					array[0] = temp;				}			}			else{				array[j+1] = temp;				break;						}			}	}

IDEA基本设置（4.17）

字体外观

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UILXzRIc-1635652961155)(JAVA 笔记.assets/image-20210417082729788.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pYI0TYop-1635652961157)(JAVA 笔记.assets/image-20210417082846794.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GQQCaa8g-1635652961158)(JAVA 笔记.assets/image-20210417083655453.png)]

1、字体的设置

（1）非代码块设置主题和字体
file --》 settings ---》appearance---》theme  更换主题Use custom font 勾上  选择字体 和 文字大小

file --》 settings --》 plugins --》 installed ---》theme   插件ctrl art shift +s
（2）修改代码块的字体
file --》 setting --》editor --》font

2、配置jdk

（1）启动的时候就能配置

（2）ctrl + alt + shift + s 工程配置

project ---> project Sdk   --> new   找到自己安装的jdk一定要保存  点击ok

3、一些快捷方式

main方法新版的输入 main老板的输入 psvm输出语句   sout复制一行   ctrl+D剪切       ctrl+X注释    ctrl+/自动改错   alt + enterfori shift+F6ctrl+shift+下   和下一行交换位置ctrl+alt+L     格式化代码

增强for循环和一些快捷键

增强for循环

value为一个自变量，每次循环就将数组中的值赋给value然后打印出来，缺点是不能获取下标

int[] arr = {1,2,4,5};for (int value : arr){    System.out.println(value)}

方法（相当于c语言中的函数），方法封装起来叫做对象，描述特征的叫做属性

一些实用方法

1、生成随机数

Math.random()随机生成一个0~1的数字，并且因为是浮点型所以必须转成整形

//概率、随机int a = (int)(Math.random()*10+20);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uPJfyY4W-1635652961159)(JAVA 笔记.assets/image-20210426094124393.png)]

2、延迟

public static void sleep(int time){    try {        Thread.sleep(time);    }catch (InterruptedException e){        e.printStackTrace();    }

3、数字转字符串

任何东西只要加字符串就是字符串

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sxTlBBwu-1635652961160)(JAVA 笔记.assets/image-20210420154435699.png)]

4、字符串转数字

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C6xCXDOu-1635652961162)(JAVA 笔记.assets/image-20210420162050517.png)]

5、字符串比较

使用equals

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y6gIU4SS-1635652961163)(JAVA 笔记.assets/image-20210421161046457.png)]

获取当前时间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l9Or9Lii-1635652961163)(JAVA 笔记.assets/image-20210426094936868.png)]

面向对象(4.19)

方法（相当于c语言中的函数），方法封装起来叫做对象，描述特征的叫做属性。

import java.util.Scanner;//包 package ……public class Car {    //定义颜色 可以不赋值    public String color;    public int saddle;    public void run(){        System.out.println("启动");        System.out.println("加油");    }//例子：封装    //方法存在方法区   栈里面存的引用（地址）（执行效率高）、基础数据类型；    public static void main(String[] args) {        /**         *  构造方法         *  1 new 其实是在调用构造方法         *  2 如果一个类里边没有构造方法 会自动创建一个空的构造方法         *  3 构造方法能传参数，在构造期间就把对象得值赋好         *  4 一旦有了新的参数的构造方法，空构造就不在了，如果想保留，就得手动写上         *  Car是类，小car是引用（指向内存里的一片区域)         *  5 重载的构造方法，名字一样，参数不一样。         */        /**         * this 关键字指内存里分配好空间的（对象）         *         * 重载         * 1 方法名相同         * 2 方法的参数类型，参数个数不一样         * 3 方法的返回类型可以不相同         * 4 方法的修饰符可以不相同         * 5 main 方法也可以被重载         *         */        Car car = new Car();        car.color = "red";        car.saddle = 4;        car.run();    }java}

1、包

​ 简单、装类的，就是个文件夹

​ 要求

​ 域名倒着写 com.xinzhi ，必须全部小写 用.隔开。

​ 1、引入其他人写的类的时候保证不重名。

​ 2、一眼就能看出是哪个公司的作品、保护作用。

2、权限修饰符

​

作用域 当前类 同package 子孙类 其他package
public √ √ √
protected（受保护的） √ √ ×
friendly( default )（默认） √ √ ×
private keyi X X

为什么要用

1、对自己而言，保护代码不被污染

2、对别人而言、给别人一个干净的类

关于protected修饰符的访问权限如下：

  • 子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
  • 子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，子类不能访问基类实例的protected方法。

4、类 new对象 重点

new对象其实是调用构造方法 ，但我们发现刚写的类里并没有构造方法 ,事实上，如果你的类没有构造方法系统会送一个空的构造方法。

构造方法

构造方法    /***  1 new 其实是在调用构造方法*  2 如果一个类里边没有构造方法 会自动创建一个空的构造方法*  3 构造方法能传参数，在构造期间就把对象得值赋好*  4 一旦有了新的参数的构造方法，空构造就不在了，如果想保留，就得手动写上*  Car是类，小car是引用（指向内存里的一片区域)*  5 重载的构造方法，名字一样，参数不一样。**/

​

​ 那我们怎么写自己的构造方法：

名字和类名完全一样大小写也不能有区别,不能有返回值void也不写。

一旦你定义了自己的构造方法，系统就不会赠送空的构造方法

重载

/**重载* 1 方法名相同* 2 方法的参数类型，参数个数不一样* 3 方法的返回类型可以不相同* 4 方法的修饰符可以不相同* 5 main 方法也可以被重载**/

重点工作、难点一，要理解：

package com.xinzhi.test;/** * @author 张楠 * @date 2020/2/6 */public class Dog {    public static void main(String[] args) {        //使用无参的构造方法        Dog teddy = new Dog();        //使用setter赋值        teddy.setName("金毛");        System.out.println(teddy.getName());        System.out.println("-------------------------------------------------");        //使用有参的构造方法，直接给name赋值        Dog golden  = new Dog("金毛");        System.out.println(golden.getName());        System.out.println("-------------------------------------------------");        //直接new对象看看new的时候是不是调用了构造方法，事实证明是的        new Dog("哈士奇");    }    private String name;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    //空的构造方法，名字必须和类名一样，不能有一点区别    public Dog(){    }    //构造方法和其他方法一样可以重载，可以有参数，名字必须和类名一样，不能有一点区别    public Dog(String name){        System.out.println("验证构造方法被调用的时机：【"+ name + "】被创建！");        this.name = name;    }}结果金毛-------------------------------------------------验证被调用的时机：【金毛】被创建！金毛-------------------------------------------------验证被调用的时机：【哈士奇】被创建！

5、setter and getter，规范，记住这么写就行了

所有的属性必须私有化：

使用setter和getter，因为方法能控制取值和赋值的过程。

/** * 定义狗类 * @author zn * @date 2020/2/2 */public class Dog {        //有哪些特点    //定义狗有颜色这个属性    private String color;    //定义狗有种类这个属性    private String type;    //定义狗有年龄这个属性    private int age;        //java约定使用setter和getter方法进行属性的取值和赋值    public String getColor() {        return color;    }    public void setColor(String color) {        this.color = color;    }    public String getType() {        return type;    }    public void setType(String type) {        this.type = type;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    //..狗还有很多属性和方法，我们无法一一列举}

6、 封装

extends 单继承，一个爹可以有多个儿子，一个儿子只能有一个爹。

有个 顶级父类叫Object，所有的对象都有一个父类叫Object,这是规定，记住。

所以所有的对象都有object的所有方法。Object obj = new Object()；

思想：一个对象调用方法的时候，首先去自己的类里边找，找不到的话就去父类找，父类找也不到，就去父类的父类找，直到Object，找到为止！

重点工作、难点二、一样要理解：

//你建了包会自动给你创建packagepackage com.xinzhi.myextends;/** * 封装一个动物类作为父类 * @author 张楠 * @date 2020/2/6 */public class Animal {    private String name;    public void breathe(){        System.out.println(this.name + "在呼吸。");    }    public void eat(){        System.out.println(this.name + "会吃东西。");    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }}

package com.xinzhi.myextends;/** * 封装鸟类 * @author 张楠 * @date 2020/2/6 */public class Bird extends Animal {    //鸟会飞    public void fly(){        System.out.println(this.getName() + "会飞！");    }}

package com.xinzhi.myextends;/** * 封装一个鱼类 * @author 张楠 * @date 2020/2/6 */public class Fish extends Animal {    //鱼类有独立的方法，游泳    public void swimming(){        System.out.println(this.getName() + "会游泳！");    }    //重写呼吸的方法，因为特殊，那么鱼类在调用breathe方法时先来这里找，找到了就不去父类找了    public void breathe() {        System.out.println("我用腮呼吸呦！");    }}

package com.xinzhi.myextends;import java.io.FilterReader;/** * @author 张楠 * @date 2020/2/6 */public class Test {    public static void main(String[] args) {        Bird bird = new Bird();        //bird里没有setName方法，怎么办去父类找        bird.setName("鸟儿");        //bird里有fly方法，直接调用        bird.fly();        //bird里没有breathe方法，怎么办去父类找        bird.breathe();        System.out.println("-----------------------------");        Fish fish = new Fish();        //fish里没有setName方法，怎么办去父类找        fish.setName("小鱼儿");        //去自己类找发现有就不去父类里找了，这叫重写了父类的方法        fish.breathe();        //fish里没有swimming方法，怎么办去父类找        fish.swimming();    }}

7、String

字符串是引用类型，但是为什么不用new，因为太常用了，就简化了。

如果你不觉的麻烦，也能写成：

String name = new String("name");实际上String name = "name";   就行了

既然是个对象就有属性和方法：

他的方法无非就是帮助我们方便的处理这个字符串。

注：使用string一定要注意，必须用一个新的String接受。

String substring = name.substring(1, 3);

案例、这几个最好记住：

符串查找

String 类的 indexOf() 方法在字符串中查找子字符串出现的位置，如过存在返回字符串出现的位置（第一位为0），如果不存在返回 -1。

public class SearchStringEmp {   public static void main(String[] args) {      String strOrig = "xinzhi bigdata Java";      int intIndex = strOrig.indexOf("Java");      if(intIndex == - 1){         System.out.println("没有找到字符串 Java");      }else{         System.out.println("Java 字符串位置 " + intIndex);      }   }}

也可以用contains() 方法

字符串替换

java String 类的 replace 方法可以替换字符串中的字符。

public class test {    public static void main(String args[]){            String str="Hello World,Hello Java.";            System.out.println(str.replace('H','W')); //替换全部            System.out.println(str.replaceFirst("He","Wa")); //替换第一个遇到的            System.out.println(str.replaceAll("He", "Ha")); //替换全部       }}
字符串分割

split(string) 方法通过指定分隔符将字符串分割为数组。

public class test {    public static void main(String args[]){            String str="www-baidu-com";            String delimeter = "-";  //指定分隔符            String[] temp = str.split(delimeter);  //分割字符串            //普通for循环            for(int i =0; i < temp.length; i++){                System.out.println(temp[i]);                System.out.println("");            }                        System.out.println("----java for each循环输出的方法-----");            String str1 = "www.baidu.com";            String delimeter1 = "\\.";   //指定分隔符，.号需要转义，不会明天讲            String[] temp1 = str1.split(delimeter1);            for (String x : temp1){                System.out.println(x);                System.out.println("");            }           }}
字符串截串

substring(string) 方法可以截取从第几个下标（0开始，包含第这一个开始）到第几个下标（不包含）的字符串。

public class test {    public static void main(String args[]){        String name = new String("name");        String substring = name.substring(1, 3);    }}
字符串小写转大写

String toUpperCase() 方法将字符串从小写转为大写。

String str = "string runoob";String strUpper = str.toUpperCase();

8、基础类型的包装类

现在知道有这么个东西就行了，不用练，没几个重要的方法，用的时候讲。

因为基础类型没有方法，不好操作。

所有java对每一种基础类型都进行了包装，生成包装类

int -》 Integer

Integer是个对象，本来是要new

但是太常用了，所以简化了定义的方式，和基础类型一样。

Integer i= 3；

自动装箱 => new Integer(3); 看见变量是个Integer 而后边没new 就自动帮你new一个。

System.out.println(i)

自动拆箱 看见是个包装类，但这里需要打印的是基础类型，自动转。

9、this关键字

this 关键字指内存里分配好空间的（对象）

思维

首先要思考这个工程有哪些角色

1、首先思考这个系统有什么功能 ，首先肯定是一个功能一个方法。2、每一个功能有多复杂，复杂功能能不能拆开，比如一个功能分三步走，每一步能不能单独定义成一个方法。3、思考整个系统的逻辑顺序，什么情况下会被调用。4、有些小功能能不能独立为方法，很多共同的代码，需要抽离成方法。

类的加载（4.20）

1、成员变量与局部变量

成员变量 属性 定义之后有默认初始值基础数据类型 有初始值

基础数据类型,引用数据类型，局部变量必须手动初始化

静态变量全部大写，下划线链接

2、引用传递和值传递

引用传递传的是地址，值传递传的是值

3、基础数据类型包装类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jWVYVeRt-1635652961164)(JAVA 笔记.assets/image-20210420161225708.png)]

4、自动拆装箱

  • 自动装箱

将基础数据类型转成包装类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ISchcbk1-1635652961165)(JAVA 笔记.assets/image-20210421081540919.png)]

  • 自动拆箱

将包装类转成基础数据类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qpLTSMLD-1635652961166)(JAVA 笔记.assets/image-20210421081620741.png)]

5、类的加载内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1wksXh0t-1635652961167)(JAVA 笔记.assets/类加载过程.png)]

继承（4.21）

1、继承

  1. 使用extends关键字实现。

  2. 单继承，一个爹可以有多个儿子，一个儿子只能有一个爹。

  3. 有个 顶级父类叫Object，所有的对象都有一个父类叫Object，这是规定，记住。所以所有的对象都能调用object的所有方法，比如toString()。

  4. new一个子类，一定会先new一个父类，子类的构造方法中第一句默认就是super()，意思就是构造子类一定会先构造一个子类。

  5. 重写父类的方法使用@Override 注解

  6. super

    super指向了引用的父类，可以当作父类的构造器

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HWiyUSe3-1635652961168)(JAVA 笔记.assets/image-20210421114937713.png)]

2、实例图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YV7EkUUq-1635652961169)(JAVA 笔记.assets/image-20210421111925285.png)]

/** * @author zn * @date 2020/2/10 **/public class Father {    public Father(){        System.out.println("爹被创建");    }    public void say(){        System.out.println("我是爹");    }}

/** * @author zn * @date 2020/2/10 **/public class Son extends Father {    public Son(){        super();        System.out.println("儿子被创建！");    }}

/** * @author zn * @date 2020/2/9 **/public class Test {    public static void main(String[] args) {        Son son = new Son();    }}结果--爹被创建儿子被创建！

思想：一个对象调用方法的时候，首先去自己的类里边找，找不到的话就去父类找，父类找也不到，就去父类的父类找，直到Object，找到为止！

类的加载顺序

1.父类的静态属性

​ 类加载的时候就会调用

​ 类加载的时机，第一次主动使用就会主动加载这个类， 被他加载到内存当中

2.父类的静态代码块

3.子类的静态属性

4.子类的静态代码块

5.父类的非静态属性

6.父类的非静态代码块

7.父类的构造器

8.子类的非静态属性

9.子类的非静态代码块

10.子类的构造器

instanceof和对象转型

instanceof

instanceof 判断传的类是否是指定的父类

重写

当父类的方法不满足所需要的要求，就需要进行重写

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iBxIT16O-1635652961170)(JAVA 笔记.assets/image-20210422092959956.png)]

静态方法

静态方法一般当作工具来使用

static 的属性通常当作常量使用,记录一些不变的但是到处可能使用的东西

ToString

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QTllmcuF-1635652961170)(JAVA 笔记.assets/image-20210422173010992.png)]

打印一个类的具体内容具体属性需要重写它的ToString方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WKQwcrK2-1635652961171)(JAVA 笔记.assets/image-20210422173326070.png)]

多态

存在的前提

1、要有继承

//先定义一个父类

/** * @author zn * @date 2020/2/9 **/public class  Animal {    private String type;    public Animal(String type) {        this.type = type;    }        //所有的动物都能吃    public  void eat(){        System.out.println("动物在吃食物");    };    public void breathe(){        System.out.println("呼吸");    }    public String getType() {        return type;    }    public void setType(String type) {        this.type = type;    }}
2、要有重写
/** * @author zn * @date 2020/2/9 **///有继承public class Dog extends Animal {    public Dog(String type) {        super(type);    }    //狗有狗的吃方法    //有重写    @Override    public void eat() {        System.out.println(this.getType() + "在吃骨头！");    }    public void enjoy(){        System.out.println("摇尾巴！");    }}

/** * @author zn * @date 2020/2/9 **///有继承public class Cat extends Animal {    public Cat(String type) {        super(type);    }    //有重写    @Override    public void eat() {        System.out.println(this.getType() +"在吃鱼！");    }}
3、要有父类引用指向子类对象
/** * @author zn * @date 2020/2/9 **/public class Test {    public static void main(String[] args) {        //父类引用指向子类对象，子类能完成父类的一切工作        Animal dog= new Dog("小狗");        dog.eat();        //父类引用指向子类对象，子类能完成父类的一切工作        Animal cat = new Cat("小猫");        cat.eat();    }}--结果小狗在吃骨头！小猫在吃鱼！
好处一、灵活
/** * @author zn * @date 2020/2/10 **/public class Girl {    public void KeepAnimal(Animal animal){        System.out.println("小姑娘开始给"+animal.getType()+"喂食。");         System.out.println("小姑娘开始给"+animal.getType()+"喂食。");        //没有重写的方法，调用时就不叫多态        animal.breathe();        //重写了的方法会根据传入的实际的动物调用        animal.eat();    }}

/** * @author zn * @date 2020/2/9 **/public class Test {    public static void main(String[] args) {        Animal dog= new Dog("小狗");        Animal cat = new Cat("小猫");                //武三水养了条狗        Girl wss = new Girl();        wss.KeepAnimal(dog);        //刘慧慧养了一只猫        Girl lhh = new Girl();        lhh.KeepAnimal(cat);                //这样让girl 养动物很灵活    }}

好处有很多，慢慢再体会

抽象类

​ 有些类天然的就是为了让子类继承，而不是为了在父类中调用，这类方法存在的目的就是规定了子类，必须要有这些方法，比如动物类就规定，你实现了我这个类，就必须有eat的方法，而且你必须重写。

​ 对于这种情况，java提出了抽象类，这种类，里边可以有一些方法没有方法体，我们称之为抽象方法，抽象方法必须使用abstract修饰，同时，如果有了abstract抽象方法之后，这个类必须被定义成抽象方法，也使用abstract修饰。

​ 抽象方法是对子类的约束，不管是猫是狗是蛇是龙，他必须都能吃东西。

/** * @author zn * @date 2020/2/9 **/public abstract class  Animal {    private String type;    public Animal(String type) {        this.type = type;    }    //所有的动物都能吃    //规定这是个抽象方法，子类必须实现    public abstract void eat();    public void breathe(){        System.out.println("呼吸");    }    public String getType() {        return type;    }    public void setType(String type) {        this.type = type;    }}

注意：

  1. 不能new，因为有某些方法没有方法体。这些方法就是用来重写的，就是定义了子类必须有这些方法。
  2. 他必须被继承才能用，必须实现所有的抽象方法
  3. 如果一个类继承了抽象类，要么、把自己申明成一个抽象类；要么、实现抽象类的所有方法

要么、实现抽象类的所有方法

接口

当一个类里全是抽象方法时，我们称这类方法叫接口，省略abstract，class改为interface。

注意：接口里省略权限修饰符，默认为public，一个原因是因为他一定是给子类去实现（继承里叫重写）的。

/** * @author zn * @date 2020/2/10 **/public interface Car {    /**     * 汽车能跑，不管什么汽车都能跑，接口里省略权限修饰符，默认为public     */    public void run();    /**     * 汽车能坐人，不管什么汽车都能坐人，接口里省略权限修饰符，默认为public     */    void ride();}

/** * @author zn * @date 2020/2/10 **///接口要被实现，关键字implements，必须实现里边所有的方法public class CRV implements Car {    @Override    public void run() {        System.out.println("CRV 嘟嘟嘟的跑");    }    @Override    public void ride() {		System.out.println("CRV座位就是大，坐着宽敞");    }}

/** * @author zn * @date 2020/2/10 **/public class Passat implements Car {    @Override    public void run() {        System.out.println("帕沙特  啪啪啪的跑");    }    @Override    public void ride() {		System.out.println("CRV座位就是气派，坐着有面子");    }}

java是单继承，但是是多实现，一个类可以实现多个接口，但只能继承一个父类。

实现接口，必须实现接口里全部的方法。

接口里只能有静态常量、抽象方法。

静态常量可以在任何的类、抽象类、接口中定义，它和继承，封装，多态以及new不new没有任何毛线关系。

public static final int num  = 1;

升级版超级数组

1、类名
简单类名：  SuperLinked全类名：    com.zhixin.util.SuperLinked   （包名加类名）
2、包的引入
//该包下的内容全部引入import com.zhixin.util.*;   //只引入一个类import com.zhixin.util.SuperLinked;
3、对象转型

强制转型：从父类的类型强制转为子类，如果传入的真的是该类型，则强转没有问题；如果不是就会报错。

合适的方法是使用instanceof 首先进行判断，确定类型之后再处理。

package com.xinzhi.polymorphism;/** * @author zn * @date 2020/2/10 **/public class Girl {    public void KeepAnimal(Animal animal){        //使用instanceof 判断传进来的对象是不是一个Dog类型        if(animal instanceof Dog){            //强转成某一个子类            Dog dog = (Dog)animal;            dog.enjoy();        }        System.out.println("小姑娘开始给"+animal.getType()+"喂食。");        //没有重写的方法，调用时就不叫多态        animal.breathe();        //重写了的方法会根据传入的实际的动物调用        animal.eat();    }    public void buyCar(Carola car){        System.out.println("小姑娘买车了！发动");        car.run();    }}
4、泛型

  当某个类不知道自己内部处理的数据的真实类型时，可以使用泛型、方法是在类后加，不一定是T，其他字母也行，但一般写成T或E。T就是个未知数，只有当你去new对象时指定了确定的类型时，代码里的T就会变为实际的类型，具体从代码里思考。

二、项目代码

package com.zhixin.util;/** * @author zn * @date 2020/2/7 **/public class SuperArray<T> extends Super<T> {    //维护一个数组,要想什么都存，就要使用顶级父类    private Object[] array;    //当前最后一个数字的下边，要为-1 ，以为数组的第一个下标为0    private int currentIndex = -1;    //构造是初始化    public SuperArray(){        array = new Object[8];    }    //添加数据的方法    public void add(T data){        System.out.println("我是数组的实现！---add");        currentIndex++;        //自动扩容        if(currentIndex > array.length-1){            array = dilatation(array);        }        array[currentIndex] = data;    }    //根据下标查询数字    public T get(int index){        System.out.println("我是数组的实现---get");        return (T)array[index];    }    //查看当前有多少个数字    public int size(){        return currentIndex + 1;    }    //数组扩容的方法    private Object[] dilatation(Object[] oldArray){        Object[] newArray = new Object[oldArray.length * 2];        for (int i = 0; i < oldArray.length; i++) {            newArray[i] = oldArray[i];        }        return newArray;    }    //验证下标是否合法    private boolean validateIndex(int index) {        //只要有一个不满足就返回false        return index <= currentIndex && index >= 0;    }}

package com.zhixin.util;/** * @author zn * @date 2020/2/11 **/public class SuperLinked<T> extends Super<T> {    private Node head = null;    private Node tail = null;    private int length = 0;    //添加元素    public void add(T data){        System.out.println("我是链表的实现-----add");        Node node = new Node<>();        node.setNum(data);        if (length == 0) {            //如果第一次添加一共就一个节点            head = node;        }else{            //和尾巴拉手            tail.setNextNode(node);        }        //把心添加进来的当成尾巴        tail = node;        length ++;    }    //根据下标查询数字,非常有意思的写法    public T get(int index){        System.out.println("我是链表的实现------get");        if(index > length){            return null;        }        //小技巧        Node targetNode = head;        for (int i = 0; i < index; i++) {            targetNode = targetNode.getNextNode();        }        return (T)(targetNode.getNum());    }    //查看当前有多少个数字    public int size(){        return length;    }    class Node {        //存储的真实数据        private T num;        //写一个节点        private Node nextNode = null;        public T getNum() {            return num;        }        public void setNum(T num) {            this.num = num;        }        public Node getNextNode() {            return nextNode;        }        public void setNextNode(Node nextNode) {            this.nextNode = nextNode;        }    }}

package com.zhixin.util;/** * @author zn * @date 2020/2/11 **/public abstract class Super<T> {    /**     * 标记所有的子类实现必须有add方法，添加数据     * @param data     */    public abstract void add(T data);    /**     * 标记所有的子类实现必须有get方法，获取数据     * @param index     * @return     */    public abstract T get(int index);    /**     * 标记所有的子类实现必须有size方法，数据大小     * @return     */    public abstract int size();}

静态内部类（4.24）

使用方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AWY2O2BY-1635652961172)(JAVA 笔记.assets/image-20210424091302922.png)]

如果一个类只被某一个类调用，就可以将它放在类的内部，叫做静态内部类。

匿名内部类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FAGjspCA-1635652961173)(JAVA 笔记.assets/image-20210424093537156.png)]

接口没有名字，却实现了所有方法.

只能用一次，实现一个接口，必须重写

将内部类保存起来，可以用好几次

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cdZaKYZS-1635652961174)(JAVA 笔记.assets/image-20210424093758226.png)]

打jar包和引进jar包

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nf1eqyWg-1635652961175)(JAVA 笔记.assets/image-20210424094932967.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LKc5B8tk-1635652961176)(JAVA 笔记.assets/image-20210424095041715.png)]

final

被final修饰的类不能被继承

修饰变量的值不能改[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ml66kflM-1635652961177)(JAVA 笔记.assets/image-20210424104828279.png)]

集合与链表

LinkedList 本质是一个链表

ArrayList 本质是一个数组

两者的方法相差不大

public void Testlist(){    List<User> list = new ArrayList<>();    list.add(new User("晓倩",456));    list.remove(new User("晓倩",456));    for (int i = 0; i < list.size() ; i++) {      System.out.println(list.get(i).getUsername() + list.get(i).getPassword());    }}

哈希

Hashcoad

将字符串转换成一组数字[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8svurcpu-1635652961178)(JAVA 笔记.assets/image-20210425084818195.png)]

hash是什么
hash是一个函数，该函数中的实现就是一种算法，就是通过一系列的算法来得到一个hash值，这个时候，我们就需要知道另一个东西，hash表，通过hash算法得到的hash值就在这张hash表中，也就是说，hash表就是所有的hash值组成的，有很多种hash函数，也就代表着有很多种算法得到hash值, 编写散列函数是老生常谈的研究课题，是数学家和理论方面的计算机科学家的研究任务, 我们只需要知道那些比较好用, 大概为啥好用就可以了

hashcode是啥
hashcode就是通过hash函数得来的，通俗的说，就是通过某一种算法得到的，hashcode就是在hash表中有对应的位置。

每个对象都有hashcode，对象的hashcode怎么得来的呢？

首先一个对象肯定有物理地址，网上有人把对象的hashcode说成是对象的地址，事实上这种看法是不全面的，确实有些JVM在实现时是直接返回对象的存储地址，但是大多时候并不是这样，只能说可能存储地址有一定关联,

那么对象如何得到hashcode呢？通过对象的内部地址(也就是物理地址)转换成一个整数，然后该整数通过hash函数的算法就得到了hashcode(不同jvm的实现不同, hotspot的实现贴在了最后)，所以，hashcode是什么呢？就是在hash表中对应的位置。这里如果还不是很清楚的话，举个例子，hash表中有 hashcode为1、hashcode为2、(…)3、4、5、6、7、8这样八个位置，有一个对象A，A的物理地址转换为一个整数17(这是假如)，就通过直接取余算法，17%8=1，那么A的hashcode就为1，且A就在hash表中1的位置。

为什么使用 HashCode
HashCode的存在主要是为了查找的快捷性, HashCode是用来在散列存储结构中确定对象的存储地址的 ( 用hashcode来代表对象在hash表中的位置 ) , hashCode 存在的重要的原因之一就是在 HashMap(HashSet 其实就是HashMap) 中使用（其实Object 类的 hashCode 方法注释已经说明了 ），HashMap 之所以速度快，因为他使用的是散列表，根据 key 的 hashcode 值生成数组下标（通过内存地址直接查找，不需要判断, 但是需要多出很多内存，相当于以空间换时间）

HashMap

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vJ5IiVys-1635652961179)(JAVA 笔记.assets/image-20210425091928855.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ji20aV2L-1635652961180)(JAVA 笔记.assets/image-20210425085027641.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ggZkIhk9-1635652961181)(JAVA 笔记.assets/image-20210425084737456.png)]

在HashMap中如果Key相同 就将前一个覆盖

遍历HashMap

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fdHU1aNE-1635652961182)(JAVA 笔记.assets/image-20210425090605462.png)]

Hash是无序的，不能排序

HashSet

存储时只有Key 无value,不可以存重复的值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K54MnWyh-1635652961183)(JAVA 笔记.assets/image-20210425091742912.png)]

因为无下标使用增强for遍历

迭代器

iterator

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zphU9frG-1635652961184)(JAVA 笔记.assets/image-20210425163548845.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TvgcasHX-1635652961186)(JAVA 笔记.assets/image-20210425163104329.png)]

HashMap使用迭代器遍历

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nD14ojyE-1635652961187)(JAVA 笔记.assets/image-20210425170434967.png)]

！！！使用迭代器删除一个元素

Java中Collection和Collections的区别

1、java.util.Collection 是一个集合接口（集合类的一个顶级接口）。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式，其直接继承接口有List与Set。

2、Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。

可变参数

public int sun (...nums){} //...nums代表可变参数

可变参数必须放在最后，一个方法只能有一个[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NYdxm2eh-1635652961188)(JAVA 笔记.assets/image-20210427154149908.png)]

Data方法

时间戳（Timestamp）

时间戳是指格林威治时间1970年01月01日00时00分00秒（北京时间1970年01月01日8时00分00秒）起止到现在的总毫秒数

Data使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cQwuIdmP-1635652961188)(JAVA 笔记.assets/image-20210427161345111.png)]

日历类Calender

创建 Calendar 对象
Calendar 是一个抽象类, 无法通过直接实例化得到对象. 因此, Calendar 提供了一个方法 getInstance,来获得一个Calendar对象, 得到的 Calendar 由当前时间初始化.

Calendar cal = Calendar.getInstance();

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GLpOIlCg-1635652961189)(JAVA 笔记.assets/20181205012638154.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3a7UKYLb-1635652961190)(JAVA 笔记.assets/20181205012900902.png)]

月数从0开始（0，1，2，3，4，5，6，7，8，9，10，11）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TxbRIxH0-1635652961191)(JAVA 笔记.assets/image-20210502104405044.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KZNJVYtW-1635652961192)(JAVA 笔记.assets/image-20210502104435087.png)]

设计模式（5.2）

最常问的（抽象工厂，代理，单例）

单例

堆内存中只能有一个实例对象，就叫做单例

单例模式
单例模式(Singleton Pattern)是Java中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这—实例。
意图: 保证一个类仅有一个实例，并提供一个访问它的全局访问点。主要解决:一个全局使用的类频繁地创建与销毁。
何时使用: 当您想控制实例数目，节省系统资源的时候。
如何解决: 判断系统是否已经有这个单例，如果有则返回，如果没有则创建。关键代码:构造函数是私有的。

饿汉式单例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UdCZ0KAY-1635652961193)(JAVA 笔记.assets/image-20210502113501649.png)]

是线程安全的

懒汉式单例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vQ89sLow-1635652961194)(JAVA 笔记.assets/image-20210502130338279.png)]

归并的思想

public static int[] Lianjie(int[] a1,int[] a2){    //定义一个新数组    int[] tamp = new int[a1.length + a2.length];    int left = 0;    int right = 0;    int con = 0;	    while (a1.length != left){        if (a1[left] > a2[right]){            tamp[con] = a2[right];            right++;        }else {            tamp[con] = a1[left];            left++;        }        con++;    }    if (con >= a1.length){        for (int i = right; i < a2.length ; i++) {            tamp[con++] = a2[i];        }    }    if (con >= a2.length){        for (int i = left; i < a1.length ; i++) {            tamp[con++] = a1[i];        }    }    return tamp;}

线程（Thread）

进程和线程的区别：一个软件就是一个进程，一个进程可以运行多个线程，我们可以使用多个线程同时执行提高效率。

多个线程同时执行的时候，互相之间没有必然的顺序，他是有cpu的调度决定的。

启动线程必须调用start方法，不能调用run,调用run只是方法调用，start是个native的本地方法，会调用cpu的资源，开辟线程。

synchronized保证线程安全

List线程不安全，Vector是线程安全的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wnPBHaCE-1635652961195)(JAVA 笔记.assets/image-20210503112117934.png)]

HashMap不是线程安全的，HashTable是线程安全的

String、StringBuffer、StringBuilder

​ 和String类不同的是，StringBuffer和StringBuilder类的对象能够被多次的修改，并且不产生新的未使用对象。
​ StringBuilder类在Java 5中被提出，它和StringBuffer之间的最大不同在于 StringBuilder的方法不是线程安全的（不能同步访问)。由于StringBuilder 相较于StringBuffer有速度优势，==所以多数情况下建议使用StringBuilder类。==然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer类。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sx0bCmmm-1635652961195)(JAVA 笔记.assets/image-20210503120204509.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nulESlZT-1635652961196)(JAVA 笔记.assets/image-20210503121248118.png)]

UUAD

生成一个世界上唯一的字符串

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FO9LKSlJ-1635652961197)(JAVA 笔记.assets/image-20210503121740825.png)]

异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IqJmxmtv-1635652961197)(JAVA 笔记.assets/image-20210503123907041.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pQiI5EKF-1635652961198)(JAVA 笔记.assets/image-20210503124017044.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xxSHXpGu-1635652961198)(JAVA 笔记.assets/image-20210503124434268.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hVxVvkoc-1635652961199)(JAVA 笔记.assets/image-20210503124457226.png)]

InterruptedException

将异常向上一级抛出

public static void main(String[] args) throws InterruptedException {    time();}public static void time() throws InterruptedException {    Thread.sleep(200);}

try{ }catch( ){ }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hOKzn4Ce-1635652961200)(JAVA 笔记.assets/image-20210504094911509.png)]

如果一个异常继承自Exception,则为检查性异常

==printStackTrace()==方法的意思是：在命令行打印异常信息在程序中出错的位置及原因。

System.out.println(e)，这个方法打印出异常，并且输出在哪里出现的异常，不过它和另外一个e.printStackTrace()方法不同。后者也是打印出异常，但是它还将显示出更深的调用信息

2.throw的作用

手动抛出异常但是有时候有些错误在jvm看来不是错误，比如说
int age = 0;
age = -100;
System.out.println(age);
很正常的整形变量赋值，但是在我们眼中看来就不正常，谁的年龄会是负的呢。所以我们需要自己手动引发异常，这就是throw的作用
int age = 0;
age = -100;
if(age<0)
{
Exception e = new Exception();//创建异常对象
throw e;//抛出异常
}
System.out.println(age);

3.throws的作用

​ 声明方法可能回避的异常有异常被抛出了，就要做处理，所以java中有try-catch可是有时候一个方法中产生了异常，但是不知道该怎么处理它，那么就放着不管，当有异常抛出时会中断该方法，而异常被抛到这个方法的调用者那里。这个有点像下属处理不了的问题就交到上司手里一样，这种情况称为回避异常但是这使得调用这个方法就有了危险，因为谁也不知道这个方法什么时候会丢一个什么样的异常给调用者，所以在定义方法时，就需要在方法头部分使用throws来声明这个方法可能回避的异常

throws和throw

**throws：

用来声明一个方法可能产生的所有异常，不做任何处理而是将异常往上传，谁调用我我就抛给谁。
用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常
throw：

则是用来抛出一个具体的异常类型。
用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理
throw则是抛出了异常，执行throw则一定抛出了某种异常

运行时异常

ArithmeticException 算数异常

ClassCastException：类转换异常

NullPointerExceptionextends 空指针异常

检查性异常

ClassNotFoundException,未找到类

InterruptedException,中断异常

ioException

SQLException,

TimeoutException,

FileNotFoundException

java IO入门

一、 java IO 流的概念

java的io是实现输入和输出的基础，可以方便的实现数据的输入和输出操作。在java中把不同的输入/输出源（键盘，文件，网络连接等）抽象表述为“流”(stream)。

二、 Io流的分类：

按照不同的分类方式，可以把流分为不同的类型。常用的分类有三种：

1、 按照流的流向分，可以分为输入流和输出流。

  • 输入流： 只能从中读取数据，而不能向其写入数据。
  • 输出流：只能向其写入数据，而不能向其读取数据。
    此处的输入,输出涉及一个方向的问题，对于如图15.1所示的数据流向，数据从内存到硬盘，通常称为输出流——也就是说，这里的输入，输出都是从程序运行所在的内存的角度来划分的。

对于如图15.2所示的数据流向，数据从服务器通过网络流向客户端，在这种情况下,Server端的内存负责将数据输出到网络里，因此Server端的程序使用输出流；Client端的内存负责从网络中读取数据，因此Client端的程序应该使用输入流。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YNAM9GxH-1635652961201)(JAVA 笔记.assets/11798292-1268450dfccafde7.png)]

2 、按照操作单元划分，可以划分为字节流和字符流。

字节流和字符流的用法几乎完成全一样，区别在于字节流和字符流所操作的数据单元不同，字节流操作的单元是数据单元是8位的字节，字符流操作的是数据单元为16位的字符。

字节流主要是由InputStream和outPutStream作为基类，而字符流则主要有Reader和Writer作为基类。

3、 按照流的角色划分为节点流和处理流。

可以从/向一个特定的IO设备（如磁盘，网络）读/写数据的流，称为节点流。节点流也被称为低级流。图15.3显示了节点流的示意图。哪里需要怼哪里。
 
从图15.3中可以看出，当使用节点流进行输入和输出时，程序直接连接到实际的数据源，和实际的输入/输出节点连接。

处理流则用于对一个已存在的流进行连接和封装，通过封装后的流来实现数据的读/写功能。处理流也被称为高级流。图15.4显示了处理流的示意图。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gRH2LpQS-1635652961201)(JAVA 笔记.assets/11798292-52e163c670a11e01.png)]

4、java输入/输出流体系中常用的流的分类表

| 分类 | 字节输入流 |字节输出流|字符输入流|字符输出流|

分类 字节输入流 字节输出流 字符输入流 字符输出流
抽象基类 InputStream OutputStream Reader Writer
访问文件 FileInputStream FileOutputStream FileReader FileWriter
访问数组 ByteArrayInputStream ByteArrayOutputStream CharArrayReader CharArrayWriter
访问字符串 StringReader StringWriter
缓冲流 BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter
转换流 InputStreamReader OutputStreamWriter
对象流 ObjectInputStream ObjectOutputStream

转换流能都将字符流转成字节流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u6nEVDyN-1635652961202)(JAVA 笔记.assets/20161220152558257)]

三、具体操作

1、文件的基本操作

@Testpublic void testFile() throws Exception{    //创建文件    File file = new File("E:\\test\\b.txt");    file.createNewFile();    //查看文件夹下的文件    File file2 = new File("E:\\test\\b.txt");    String[] list = file2.list();    for (int i = 0; i < list.length; i++) {        System.out.println(list[i]);    }    //其他的方法自己查看}

2、复制文件带有进度条

@Testpublic void testFileInputStream() throws Exception {    File file = new File("E:\\test\\a\\233.mp4");    //拿到文件的大小    long dataLength = file.length();    //构建一个输入流，他的数据要流入内存，咱们的程序    InputStream inputStream = new FileInputStream(file);    //构建一个输出流，他的数据要从内存（咱们的程序）流到另一个文件夹    OutputStream outputStream = new FileOutputStream("E:\\test\\b\\233.mp4");    //新建一个水泵，能存一点水，每次对对1k    byte[] buffer = new byte[1024 *1024*50];    Long currentLength = 0L;    //如果read返回-1说明读完了    int len;    int showNumber = 0;    while ( (len = inputStream.read(buffer)) != -1 ){        outputStream.write(buffer,0,len);        currentLength += len;        //当下加载了百分之多少        int currentPer  = (int)(((double)currentLength/dataLength)*100);        //目的是不重复显示        if(showNumber !=  currentPer){            showNumber = currentPer;            System.out.println("已经拷贝了百分之" + showNumber);        }    }    outputStream.flush();    outputStream.close();    inputStream.close();}

3、字节流读文件

@Testpublic void testInputStream() throws Exception{    //怼了一个输入流到文件上    InputStream wordInput = new FileInputStream("E:\\test\\a\\word.txt");    //建立缓冲区    byte[] bytes = new byte[1024];    int len;    while ( (len = wordInput.read(bytes)) != -1 ){        System.out.println(new String(bytes,0,len, Charset.forName("ISO8859-1")));    }    wordInput.close();}

4、字符流对文件

@Testpublic void testReader() throws Exception{    //怼了一个输入流到文件上    Reader reader = new FileReader("E:\\test\\a\\word.txt");    BufferedReader br = new BufferedReader(reader);    String str;    while ((str = br.readLine()) != null){        System.out.println(str);    }    reader.close();    br.close();}

5、向文件里写内容

//这个用main方法测吧public void testWriter() throws Exception{    //怼了一个输入流到文件上    Writer writer = new FileWriter("E:\\test\\a\\writer.txt");    BufferedWriter bw = new BufferedWriter(writer);    Scanner scanner = new Scanner(System.in);    while (true){        System.out.print("请输入：");        String words = scanner.next();        bw.write(words);        bw.flush();    }}

6、StringReader就是往String上怼

@Testpublic void testStringReader() throws Exception{    //怼了一个string    OutputStream os = new FileOutputStream("E:\\test\\a\\user.txt");    ObjectOutput oo  = new ObjectOutputStream(os);    oo.writeObject(new User("王老师",3,4));    oo.flush();    oo.close();    os.close();}

7、对象流就是对new出来的对象进行序列化

该对象必须实现Serializable接口，才能被序列化。

对象在内存就是一堆0和1，任何文件在内存都是0和1，都能转化成字节数组，进行保存或者网络传输。

对象序列化也是一样的，就是把内存的对象以字节数组的形式上保存，我们能保存在磁盘，或者在网络中传输。

import java.io.Serializable;/** * @author zn * @date 2020/2/14 **/public class User implements Serializable {    private String name;    private int age;    private int gander;    public User(String name, int age, int gander) {        this.name = name;        this.age = age;        this.gander = gander;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public int getGander() {        return gander;    }    public void setGander(int gander) {        this.gander = gander;    }}

@Testpublic void testObjectOut() throws Exception{    //怼了一个string    InputStream is = new FileInputStream("E:\\test\\a\\user.txt");    ObjectInputStream oi  = new ObjectInputStream(is);    User user = (User)(oi.readObject());    System.out.println(user.getName());    is.close();    oi.close();}

四、flush()方法介绍

查阅文档可以发现，IO流中每一个类都实现了Closeable接口，它们进行资源操作之后都需要执行close()方法将流关闭 。但字节流与字符流的不同之处在于：字节流是直接与数据产生交互，而字符流在与数据交互之前要经过一个缓冲区 。
草图：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GS39TjAw-1635652961203)(JAVA 笔记.assets/20160825235002516)]

使用字符流对资源进行操作的时候，如果不使用close()方法，则读取的数据将保存在缓冲区中，要清空缓冲区中的数据有两种办法：

  • public abstract void close() throws IOException
    关闭流的同时将清空缓冲区中的数据，该抽象方法由具体的子类实现

  • public abstract void flush() throws IOException
    不关闭流的话，使用此方法可以清空缓冲区中的数据，但要注意的是，此方法只有Writer类或其子类拥有，而在Reader类中并没有提供。此方法同样是在具体的子类中进行实现 。

客户端与服务器

服务器

public class QQsocket {    public static void main(String[] args) {        ServerSocket server;        InputStream inputStream = null;        try {                //创建一个服务器                server = new ServerSocket();                //连接一个端口                server.bind(new InetSocketAddress(8888));                //等待输入数据                Socket acc = server.accept();                //等待用流接收                 inputStream = acc.getInputStream();                byte[] by = new byte[1024];                int len ;                while ((len = inputStream.read(by) )!= -1){                    System.out.println(new String(by,0,len));                }            } catch (IOException e) {                e.printStackTrace();            }finally {                if (inputStream != null){                    try {                                         inputStream.close();                    } catch (IOException e) {                        e.printStackTrace();                    }                }            }    }

客户端

public class qq {    public static void main(String[] args) {        Socket socket = new Socket();        OutputStream outputStream = null;        try {            socket.connect(new InetSocketAddress("172.16.1.243", 8888));             outputStream = socket.getOutputStream();            String nas = "早上好~~~晓倩！";            outputStream.write(nas.getBytes());        } catch (IOException e) {            e.printStackTrace();        }finally {            if (outputStream != null){                try {                    outputStream.flush();                    outputStream.close();                } catch (IOException e) {                    e.printStackTrace();                }            }        }    }}

序列化和反序列化

1、什么是序列化和反序列化

（1）Java序列化是指把Java对象转换为字节序列的过程，而Java反序列化是指把字节序列恢复为Java对象的过程；

（2）**序列化：**对象序列化的最主要的用处就是在传递和保存对象的时候，保证对象的完整性和可传递性。序列化是把对象转换成有序字节流，以便在网络上传输或者保存在本地文件中。序列化后的字节流保存了Java对象的状态以及相关的描述信息。序列化机制的核心作用就是对象状态的保存与重建。

（3）**反序列化：**客户端从文件中或网络上获得序列化后的对象字节流后，根据字节流中所保存的对象状态及描述信息，通过反序列化重建对象。

（4）本质上讲，序列化就是把实体对象状态按照一定的格式写入到有序字节流，反序列化就是从有序字节流重建对象，恢复对象状态。

2、为什么需要序列化与反序列化

我们知道，当两个进程进行远程通信时，可以相互发送各种类型的数据，包括文本、图片、音频、视频等， 而这些数据都会以二进制序列的形式在网络上传送。

那么当两个Java进程进行通信时，能否实现进程间的对象传送呢？答案是可以的！如何做到呢？这就需要Java序列化与反序列化了！

换句话说，一方面，发送方需要把这个Java对象转换为字节序列，然后在网络上传送；另一方面，接收方需要从字节序列中恢复出Java对象。

当我们明晰了为什么需要Java序列化和反序列化后，我们很自然地会想Java序列化的好处。其好处一是实现了数据的持久化，通过序列化可以把数据永久地保存到硬盘上（通常存放在文件里），二是，利用序列化实现远程通信，即在网络上传送对象的字节序列。

总的来说可以归结为以下几点：

  • 永久性保存对象，保存对象的字节序列到本地文件或者数据库中；
  • 通过序列化以字节流的形式使对象在网络中进行传递和接收；
  • 通过序列化在进程间传递对象；

enum枚举

什么是枚举

我们学习过单例模式，即一个类只有一个实例。而枚举其实就是多例，一个类有多个实例，但实例的个数不是无穷的，是有限个数的。例如word文档的对齐方式有几种：左对齐、居中对齐、右对齐。开车的方向有几种：前、后、左、右！
　我们称呼枚举类中实例为枚举项！一般一个枚举类的枚举项的个数不应该太多，如果一个枚举类有30个枚举项就太多了！

定义枚举类型

定义枚举类型需要使用enum关键字，例如：

public enum Direction {    FRONT, BEHIND, LEFT, RIGHT;}Direction d = Direction.FRONT;

注意，定义枚举类的关键字是enum，而不是Enum，所有关键字都是小写的！
其中FRONT、BEHIND、LEFT、RIGHT都是枚举项，它们都是本类的实例，本类一共就只有四个实例对象。
在定义枚举项时，多个枚举项之间使用逗号分隔，最后一个枚举项后需要给出分号！但如果枚举类中只有枚举项（没有构造器、方法、实例变量），那么可以省略分号！建议不要省略分号！
不能使用new来创建枚举类的对象，因为枚举类中的实例就是类中的枚举项，所以在类外只能使用类名.枚举项。

枚举与switch

枚举类型可以在switch中使用

Direction d = Direction.FRONT;  switch(d) {    case FRONT: System.out.println("前面");break;    case BEHIND:System.out.println("后面");break;    case LEFT:  System.out.println("左面");break;    case RIGHT: System.out.println("右面");break;    default:System.out.println("错误的方向");}Direction d1 = d;System.out.println(d1);

注意，在switch中，不能使用枚举类名称，例如：“case Direction.FRONT：”这是错误的，因为编译器会根据switch中d的类型来判定每个枚举类型，在case中必须直接给出与d相同类型的枚举选项，而不能再有类型。

  1. 所有枚举类都是Enum的子类
    所有枚举类都默认是Enum类的子类，无需我们使用extends来继承。这说明Enum中的方法所有枚举类都拥有。
  • int compareTo(E e)：比较两个枚举常量谁大谁小，其实比较的就是枚举常量在枚举类中声明的顺序，例如FRONT的下标为0，BEHIND下标为1，那么FRONT小于BEHIND；
  • boolean equals(Object o)：比较两个枚举常量是否相等；
  • int hashCode()：返回枚举常量的hashCode；
  • String name()：返回枚举常量的名字；
  • int ordinal()：返回枚举常量在枚举类中声明的序号，第一个枚举常量序号为0；
  • String toString()：把枚举常量转换成字符串；
  • static T valueOf(Class enumType, String name)：把字符串转换成枚举常量。

枚举类的构造器

枚举类也可以有构造器，构造器默认都是private修饰，而且只能是private。因为枚举类的实例不能让外界来创建！

enum Direction {    FRONT, BEHIND, LEFT, RIGHT;//[在枚举常量后面必须添加分号，因为在枚举常量后面还有其他成员时，分号是必须的。枚举常量必须在枚举类中所有成员的上方声明。]        Direction()//[枚举类的构造器不可以添加访问修饰符，枚举类的构造器默认是private的。但你自己不能添加private来修饰构造器。] {        System.out.println("hello");    }}

其实创建枚举项就等同于调用本类的无参构造器，所以FRONT、BEHIND、LEFT、RIGHT四个枚举项等同于调用了四次无参构造器，所以你会看到四个hello输出。

枚举类可以有成员

其实枚举类和正常的类一样，可以有实例变量，实例方法，静态方法等等，只不过它的实例个数是有限的，不能再创建实例而已。

enum Direction {    FRONT("front"), BEHIND("behind"), LEFT("left"), RIGHT("right");        private String name;        Direction(String name) {        this.name = name;    }        public String getName() {        return name;    }}Direction d = Direction.FRONT;System.out.println(d.getName());

因为Direction类只有唯一的构造器，并且是有参的构造器，所以在创建枚举项时，必须为构造器赋值：FRONT(“front”)，其中”front”就是传递给构造器的参数。你不要鄙视这种语法，你应该做的是接受这种语法！
Direction类中还有一个实例域：String name，我们在构造器中为其赋值，而且本类还提供了getName()这个实例方法，它会返回name的值。

  1. 枚举类中还可以有抽象方法
    还可以在枚举类中给出抽象方法，然后在创建每个枚举项时使用“特殊”的语法来重复抽象方法。所谓“特殊”语法就是匿名内部类！也就是说每个枚举项都是一个匿名类的子类对象！

通常fun()方法应该定义为抽象的方法，因为每个枚举常量都会去重写它。
你无法把Direction声明为抽象类，但需要声明fun()方法为抽象方法。

enum Direction {    FRONT() {        public void fun() {            System.out.println("FROND：重写了fun()方法");        }    },     BEHIND() {        public void fun() {            System.out.println("BEHIND：重写了fun()方法");        }    },     LEFT() {        public void fun() {            System.out.println("LEFT：重写了fun()方法");        }    },    RIGHT() {        public void fun() {            System.out.println("RIGHT：重写了fun()方法");        }    };        public abstract void fun()[只需要把fun()方法修改为抽象方法，但不可以把Direction类声明为抽象类。];}
  1. 每个枚举类都有两个特殊方法
    每个枚举类都有两个不用声明就可以调用的static方法，而且这两个方法不是父类中的方法。这又是枚举类特殊的地方，下面是Direction类的特殊方法。
  • static Direction[] values()：返回本类所有枚举常量；
  • static Direction valueOf(String name)：通过枚举常量的名字返回Direction常量，注意，这个方法与Enum类中的valueOf()方法的参数个数不同。

泛型

一、什么是泛型？

Java泛型设计原则：只要在编译时期没有出现警告，那么运行时期就不会出现ClassCastException异常.

泛型：把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型

参数化类型:

  • 把类型当作是参数一样传递
  • <数据类型> 只能是引用类型

相关术语：

  • ArrayList中的E称为类型参数变量
  • ArrayList中的Integer称为实际类型参数
  • 整个称为ArrayList泛型类型
  • 整个ArrayList称为参数化的类型ParameterizedType

二、为什么需要泛型

早期Java是使用Object来代表任意类型的，但是向下转型有强转的问题，这样程序就不太安全

首先，我们来试想一下：没有泛型，集合会怎么样

  • Collection、Map集合对元素的类型是没有任何限制的。本来我的Collection集合装载的是全部的Dog对象，但是外边把Cat对象存储到集合中，是没有任何语法错误的。
  • 把对象扔进集合中，集合是不知道元素的类型是什么的，仅仅知道是Object。因此在get()的时候，返回的是Object。外边获取该对象，还需要强制转换

有了泛型以后：

  • 代码更加简洁【不用强制转换】
  • 程序更加健壮【只要编译时期没有警告，那么运行时期就不会出现ClassCastException异常】
  • 可读性和稳定性【在编写集合的时候，就限定了类型】

2.1有了泛型后使用增强for遍历集合

在创建集合的时候，我们明确了集合的类型了，所以我们可以使用增强for来遍历集合！

        //创建集合对象        ArrayList list = new ArrayList<>();        list.add("hello");        list.add("world");        list.add("java");        //遍历,由于明确了类型.我们可以增强for        for (String s : list) {            System.out.println(s);        }

三、泛型基础

3.1泛型类

泛型类就是把泛型定义在类上，用户使用该类的时候，才把类型明确下来…这样的话，用户明确了什么类型，该类就代表着什么类型…用户在使用的时候就不用担心强转的问题，运行时转换异常的问题了。

  • 在类上定义的泛型，在类的方法中也可以使用！
/*    1:把泛型定义在类上    2:类型变量定义在类上,方法中也可以使用 */public class ObjectTool<T> {    private T obj;    public T getObj() {        return obj;    }    public void setObj(T obj) {        this.obj = obj;    }}
  • 测试代码：

用户想要使用哪种类型，就在创建的时候指定类型。使用的时候，该类就会自动转换成用户想要使用的类型了。

    public static void main(String[] args) {        //创建对象并指定元素类型        ObjectTool tool = new ObjectTool<>();        tool.setObj(new String("钟福成"));        String s = tool.getObj();        System.out.println(s);        //创建对象并指定元素类型        ObjectTool objectTool = new ObjectTool<>();        /**         * 如果我在这个对象里传入的是String类型的,它在编译时期就通过不了了.         */        objectTool.setObj(10);        int i = objectTool.getObj();        System.out.println(i);    }

3.2泛型方法

前面已经介绍了泛型类了，在类上定义的泛型，在方法中也可以使用…

现在呢，我们可能就仅仅在某一个方法上需要使用泛型…外界仅仅是关心该方法，不关心类其他的属性…这样的话，我们在整个类上定义泛型，未免就有些大题小作了。

  • 定义泛型方法…泛型是先定义后使用的
    //定义泛型方法..    public  void show(T t) {        System.out.println(t);    }
  • 测试代码：

用户传递进来的是什么类型，返回值就是什么类型了

    public static void main(String[] args) {        //创建对象        ObjectTool tool = new ObjectTool();        //调用方法,传入的参数是什么类型,返回值就是什么类型        tool.show("hello");        tool.show(12);        tool.show(12.5);    }

3.3泛型类派生出的子类

前面我们已经定义了泛型类，泛型类是拥有泛型这个特性的类，它本质上还是一个Java类，那么它就可以被继承

那它是怎么被继承的呢？？这里分两种情况

  1. 子类明确泛型类的类型参数变量
  2. 子类不明确泛型类的类型参数变量

3.3.1子类明确泛型类的类型参数变量

  • 泛型接口
/*    把泛型定义在接口上 */public interface Inter<T> {    public abstract void show(T t);}
  • 实现泛型接口的类…
/** * 子类明确泛型类的类型参数变量: */public class InterImpl implements Inter<String> {    @Override    public void show(String s) {        System.out.println(s);    }}

3.3.2子类不明确泛型类的类型参数变量

  • 当子类不明确泛型类的类型参数变量时，外界使用子类的时候，也需要传递类型参数变量进来，在实现类上需要定义出类型参数变量
/** * 子类不明确泛型类的类型参数变量: *      实现类也要定义出类型的 * */public class InterImpl<T> implements Inter<T> {    @Override    public void show(T t) {        System.out.println(t);    }}

测试代码:

    public static void main(String[] args) {        //测试第一种情况        //Inter i = new InterImpl();        //i.show("hello");        //第二种情况测试        Inter ii = new InterImpl<>();        ii.show("100");    }

值得注意的是：

  • 实现类的要是重写父类的方法，返回值的类型是要和父类一样的！
  • 类上声明的泛形只对非静态成员有效

3.4类型通配符

为什么需要类型通配符？？？？我们来看一个需求…

现在有个需求：方法接收一个集合参数，遍历集合并把集合元素打印出来，怎么办？

  • 按照我们没有学习泛型之前，我们可能会这样做：
public void test(List list){    for(int i=0;i<list.size();i++){                System.out.println(list.get(i));        }}

上面的代码是正确的，只不过在编译的时候会出现警告，说没有确定集合元素的类型…这样是不优雅的…

  • 那我们学习了泛型了，现在要怎么做呢？？有的人可能会这样做：
public void test(List<Object> list){    for(int i=0;i<list.size();i++){                System.out.println(list.get(i));        }}

这样做语法是没毛病的，但是这里十分值得注意的是：该test()方法只能遍历装载着Object的集合！！！

强调：泛型中的并不是像以前那样有继承关系的，也就是说List和List是毫无关系的！！！！

那现在咋办？？？我们是不清楚List集合装载的元素是什么类型的，List这样是行不通的…于是Java泛型提供了类型通配符 ?

所以代码应该改成这样：

public void test(List<?> list){    for(int i=0;i<list.size();i++){                System.out.println(list.get(i));        }}

?号通配符表示可以匹配任意类型，任意的Java类都可以匹配…

现在非常值得注意的是，当我们使用?号通配符的时候：就只能调对象与类型无关的方法，不能调用对象与类型有关的方法。

记住，只能调用与对象无关的方法，不能调用对象与类型有关的方法。因为直到外界使用才知道具体的类型是什么。也就是说，在上面的List集合，我是不能使用add()方法的。因为add()方法是把对象丢进集合中，而现在我是不知道对象的类型是什么。

3.4.1设定通配符上限

首先，我们来看一下设定通配符上限用在哪里…

现在，我想接收一个List集合，它只能操作数字类型的元素【Float、Integer、Double、Byte等数字类型都行】，怎么做？？？

我们学习了通配符，但是如果直接使用通配符的话，该集合就不是只能操作数字了。因此我们需要用到设定通配符上限

List<? extends Number>

上面的代码表示的是：List集合装载的元素只能是Number的子类或自身

    public static void main(String[] args) {        //List集合装载的是Integer，可以调用该方法        List integer = new ArrayList<>();        test(integer);        //List集合装载的是String，在编译时期就报错了        List strings = new ArrayList<>();        test(strings);    }    public static void test(List list) {            }

3.4.2设定通配符下限

既然上面我们已经说了如何设定通配符的上限，那么设定通配符的下限也不是陌生的事了。直接来看语法吧

    //传递进来的只能是Type或Type的父类

设定通配符的下限这并不少见，在TreeSet集合中就有…我们来看一下

    public TreeSet(Comparator<? super E> comparator) {        this(new TreeMap<>(comparator));    }

那它有什么用呢？？我们来想一下，当我们想要创建一个TreeSet类型的变量的时候，并传入一个可以比较String大小的Comparator。

那么这个Comparator的选择就有很多了，它可以是Comparator，还可以是类型参数是String的父类，比如说Comparator…

这样做，就非常灵活了。也就是说，只要它能够比较字符串大小，就行了

经评论去补充：在泛型的上限和下限中有一个原则：PECS(Producer Extends Consumer Super)

书上是这样写的：

带有子类限定的可以从泛型读取【也就是—>(? extend T)】-------->Producer Extends
带有超类限定的可以从泛型写入【也就是—>(? super T)】-------->Consumer Super
也有相关博文写得很好：

http://blog.51cto.com/flyingc…
https://blog.csdn.net/xx32666…

3.5通配符和泛型方法

大多时候，我们都可以使用泛型方法来代替通配符的…

    //使用通配符    public static void test(List list) {    }    //使用泛型方法    public  void  test2(List t) {            }

上面这两个方法都是可以的…那么现在问题来了，我们使用通配符还是使用泛型方法呢？？

原则：

  • 如果参数之间的类型有依赖关系，或者返回值是与参数之间有依赖关系的。那么就使用泛型方法
  • 如果没有依赖关系的，就使用通配符，通配符会灵活一些.

3.6泛型擦除

泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为“擦除”。

3.6.1兼容性

JDK5提出了泛型这个概念，但是JDK5以前是没有泛型的。也就是泛型是需要兼容JDK5以下的集合的。

当把带有泛型特性的集合赋值给老版本的集合时候，会把泛型给擦除了。

值得注意的是：它保留的就类型参数的上限。

        List<String> list = new ArrayList<>();        //类型被擦除了，保留的是类型的上限，String的上限就是Object        List list1 = list;

如果我把没有类型参数的集合赋值给带有类型参数的集合赋值，这又会怎么样？？

        List list = new ArrayList();        List<String> list2 = list;

它也不会报错，仅仅是提示“未经检查的转换”

四、泛型的应用

当我们写网页的时候，常常会有多个DAO，我们要写每次都要写好几个DAO，这样会有点麻烦。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LLYKADqE-1635652961204)(JAVA 笔记.assets/162810c81b07499d)]

那么我们想要的效果是什么呢？？只写一个抽象DAO，别的DAO只要继承该抽象DAO，就有对应的方法了。

要实现这样的效果，肯定是要用到泛型的。因为在抽象DAO中，是不可能知道哪一个DAO会继承它自己，所以是不知道其具体的类型的。而泛型就是在创建的时候才指定其具体的类型。

  • 抽象DAO
public abstract class BaseDao<T> {    //模拟hibernate....    private Session session;    private Class clazz;            //哪个子类调的这个方法，得到的class就是子类处理的类型（非常重要）    public BaseDao(){        Class clazz = this.getClass();  //拿到的是子类        ParameterizedType  pt = (ParameterizedType) clazz.getGenericSuperclass();  //BaseDao        clazz = (Class) pt.getActualTypeArguments()[0];        System.out.println(clazz);            }        public void add(T t){        session.save(t);    }        public T find(String id){        return (T) session.get(clazz, id);    }        public void update(T t){        session.update(t);    }        public void delete(String id){        T t = (T) session.get(clazz, id);        session.delete(t);    }    }
  • 继承抽象DAO，该实现类就有对应的增删改查的方法了。

CategoryDao

public class CategoryDao extends BaseDao<Category> {}

BookDao

public class BookDao extends BaseDao<Book> {}

你可能感兴趣的:(笔记,java,java-ee,开发语言)

  • 新网师的精神肤色（幕布笔记） 悦读书香
    王子老师的《极简100小妙招》收到已经几天了，之前大概的浏览了全书，今天起给自己定了一个计划，必须每天学习极简小妙招里面的一个妙招，并加以运用。一、今天要打卡什么内容因有完成每天学习极简小妙招的计划，所以今天晚饭吃的比较简单，草草吃完以后带着小宝到广场溜达一圈，急忙赶回来学习极简小妙招。再重看的时候不知道自己要学点什么，打卡哪一招，感觉哪个都简单，就看这一环节像王子老师说的“一看就会”，但做这一环
  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++） 华为OD题库 华为od链表java
    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
  • 学习JavaEE的日子 Day32 线程池 A 北枝 学习JavaEE学习java-eejava线程池
    Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
  • C++学习笔记（lambda函数） __TAT__ C&C++c++学习笔记
    C++learningnote1、lambda函数的语法2、lambda函数的几种用法1、lambda函数的语法lambda函数的一般语法如下：[capture_clause](parameters)->return_type{function_body}capture_clause：需要捕获的变量，但要求该变量必须在这个作用域中。通常的捕获方式有以下几种：[]：不捕获任何变量[&]：按引用捕获变
  • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？ AaronWang94 shirojavajava安全开发语言
    请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
  • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？ 大龄下岗程序员 mysqljavamysqlspring
    Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
  • 读书笔记《穿越寒冬》 如雪般飞舞
    各位好，我们今天来讲一本书，名字叫作《穿越寒冬》。看起来特别应景，大家觉得现在创业的状况不景气，大家都在忍受着寒冬的煎熬。但实际上，这本书的英文名字并不是这个意思，它的英文名叫作“如何创立一家新公司，并且能够活下来”。我在整个读完了以后，我发现这本书真正要翻译得好，它的名字应该叫作《创业生存手册》。这个书的作者，来自硅谷的霍夫曼船长。霍夫曼船长写过一本让创业者觉得特别贴心的书，叫作《让大象飞》它和
  • 3、JavaWeb-Ajax/Axios-前端工程化-Element 所谓远行Misnearch #JavaWeb前端ajaxelementuijava前端框架
    P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
  • 2018-11-18成长小组学习笔记 实验中学45
    因为嗓子“罢工”，我面对众人只能借“微笑”代言。在开始授课前，绣霞老师先反馈上次作业的情况，提到“接纳”需是真正发自内心的完全接纳，而不是口头上的接纳，内心却是排斥的。提到一个“问题”孩子恰恰对家爱的更加“深沉”，夫妻间的问题不能影响到孩子，对孩子更好的爱不是你为他做的更多，而是给他自由、健康成长的空间。图片发自App一、孩子：家庭的一面镜子夫妻成了彼此的“投射”，婚姻便“吵的不可开交”，婚姻便成
  • 【鸿蒙HarmonyOS开发笔记】ArkUI常用组件介绍汇总（更新中） 温、 鸿蒙HarmonyOS开发笔记学习记录harmonyos笔记华为
    概述此文总结开发中用到的一些常用组件，便于查阅，此文持续更新，闲的没事就更线性布局（Row/Column）不多介绍了，最常用的布局组件，两者除了方向不一样，别的都一样方便起见下面只写Column常用属性排列方向上的间距：spaceColumn({space:20}){Row().width('90%').height(50).backgroundColor(0xF5DEB3)Row().width
  • 安卓笔记本 - Handler Message MessageQueue Looper SocialException
    不爱写字，一张图解决。Handler,Message,MessageQueue,Looper工作原理
  • 枚举使用笔记 万变不离其宗_8 项目笔记笔记
    1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
  • ruoyi使用笔记 万变不离其宗_8 项目笔记代码参考笔记笔记java前端
    1.限流处理@RateLimiter@PostMapping("/createOrder")@ApiOperation("创建充值订单")@RateLimiter(key=CacheConstants.REPEAT_SUBMIT_KEY,time=10,count=1,limitType=LimitType.IP)publicRcreateOrder(@RequestBodyFormform){/
  • 数据管理知识体系指南（第二版）-第五章——数据建模和设计-学习笔记 键盘上的五花肉 数据治理数据库数据仓库数据治理
    目录5.1引言5.1.1业务驱动因素5.1.2目标和原则5.1.3基本概念5.2活动5.2.1规划数据建模5.2.2建立数据模型5.2.3审核数据模型5.2.4维护数据模型5.3工具5.3.1数据建模工具5.3.2数据血缘工具5.3.3数据分析工具5.3.4元数据资料库5.3.5数据模型模式5.3.6行业数据模型5.4方法5.4.1命名约定的最佳实践5.4.2数据库设计中的最佳实践5.5数据建模和
  • Python dict字符串转json对象，小数精度丢失问题 朝如青丝 暮成雪 jsonpython
    一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
  • java实体中返回前端的double类型四舍五入（格式化） 婲落ヽ紅顏誶 java
    根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
  • Java中HashMap底层数据结构及主要参数? 山间漫步人生路 java数据结构开发语言
    在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
  • Java学习笔记01 .wsy. 日常java学习笔记
    1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
  • Java回溯知识点（含面试大厂题和源码） 一成码农 java面试开发语言
    回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
  • 《老子》笔记19 2018-10-28 海上明月共
    第二十二章[原文]曲则全，枉则直，洼则盈，敝则新，少则得，多则惑。是以圣人抱一为天下式。不自见，故明；不自是，故彰，不自伐，故有功；不自矜，故长。夫唯不争，故天下莫能与之争。古之所谓"曲则全"者，岂虚言哉？诚全而归之。[译文]委曲便会保全，屈枉便会直伸；低洼便会充盈，陈旧便会更新；少取便会获得，贪多便会迷惑。所以有道的人坚守这一原则作为天下事理的范式，不自我表扬，反能显明；不自以为是，反能是非彰明
  • Azkaban各种类型的Job编写 __元昊__
    一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
  • java基础相关面试题详细总结 。。。。。96 java开发语言
    1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
  • 以客户为中心的企业设计（咨询执业笔记） 觉者看世界
    以客户为中心的企业设计（咨询执业笔记）——何伏全案咨询知名专家数字经济大行其道，过剩的风险资本自由流动，股权市场日益强势，这些力量综合在一起，产生出诸多不合理的企业设计。这些事实使得企业设计的再创造越来越需要一种约束力，许多公司和投资者未能熟谙这种约束力，或者未能将其基本原理运用于具体的商业行为中，因此付出了沉重的代价。无利润区的确存在，并且已在全球蔓延，有愈演愈烈之势。它席卷了数以千计的公司，涉
  • javascript 日期转换为时间戳，时间戳转换为日期的函数 cdcdhj javascript学习日记javascript开发语言ecmascript
    日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-
  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法 杰哥在此 Java系列javajvm算法面试
    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
  • 【Git安装及使用学习笔记】 可可西里啊 零零散散的学习笔记git学习笔记c++qt5
    Git学习笔记Git安装Git创建本地版本库以及提交文件使用Git提交代码到码云使用Git从码云拉取代码参考博客Git安装这里参考Git详细安装教程（详解Git安装过程的每一个步骤）Git创建本地版本库以及提交文件1.查看git版本信息：git--version2.设置对应用户名与邮箱地址gitconfig--globaluser.name"your_usernamegitconfig--glob
  • COMP315 JavaScript Cloud Computing for E Commerce zhuyu0206girl javascript开发语言ecmascript
    Assignment1:Javascript1IntroductionAcommontaskincloudcomputingisdatacleaning,whichistheprocessoftakinganinitialdatasetthatmaycontainerroneousorincompletedata,andremovingorfixingthoseelementsbeforeform
  • JSON与AJAX：网页交互的利器 入冉心 jsonajax前端
    在现代Web开发中，JSON（JavaScriptObjectNotation）和AJAX（AsynchronousJavaScriptandXML）是两项不可或缺的技术。它们共同为网页提供了动态、实时的数据交互能力，为用户带来了更加流畅和丰富的体验。本文将详细介绍JSON和AJAX的概念、原理，并通过代码示例展示它们在实际开发中的应用。一、JSON：轻量级的数据交换格式JSON是一种轻量级的数据
  • 程序员开发技术整理 laizhixue 学习前端框架
    前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
  • 读书笔记|《穆斯林的葬礼》 飞舞的微辰
    她从来也没有打算对过去的恩怨进行报偿或是惩罚，只是想把该记住的都记住，该忘却的都忘却。事业的追求，并不一定要什么头衔和称号来满足，你爱上了一种东西，愿意用全部心血去研究它，掌握它，从中得到乐趣，并且永远也不舍得丢其它，这是事业心，是比什么都重要的......人生在世，谁也管不了谁；生儿育女，不是为了父母，是为了儿女自己，各人的路，让他们自己去闯吧。七尺之躯，一抔黄土，穆斯林们一个个都离去了，什么都
  • 安装数据库首次应用 Array_06 javaoraclesql
    可是为什么再一次失败之后就变成直接跳过那个要求 enter full pathname of java.exe的界面 这个java.exe是你的Oracle 11g安装目录中例如：【F:\app\chen\product\11.2.0\dbhome_1\jdk\jre\bin】下的java.exe 。不是你的电脑安装的java jdk下的java.exe！ 注意第一次，使用SQL D
  • Weblogic Server Console密码修改和遗忘解决方法 bijian1013 Welogic
            在工作中一同事将Weblogic的console的密码忘记了，通过网上查询资料解决，实践整理了一下。 一.修改Console密码         打开weblogic控制台，安全领域 --> myrealm -->&n
  • IllegalStateException: Cannot forward a response that is already committed Cwind javaServlets
    对于初学者来说，一个常见的误解是：当调用 forward() 或者 sendRedirect() 时控制流将会自动跳出原函数。标题所示错误通常是基于此误解而引起的。 示例代码： protected void doPost() { if (someCondition) { sendRedirect(); } forward(); // Thi
  • 基于流的装饰设计模式 木zi_鸣 设计模式
    当想要对已有类的对象进行功能增强时，可以定义一个类，将已有对象传入，基于已有的功能，并提供加强功能。 自定义的类成为装饰类 模仿BufferedReader，对Reader进行包装，体现装饰设计模式 装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰的对象功能，提供更强的功能。 装饰模式比继承灵活，避免继承臃肿，降低了类与类之间的关系 装饰类因为增强已有对象，具备的功能该
  • Linux中的uniq命令 被触发 linux
    Linux命令uniq的作用是过滤重复部分显示文件内容，这个命令读取输入文件，并比较相邻的行。在正常情 况下，第二个及以后更多个重复行将被删去，行比较是根据所用字符集的排序序列进行的。该命令加工后的结果写到输出文件中。输入文件和输出文件必须不同。如 果输入文件用“- ”表示，则从标准输入读取。 AD： uniq [选项] 文件 说明：这个命令读取输入文件，并比较相邻的行。在正常情况下，第二个
  • 正则表达式Pattern 肆无忌惮_ Pattern
    正则表达式是符合一定规则的表达式，用来专门操作字符串，对字符创进行匹配，切割，替换，获取。   例如，我们需要对QQ号码格式进行检验 规则是长度6~12位  不能0开头  只能是数字，我们可以一位一位进行比较，利用parseLong进行判断，或者是用正则表达式来匹配[1-9][0-9]{4,14} 或者 [1-9]\d{4,14} &nbs
  • Oracle高级查询之OVER (PARTITION BY ..) 知了ing oraclesql
    一、rank()/dense_rank() over(partition by ...order by ...) 现在客户有这样一个需求，查询每个部门工资最高的雇员的信息，相信有一定oracle应用知识的同学都能写出下面的SQL语句： select e.ename, e.job, e.sal, e.deptno from scott.emp e, (se
  • Python调试 矮蛋蛋 pythonpdb
    原文地址： http://blog.csdn.net/xuyuefei1988/article/details/19399137 1、下面网上收罗的资料初学者应该够用了，但对比IBM的Python 代码调试技巧： IBM：包括 pdb 模块、利用 PyDev 和 Eclipse 集成进行调试、PyCharm 以及 Debug 日志进行调试： http://www.ibm.com/d
  • webservice传递自定义对象时函数为空，以及boolean不对应的问题 alleni123 webservice
    今天在客户端调用方法 NodeStatus status=iservice.getNodeStatus(). 结果NodeStatus的属性都是null。 进行debug之后，发现服务器端返回的确实是有值的对象。 后来发现原来是因为在客户端，NodeStatus的setter全部被我删除了。 本来是因为逻辑上不需要在客户端使用setter， 结果改了之后竟然不能获取带属性值的
  • java如何干掉指针，又如何巧妙的通过引用来操作指针————>说的就是java指针 百合不是茶
    C语言的强大在于可以直接操作指针的地址，通过改变指针的地址指向来达到更改地址的目的,又是由于c语言的指针过于强大，初学者很难掌握， java的出现解决了c，c++中指针的问题 java将指针封装在底层，开发人员是不能够去操作指针的地址，但是可以通过引用来间接的操作：   定义一个指针p来指向a的地址（&是地址符号）：        
  • Eclipse打不开，提示“An error has occurred.See the log file ***/.log” bijian1013 eclipse
    打开eclipse工作目录的\.metadata\.log文件，发现如下错误： !ENTRY org.eclipse.osgi 4 0 2012-09-10 09:28:57.139 !MESSAGE Application error !STACK 1 java.lang.NoClassDefFoundError: org/eclipse/core/resources/IContai
  • spring aop实例annotation方法实现 bijian1013 javaspringAOPannotation
            在spring aop实例中我们通过配置xml文件来实现AOP，这里学习使用annotation来实现，使用annotation其实就是指明具体的aspect,pointcut和advice。1.申明一个切面(用一个类来实现)在这个切面里,包括了advice和pointcut AdviceMethods.jav
  • [Velocity一]Velocity语法基础入门 bit1129 velocity
    用户和开发人员参考文档 http://velocity.apache.org/engine/releases/velocity-1.7/developer-guide.html   注释 1.行级注释## 2.多行注释#*  *#   变量定义 使用$开头的字符串是变量定义，例如$var1, $var2,   赋值 使用#set为变量赋值，例
  • 【Kafka十一】关于Kafka的副本管理 bit1129 kafka
    1. 关于request.required.acks   request.required.acks控制者Producer写请求的什么时候可以确认写成功，默认是0， 0表示即不进行确认即返回。 1表示Leader写成功即返回，此时还没有进行写数据同步到其它Follower Partition中 -1表示根据指定的最少Partition确认后才返回，这个在   Th
  • lua统计nginx内部变量数据 ronin47 lua nginx　 统计
    server { listen 80; server_name photo.domain.com; location /{set $str $uri; content_by_lua ' local url = ngx.var.uri local res = ngx.location.capture(
  • java-11.二叉树中节点的最大距离 bylijinnan java
    import java.util.ArrayList; import java.util.List; public class MaxLenInBinTree { /* a. 1 / \ 2 3 / \ / \ 4 5 6 7 max=4 pass "root"
  • Netty源码学习-ReadTimeoutHandler bylijinnan javanetty
    ReadTimeoutHandler的实现思路： 开启一个定时任务，如果在指定时间内没有接收到消息，则抛出ReadTimeoutException 这个异常的捕获，在开发中，交给跟在ReadTimeoutHandler后面的ChannelHandler，例如 private final ChannelHandler timeoutHandler = new ReadTim
  • jquery验证上传文件样式及大小(好用) cngolon 文件上传jquery验证
    <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <script src="jquery1.8/jquery-1.8.0.
  • 浏览器兼容【转】 cuishikuan css浏览器IE
    浏览器兼容问题一：不同浏览器的标签默认的外补丁和内补丁不同 问题症状：随便写几个标签，不加样式控制的情况下，各自的margin 和padding差异较大。 碰到频率:100% 解决方案：CSS里    *{margin:0;padding:0;} 备注：这个是最常见的也是最易解决的一个浏览器兼容性问题，几乎所有的CSS文件开头都会用通配符*来设
  • Shell特殊变量：Shell $0, $#, $*, $@, $?, $$和命令行参数 daizj shell$#$?特殊变量
    前面已经讲到，变量名只能包含数字、字母和下划线，因为某些包含其他字符的变量有特殊含义，这样的变量被称为特殊变量。例如，$ 表示当前Shell进程的ID，即pid，看下面的代码： $echo $$ 运行结果 29949   特殊变量列表 变量 含义 $0 当前脚本的文件名 $n 传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个
  • 程序设计KISS 原则-------KEEP IT SIMPLE, STUPID! dcj3sjt126com unix
    翻到一本书，讲到编程一般原则是kiss：Keep It Simple, Stupid.对这个原则深有体会，其实不仅编程如此，而且系统架构也是如此。 KEEP IT SIMPLE, STUPID! 编写只做一件事情，并且要做好的程序；编写可以在一起工作的程序，编写处理文本流的程序，因为这是通用的接口。这就是UNIX哲学.所有的哲学真 正的浓缩为一个铁一样的定律，高明的工程师的神圣的“KISS 原
  • android Activity间List传值 dcj3sjt126com Activity
    第一个Activity： import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import a
  • tomcat 设置java虚拟机内存 eksliang tomcat 内存设置
    转载请出自出处：http://eksliang.iteye.com/blog/2117772 http://eksliang.iteye.com/ 常见的内存溢出有以下两种: java.lang.OutOfMemoryError: PermGen space java.lang.OutOfMemoryError: Java heap space   ------------
  • Android 数据库事务处理 gqdy365 android
    使用SQLiteDatabase的beginTransaction()方法可以开启一个事务，程序执行到endTransaction() 方法时会检查事务的标志是否为成功，如果程序执行到endTransaction()之前调用了setTransactionSuccessful() 方法设置事务的标志为成功则提交事务，如果没有调用setTransactionSuccessful() 方法则回滚事务。事
  • Java 打开浏览器 hw1287789687 打开网址open浏览器open browser打开url打开浏览器
    使用java 语言如何打开浏览器呢? 我们先研究下在cmd窗口中,如何打开网址 使用IE 打开 D:\software\bin>cmd /c start iexplore http://hw1287789687.iteye.com/blog/2153709 使用火狐打开 D:\software\bin>cmd /c start firefox http://hw1287789
  • ReplaceGoogleCDN：将 Google CDN 替换为国内的 Chrome 插件 justjavac chromeGooglegoogle apichrome插件
    Chrome Web Store 安装地址： https://chrome.google.com/webstore/detail/replace-google-cdn/kpampjmfiopfpkkepbllemkibefkiice 由于众所周知的原因，只需替换一个域名就可以继续使用Google提供的前端公共库了。 同样，通过script标记引用这些资源，让网站访问速度瞬间提速吧
  • 进程VS.线程 m635674608 线程
    资料来源： http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001397567993007df355a3394da48f0bf14960f0c78753f000 1、Apache最早就是采用多进程模式 2、IIS服务器默认采用多线程模式 3、多进程优缺点 优点： 多进程模式最大
  • Linux下安装MemCached 字符串 memcached
    前提准备：1. MemCached目前最新版本为：1.4.22，可以从官网下载到。2. MemCached依赖libevent，因此在安装MemCached之前需要先安装libevent。2.1 运行下面命令，查看系统是否已安装libevent。[root@SecurityCheck ~]# rpm -qa|grep libevent libevent-headers-1.4.13-4.el6.n
  • java设计模式之--jdk动态代理（实现aop编程） Supanccy2013 javaDAO设计模式AOP
        与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 &
  • Spring 4.2新特性-对java8默认方法(default method)定义Bean的支持 wiselyman spring 4
    2.1 默认方法(default method) java8引入了一个default medthod; 用来扩展已有的接口,在对已有接口的使用不产生任何影响的情况下,添加扩展 使用default关键字 Spring 4.2支持加载在默认方法里声明的bean 2.2 将要被声明成bean的类 public class DemoService {