大羊的一天

Java学习笔记基础知识(一)

发表于 更新于
Java基础知识回顾

微信图片_20200507150905

https://www.bilibili.com/video/BV1jt411H71h

image-20200507155244272

image-20200507155341754

三大平台：JavaSE 标准版、JavaME、JavaEE 企业版 enterprise edition 框架spring boot，spring cloud，

image-20200507194116508 image-20200507162925346 image-20200507162954698 image-20200507163217819 image-20200507163403708

https://www.bilibili.com/video/BV1U4411M71p

image-20200507162759966

image-20200512115507838

基础知识

一、语言本身

  • 语法基础
  • OO编程思想：类、对象、封装、继承、多态、接口
  • 容器
  • 异常
  • 泛型
  • I/O
  • 注解
  • 反射
  • 图形化界面，如 swing的东西跳过不看

语法基础

dos命令

image-20200507192226722
  • 大小写敏感；
  • 类名的每个单词首字母应该大写 ；
  • 所有的方法名都应该以小写字母开头 如果方法名含有若干单词，则后面的每个单词首字母大写。
  • 源文件名必须和类名相同 ，xxx.java

变量

存储在内存；变量作用域：一对{}内有效；与c不同 要初始化；

数据类型

​ 基本数据类型：数值型：整数型：byte 1字节（-128 127） short 2 int 4 long 8字节 long m =8l

​ 浮点数：float 4字节 float a=1.1f 7位有效数字 double 8字节 16位有效数字

​ 字符型：chart 根据unicode进行运算 ;单引号’’

​ 引用数据类型：类 class string 字符串常量=“ hello world”

​ 接口 interface

​ 数组[]

​ Lambda

​

​ 引用都可以用null 初始化。

int a =1 int b =1 内存有两个1

string a= “hello” string b=”hello” 内存的字符串常量池内只有一个hello

数据类型转换

image-20200507203434603

image-20200521213751659

  • image-20200521213816756
  • 多种类型的数据混合运算，先自动把数据转换成容量最大的数据类型再运算
  • string类型 的+运算时，+前按数学运算，+后安字符串拼接；例如 System.out.println(‘a’+1+”abc”+1+2) ->>88abc12
  • 强制类型转换的逆转换，可能造成精度降低或者溢出；
  • 通常字符串不转换为基础类型，但通过基本类型对应的包装类可实现，如：string a =“43”，int i =Integer.parseInt(a)
  • boolean不可强制转换为其他数据类型

boolean 不能o和非0替代true false 无null

  • 局部变量

    在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

  • 类变量（静态变量）

    ​ 类变量也声明在类中，方法体之外，但必须声明为static类型。

  • 成员变量（非静态变量）

    ​ 成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

标示符：

  • az AZ 0~9 _ $
  • 数字不开头
  • 不可只用关键字和保留字
  • 严格区分大小写
  • 不能包含空格

关键字：

​ image-20200521213535980

关键字都小写
class byte short
int long float double char
boolean void abstract extends final修饰常量
implements native new static strictfp
true null
if else switch case default
while do for break continue
return instanceof
private protected public default
import package
super whis void
const

运算符

  • 5%-2 =1 -5%2=-1

  • ‘星号’+’\t’+’星号’ ==93，”*”+’\t’+’星号’ ==星 星 

1
2


逻辑运算符

与 &
或 |
非 ！
逻辑异或 ^
短路与 && \1. 两边都是true，结果是true \2. 一边是false，结果是false 短路特点：符号左边是false，右边不再运算
短路或 || \1. 两边都是false，结果是false \2. 一边是true，结果是true 短路特点： 符号左边是true，右边不再运算

位运算符

image-20200507210834302

三元运算符

(结果为布尔类型的语句)?表达式1:表达式2

image-20200507211158522

if-else、switch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
if(true){
	执行语句;
}

if(true){
	执行语句1;
}
else if{
	执行语句2;
}
else{
	执行语句3
}


switch(变量){
    case 常量1:
        语句1;
        break;
    case 常量2:
        语句2;
        break;
    //。。。。。
    default:
        语句3;
        break;       
}

/* 
case后面只能跟常量,不能跟变量
default可以在switch语句的任何位置.switch语句遇见break结束,或者程序默认执行到末尾结束.
case的穿透性
在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运 行，直到遇到break，或者整体switch结束。
*/

循环语句 for、 while、 do/while 嵌套；

1
2
3
4
5
6
7
8
9
10
11
12
for(int i =1;i<100;i++){
	System.out.printIn(i);
	}
int i =100;
while(i<100){
    语句1;
}

int m =1;
do{
   	语句1;
}while(m<100);
for 和 while 的小区别：
  • 控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继

续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消

失，能够提高内存的使用效率。

  • 在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while

break可以终止当前循环;

continue 跳出当前循环继续进入下一个循环;

1
2
3
4
5
6
for(int i =1;i<100;i++){
	if(i%2==0){
        continue;
        System,out.printIn(i);
    }
}

return 可结束方法或过程；其后代码失效；

1
2
3
4
5
6
7
8
for(int i =0;i<2;i++){
	for(int j =0;j<2;j++){
		return;//直接跳出整个方法；print不执行
		break;//跳出当前循环，执行print
	};
	System,out.printIn(i);
	
}

递归

Final修饰变量方法和类

  • image-20200512155740830

数组

  • 引用数据格式
  • 数据类型唯一
  • 长度在运行期间不可更改
初始化

动态初始化（指定长度）

​ int[]arrayA= new int[100];

​ double[]arrayB= new double[300];

​ String[]arrayString= new String[5]

​ double[]arrayB；

​ arrayB= new double[300];

image-20200512160249033

静态初始化（指定内容）

​ int[]arrayA= new int[]{1,2,3}; //推算数组长度

​ 先声明再初始化

​ int[]arrayA；

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

省略型静态初始化

​ int[]arrayA= {1,2,3};

​ 不能拆能两步骤

image-20200512155952232

反转数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.awt.desktop.SystemSleepEvent;

public class Method_Demo1 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3,4,5};
   
        for(int min=0, max=arr.length-1;min<max;min++,max--){
            int x=arr[min];
           arr[min]=arr[max];
           arr[max]=x;
            
        }
        for(int i =0;i<=arr.length-1;i++){
        System.out.println(arr[i]);
         }
    }
}
  • 数组作为方法参数传递，传递的参数是数组内存的地址。
  • 数组作为方法的返回值，返回的是数组的内存地址

image-20200508154026781

增强型for循环（用于遍历）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class HelloWorld {
    public static void main(String[] args) {
        int values [] = new int[]{18,62,68,82,65,9};
        //常规遍历
        for (int i = 0; i < values.length; i++) {
            int each = values[i];
            System.out.println(each);
        }     
        //增强型for循环遍历
        for (int each : values) {
            System.out.println(each);
        }        
    }
}
/*增强型for循环只能取值，不能修改数组值  */

//用增强型for循环找出最大的那个数
public class HelloWorld {
    public static void main(String[] args) {
        int values [] = new int[]{18,62,68,82,65,9}; 
        int max = -1;
        for (int each : values) {
            if(each>max)
                max = each;
        }         
        System.out.println("最大的一个值是:"+max);       
    }
}

  • 排序：java.util.Arrays.sort(数组名称)

  • 数组拷贝：System.arraycopy(源数组，源数组开始点a，目标数组，目标数组开始点b，拷贝长度)

    • arr1:[1,2,3,4,5,6,7,8,9]

    • arr2: [11,22,33,44,55,66,77,88,99]

    • ->>System.arraycopy(arr1,3,arr2,3,4)->>[11,22,33,4,5,6,7,88,99]

    • for(int i =0;i<拷贝长度;i++){

      ​ 目标数组[b++]=源数组[a++];

      }

2面向对象

2.1枚举类型

1
2
3
4
5
6
7
8
9
10
11
public enum Season{
    SPRING,SUMMER,AUTUMN,WINTER;
}

public class a{
    public static void main(String [] args){
	for(Season value:Season.values()){
        System.out.println(value);
    }
    }
}

2.2对象

2.2.1成员变量的默认值
数据类型 默认值
整数：int byte short long 0
浮点数：float double 0.0
字符型：char ‘\u0000’
boolean false
数组、类、接口 null
2.2.2 成员变量的初始化

  • 声明该属性的时候初始化

  • 构造方法中初始化

  • 初始化块

    分步的话，必须有代码块；==代码快前若有static 报错==？

  • ==静态方法和初始化块看顺序，但运行时都优先于构造方法==。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class classChuShiHua {
    public String name = "some hero";				 //声明该属性的时候初始化
    protected float hp;
    float maxHP;									//为初始化，则为默认值  
    {
        maxHP=(float)1.1;							//分步的话，必须有代码块
    }												//代码快前若有static 报错  
    public classChuShiHua(){
    	hp=100;										//构造方法中初始化
    } 
    public static void main(String[] args) {
        classChuShiHua a=new classChuShiHua();
        System.out.println(a.maxHP);
    }
}
------------------------------------------------------------------------------------
对象属性的初始化有三种方式顺序讨论
    
public class Hero {
    public String name =Hero.getName("静态方法") ;     
    public Hero(){
        name = Hero.getName("构造方法");
    }
    {
        name =getName("初始化块");  //每新建一个对象初始化块都执行一次；
    }    
    public static String getName(String pos){
        System.out.println("name "+pos);
        return result;
    }     
    public static void main(String[] args) {
        new Hero();
    }   
}
   name 静态方法
   name 初始化块
   name 构造方法
2.2.2.1 类成员的初始化

  • 声明该属性的时候初始化

  • 静态初始化块 只执行一次。用于静态属性初始化；

    先执行父类初始化块 在执行子类初始化块；块内不能调用普通成员变量，因为没有对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class classChuShiHua {

    public String name;
    protected float hp;
    float maxHP;
    //物品栏的容量
    public static int itemCapacity=8; //声明的时候 初始化
    static{
        itemCapacity = 6;//静态初始化块 初始化  去掉static，则结果为8
    }

    public classChuShiHua(){
    }
    public static void main(String[] args) {
        System.out.println(classChuShiHua.itemCapacity);
    }
}
2.2.1.2局部变量与成员变量的区别

  • 定义的位置不同。

    ​ (1)成员变量定义在类中。
    ​ (2)局部变量定义在方法中。

  • 内存位置不同；

    ​ (1)成员变量存储在堆内存的对象中。

    ​ (2)局部变量存储在栈内存的方法中。

  • 类中作用范围、生命周期不同

    ​ (1)成员变量随着对象的出现而出现，随着对象的消失而消失。

    ​ (2)局部变量是随着方法的运行而出现，随着方法的弹栈而消失。

  • 初始化不同

    ​ (1)成员变量因为在堆内存中，所以有默认的初始化值。

    ​ (2)局部变量没有默认初始化值，必须初始化后才可以使用。

方法调用的三种形式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void main(String[] args) { 
    print(); //直接写方法名调用
    nt sum = getSum(5,6);//赋值调用
    System.out.println(getSum(5,6)); //输出语句调用：
}
public static void print() { 
    System.out.println("方法被调用");
}
public static int getSum(int a,int b) { return a + b; }

//不能用输出语句调用 void 类型的方法 
public static void main(String[] args) { 
    System.out.println(printHello());// 错误，不能输出语句调用void类型方法 
}public static void printHello() {
    System.out.println("Hello"); 
}
3、内存划分

  • 栈

    特点：区域很小 , 大概2M左右 , 特点是存取的速度特别快（==通过 ‘栈指针’ 来创建空间与释放空间 !指针向下移动, 会创建新的内存, 向上移动, 会释放这些内存 !这种方式速度特别快 , 仅次于PC寄存器 !==）；每个线程启动时, 都会创建一个栈。

    ​ 先进后出；

    储存内容：局部变量， 基本数据类型的数据以及引用数据类型的引用。

  • 堆

    特点：堆内存里面的数据,都有默认值,规则:

    数据类型 默认值
    整数：int byte short long 0
    浮点数：float double 0.0
    字符型：char ‘\u0000’
    boolean false
    数组、类、接口 null

储存内容：

  • 存放的是类的对象（对象地址值都为16进制）；

  • 方法区

    储存内容：

    • 类信息
    • 静态的变量
    • 常量
    • 成员方法
    • 常量池（存储的是使用static修饰的成员）

  • PC寄存器

    当前正在执行的 JVM指令的地址；每个线程启动时, 都会创建一个PC寄存器。

  • 本地方法栈

    保存本地(native)方法的地址。

4、构造方法

​ 建议自定义无参构造方法；

​ 当类中有非常量成员变量时，建议提供两个构造方法，一个是无参构造方法，一个是全属性做参数的构造方法。

​ 当类中所有成员变量都是常量或者没有成员变量时，建议不提供任何版本的构造。

​ (其余略)

5、匿名对象

​ 匿名对象只能使用一次，没有对象引用，结束后等待被垃圾回收器回收。

2.3 单例对象

总共七种：

一、饿汉模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package charactor;
public class GiantDragon {
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){        
    }
    //准备一个类属性，指向一个实例化对象。 因为是类属性，所以只有一个？？？？？？
    private static GiantDragon instance = new GiantDragon();   
    //public static 方法，提供给调用者获取定义的对象
    public static GiantDragon getInstance(){
        return instance;
    }     
}
package charactor;
public class TestGiantDragon {
    public static void main(String[] args) {
        //通过new实例化会报错
//      GiantDragon g = new GiantDragon();
        //只能通过getInstance得到对象
        GiantDragon g1 = GiantDragon.getInstance();
        GiantDragon g2 = GiantDragon.getInstance();
        GiantDragon g3 = GiantDragon.getInstance();  
        //都是同一个对象
        System.out.println(g1==g2);
        System.out.println(g1==g3);
    }

二、懒汉模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//懒汉式单例模式与饿汉式单例模式不同，只有在调用getInstance的时候，才会创建实例
public class GiantDragon { 
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){       
    }
    //准备一个类属性，用于指向一个实例化对象，但是暂时指向null
    private static GiantDragon instance;      
    //public static 方法，返回实例对象
    public static GiantDragon getInstance(){
        //第一次访问的时候，发现instance没有指向任何对象，这时实例化一个对象
        if(null==instance){
            instance = new GiantDragon();
        }
        //返回 instance指向的对象
        return instance;
    }      
}
//------------------------------------------------------------------------------
public class TestGiantDragon { 
    public static void main(String[] args) {
        //通过new实例化会报错
//      GiantDragon g = new GiantDragon();        
        //只能通过getInstance得到对象     
        GiantDragon g1 = GiantDragon.getInstance();
        GiantDragon g2 = GiantDragon.getInstance();
        GiantDragon g3 = GiantDragon.getInstance();       
        //都是同一个对象
        System.out.println(g1==g2);
        System.out.println(g1==g3);
    }
}

比较

  • 饿汉式是立即加载的方式，无论是否会用到这个对象，都会加载。
    如果在构造方法里写了性能消耗较大，占时较久的代码，比如建立与数据库的连接，那么就会在启动的时候感觉稍微有些卡顿。
  • 懒汉式，是延迟加载的方式，只有使用的时候才会加载。 并且有线程安全的考量(鉴于同学们学习的进度，暂时不对线程的章节做展开)。
    使用懒汉式，在启动的时候，会感觉到比饿汉式略快，因为并没有做对象的实例化。 但是在第一次调用的时候，会进行实例化操作，感觉上就略慢。

2.4 面向对象的三大特征

2.4.1封装

  • private；getXxx; setXxx;

  • boolean: setBool; isBool;

    2.4.1.1private 注意事项
    2.4.1.2this的用法

  • 调用类中的属性

  • 调用类中的方法或构造方法

  • 表示当前对象（锁中有体现）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/*访问成员
this.成员变量 ‐‐ 本类的 
super.成员变量 ‐‐ 父类的 
this.成员方法名() ‐‐ 本类的 
super.成员方法名() ‐‐ 父类的*/
//-----------------------------------------------------------------------
/*访问构造方法
this(...) ‐‐ 本类的构造方法 
super(...) ‐‐ 父类的构造方法
子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。
*/


package demo1;

public class Hero {
        String name; //姓名
        float hp; //血量
        float armor; //护甲
        int moveSpeed; //移动速度
        //带一个参数的构造方法
        public Hero(String name){
            System.out.println("一个参数的构造方法");
            this.name = name;
        }

        //带两个参数的构造方法
        public Hero(String name,float hp){
            this(name);
            System.out.println("两个参数的构造方法");
            this.hp = hp;
        }
    public Hero(String name,float hp,int V){
        this(name,hp);
        System.out.println("3个参数的构造方法");
        moveSpeed = V;
    }
        public static void main(String[] args) {
            Hero teemo =  new Hero("提莫",383,2);

            System.out.println(teemo.name+teemo.hp+teemo.moveSpeed);
        }
    }
static的用法

  • 修饰成员变量

    在类加载时加载并初始化；==存在于方法区中==；

  • 成员方法

    • static方法只能调用static属性和static方法；非static方法允许调用static属性和static方法；

  • 静态代码块（见代码快）

  • 静态内部类

权限修饰符

修饰符 private default protected public
同一类中 √ √ √ √
同一包中(子类与无关类) √ √ √
不同包的子类 √ √
不同包中的无关类 √
2.4.2 继承
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class 父类{
...
}
class 子类 extends 父类 {
	...
}
//成员变量
//子类的方法可以用父类的非私有变量；若重名，super.父类变量,this.子类变量
//父类中的私有变量若进行访问，照样getXxx,setXxx;

//成员方法
//不重名，调用时现在子类找，若无再在父类找
//重名(返回类型、方法名、参数列表相同)->>方法重写->>只执行重写后的方法
//子类方法覆盖父类方法，必须要保证权限大于等于父类权限。

  • 子类可以==直接==访问父类中的==非私有==的属性和行为。通过get set方法访问私有成员。

  • 成员变量重名

    • 重名且没有super this关键字修饰时，成员变量就近原则；
    • 子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰
      父类成员变量

  • 成员方法重名——重写(Override)

    • 重写是对父类方法对扩展
    • 重写的规则
      • 参数列表必须与被重写方法相同；
      • 返回类型必须与被重写方法的返回类型相同；
      • 访问权限不得低于父类被重写方法；
      • 只能被子类重写
      • 被final修饰的方法，不能被重写（但其所在的类可以有子类，不过final方法不能被重写。
      • 声明static和private的方法不能被重写，但能够被再次声明。
      • 子类方法的返回值必须【小于等于】父类方法的返回值范围。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class Phone {
    	public void showNum(){     
    	System.out.println("来电显示号码");         
    	}
    }
    class NewPhone extends Phone {
    	public void showNum(){     
    	//用到super.父类成员方法，表示在父类的成员方法基础上完善。  		 额外注意次用法！！！       
    	super.showNum();         
    	//增加自己特有显示姓名和图片功能         
    	System.out.println("显示来电姓名");         
    	System.out.println("显示头像");         
    }

  • 构造方法

    • 子类是无法继承父类构造方法的。因为构造方法需要与类名一致。

      子类的构造函数一定会先执行父类中的构造函数；

    • 子类的构造方法中默认有一个 super()，调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

  • 父类空间优先于子类对象产生

  • super和this

    ​ 如果父类没有无参构造，则子类有super（）的地方会报错。；

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    this.成员变量     ‐‐    本类的    
    super.成员变量     ‐‐    父类的   
       
    this.成员方法名()   ‐‐    本类的       
    super.成员方法名()   ‐‐    父类的
          
    this(...)     ‐‐    本类的构造方法    
    super(...)    ‐‐    父类的构造方法
     class Fu {
        private int n;
        Fu(){
        System.out.println("Fu()");
      }
    }
    public class Zi extends Fu{
        String sex;
        Zi(){
            super();						//还可以利用super(...)调用父类构造重载的方法；
            System.out.println("ziwucan");
        };
        Zi(String sex){
            this();							//调用上面的无参构造Zi(){...}
        }
        public static void main(String[] args) {
            Zi z=new Zi("m");
        }
    }

    //super() 和 this() 都必须是在<构造方法>的第一行，所以不能同时出现。
final关键字的使用

  • 类（太监类）：被修饰的类，不能被继承。

  • 方法：被修饰的方法，不能被重写。但该方法所属的类可有子类；

  • 变量

    • 基本类型的局部变量：被修饰的变量，只能赋值一次，不能被重新赋值。

    • 引用类型的局部变量：被final修饰后，只能指向一个对象，地址不能再更改。但是，对象中的属性可以改变。

    • 成员变量，

      • 一旦使用final关键字，一样不能改。

      • 和局部变量的不同点在于：成员变量有默认值，因此必须手动赋值。

      • 如果没有直接赋值，那就必须保证所有重载的构造方法最终都会对final的成员变量进行了赋值。

      • 赋值（初始化）方式有两种，只能二选一：

        1、显示初始化；

      1
      2
      3
      4
      public class User {
          final String USERNAME = "张三";
          private int age;
      }

      ​ 2、构造方法初始化。

      1
      2
      3
      4
      5
      6
      7
      8
      public class User {
          final String USERNAME ;
          private int age;
          public User(String username, int age) {
              this.USERNAME = username;
              this.age = age;
          }
      }
  • ==对于类和方法 abstract和final 矛盾 不能同时使用==；全局变量：public static final…
  • 被final修饰的常量名称，一般都有书写规范，所有字母都大写

3局部内部类和匿名内部类中，内部类调用了外部类的变量，则外部类的变量默认编译为final修饰的常量，且final关键字可以省略。

2.4.3 多态
  • 继承->>方法重写->>父类引用指向子类对象；
  • 此外，接口的实现也可以多态
  • 多态是方法的多态，不是属性的多态，与属性无关。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Animal {
    public void shout(){
        System.out.println("叫一声");
    }
    public  void ani(){
        System.out.println("animal");
    }
}
public class Cat extends Animal {
    @Override
    public void shout() {
        System.out.println("喵~");
    }
    public  void cat(){
        System.out.println("cat");
    }
}
public class demo1 {
    public static void main(String[] args) {
        Animal a=new Cat();
        a.shout();   //a自动向上转型 对于其他方法只能调用a内的，而重写方法调用=号右侧对象的方法
        a.ani();		//向下转型需要强转；
    }
}
//喵~
//animal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public class Animal {
    public void shout(){
        System.out.println("叫一声");
    }
}
public class Dog extends Animal {
    @Override
    public void shout() {
        System.out.println("汪汪汪~");
    }
}
public class Cat extends Animal {
    @Override
    public void shout() {
        System.out.println("喵~");
    }
}
public class demo1 {
    public static void main(String[] args) {
        Animal a=new Animal();			// 重写的继承方法：根据等号对象判断
        jiao(a);						//非继承，类自有方法，根据引用类型判断
        
        								//类型转换,调用特有方法
        
        Dog d =new Dog();				//向下强制数据类型转型：必须有继承关系，不然报错
        jiao(d);						//向下转型可以用instanceof判断
        
        Cat c=new Cat();
        jiao(c);
    }
    static void jiao(Animal b){					//父类引用指向子类对象；
        b.shout();
    }
}


public class Test { public static void main(String[] args) { 
    // 向上转型 
    Animal a = new Cat(); 
    a.eat(); // 调用的是 Cat 的 eat 
    // 向下转型 
    if (a instanceof Cat){ 
        Cat c = (Cat)a; 
        c.catchMouse(); // 调用的是 Cat 的 catchMouse 
    } else if (a instanceof Dog){ 
        Dog d = (Dog)a; 
        d.watchHouse(); // 调用的是 Dog 的 watchHouse 
    } 
} 
                  }

2.5 抽象

  • 如果一个类包含抽象方法，那么该类必须是抽象类。
  • 继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。
  • 不能直接进行实例化操作，需要实现类去创建。
  • 对于类和方法 abstract和final 矛盾不能同时使用。
  • 抽象类【可以有】构造方法（继承时，先实现父类的构造方法…）==因此开发者不能通过new创建抽象类的对象，但jvm可以以某种方式生成抽象类实现的部分供子类使用。==
  • 抽象类必须用public或procted 修饰(如果为private修饰，那么子类则无法继承，也就无法实现其抽象方法）。默认缺省为 public
1
2
3
4
5
//包含抽象方法的为抽象类>>抽象类可以有非抽象成员方法
public abstract class Animal{	
	public abstract void eat(); 
    public void run(){};//非抽象成员方法
}

2.6 接口

  • 包含常量、抽象方法、默认方法、静态方法、私有方法

  • 是另外一种引用数据类型

    • 一定要明确它并不是类
    • 引用数据类型：数组，类，接口。

  • 包含的内容：抽象方法；默认方法；静态方法；私有方法；

    1
    2
    3
    4
    5
    6
    7
    //格式
    public interface 接口名称{
    	// 抽象方法:使用 abstract 关键字修饰，可以省略，没有方法体，public也可省略。
        // 默认方法:使用 default 修饰，不可省略，供子类(实现类)调用或者子类重写(二选一)。
        // 静态方法:使用 static 修饰，供接口直接调用。不可以通过实现类的类名或者实现类的对象调用
        // 私有方法:使用 private 修饰，私有方法：只有默认方法可以调用。私有静态方法：默认方法和静态方法可以调用。
    }

  • 接口的实现

    1
    2
    3
    4
    5
    6
    class 类名 implements 接口名 {
        // 重写接口中抽象方法【必须】
        // 重写接口中默认方法【可选】   
    } 
    //1. 必须重写接口中所有抽象方法。
    //2. 继承了接口的默认方法，即可以直接调用，也可以重写。

  • 接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26

    interface A {
        public abstract void showA();
        public abstract void show();
    }
     
    interface B {
        public abstract void showB();
        public abstract void show();
    }
    public class C implements A,B{
    	@Override
        public void showA() {
            System.out.println("showA");
        }
     
        @Override
        public void showB() {
            System.out.println("showB");
        }
     
        @Override
        public void show() {
            System.out.println("show");
        }
    }

  • 接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。代码如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    interface A {
        public default void methodA(){}
        public default void method(){}
    }
     
    interface B {
        public default void methodB(){}
        public default void method(){}
    }
    public class C implements A,B{
        @Override
        public void method() {
            System.out.println("method");
        }
    }

  • 存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

    • 当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执
      行父类的成员方法。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    interface A {
        public default void methodA(){
            System.out.println("AAAAAAAAAAAA");
        }
    }

    class D {
        public void methodA(){
            System.out.println("DDDDDDDDDDDD");
        }
    }

    class C extends D implements A {
       // 未重写methodA方法   
    }

    public class Test {
        public static void main(String[] args) {
            C c = new C();
            c.methodA(); 
        }
    }
    输出结果:
    DDDDDDDDDDDD

  • 接口的多继承

    • 如果父接口中的默认方法有重名的，那么子接口需要重写一次。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      interface A {
          public default void method(){
              System.out.println("AAAAAAAAAAAAAAAAAAA");
          }
      }
       
      interface B {
          public default void method(){
              System.out.println("BBBBBBBBBBBBBBBBBBB");
          }
      }
      interface D extends A,B{
          @Override
          public default void method() {
              System.out.println("DDDDDDDDDDDDDD");
          }
      }

  • ==子接口重写默认方法时，default关键字可以保留；子类重写默认方法时，default关键字不可以保留。==

  • 接口中，没有构造方法，不能创建对象。

  • 接口中，没有静态代码块。

2.7 内部类

  • 内部类可以直接访问外部类的成员，包括私有成员。

  • 外部类要访问内部类的成员，必须要建立内部类的对象。

    1
    外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；
    2.7.1成员内部类

    image-20200924213940138

    2.7.2匿名内部类

    image-20200924221310736

3、API

3.1、Scanner

1
2
3
4
5
6
7
8
9
10
11
12
//构造方法：
import java.util.Scanner

public class demo1{
    public static void main(String[] args){
        //创建对象
        Scanner sc=new Scanner(System.in){};//System.in {}
        //接受数据
        int i = sc.nextInt(10);					//sc.nextLine()字符串
        
    }
}

3.2、Random

1
2
3
4
5
6
7
import java.util.Random
    public class demoRandom{
        public static void main(String() args){
            Random r =new Random();
            int i = r.nextInt(10)+1;    			
        }
    }

3.3、ArrayList

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.ArrayList;

public class aaa {

    public static void main(String[] args) {
        Student s1=new Student(13,"lu",true);			//创建对象
        Student s2=new Student(13,"赵丽颖",false);

        ArrayList<Student> list=new ArrayList<>();		//创建集合
        list.add(s1);									//要在main函数里，添加对象
        list.add(s2);																

        for (int i = 0; i < list.size(); i++) {			//遍历集合，集合get()提取来遍历
            Student s = list.get(i);
            System.out.println(s.isMale());
            System.out.println(s.getAge());
                    }

    }
    
    
    //常用方法 list.size()  list.remove(i)  list.add(s1)

范型只能是引用类型 不能是基本类型（若需要基本类型，需要包装类 位于java.lang包下）

byte Byte float Float
short Short double Doule
long Long char Character
int Integer boolean Boolean

3.4、String

  • String

image-20200512214341451

​

​ 

1
2
3
4
5
6
7
8
9
10
import java.util.Scanner;
public class demo1Scanner{
public static void main(String[] args){
  	Scanner sc = new Scanner(System.in);
    String str=sc.next();						//输入字符型
    System.out.println(str);
    int sum=sc.nextInt();						//输入整型
    System.out.println(sum);
	}  
}
  • 一个匿名对象，只能使用一次。以下是两个对象；
1
2
new Scanner(System.in).nextInt();
new Scanner(System.in).nextInt();

匿名对象作为参数：

​ 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.Scanner;
public class demo2Scanner{
    public static void main(String[] args){
     int num= new Scanner(System.in).nextInt();
       System.out.println("输入的是："+num);  
     //一般写法
    Scanner sc=new Scanner(System.in);
    methodParam(sc);
    //匿名引用
    methodParam(new Scanner(System.in);
    }

    
    public static void methodParam(Scanner sc){
        System.out.println(new Scanner().nextInt); 
    }
}

匿名对象还可作为返回值：

对象数组：

1
2


String

image-20200509135639331

Random类

image-20200509150316211

image-20200509151440310

Arrays

image-20200509152717995

8、内部类

8.1分类

  • 成员内部类

    定义格式：

    修饰符 class 外部类名称{

    ​ 修饰符 class 内部类名称{

    }

    内用外，随意访问，即便是外部私有。外用内，需要内部对象引用

    1
  • 局部内部类(包括匿名内部类)

image-20200513135432308

image-20200513135950991

8.3局部内部类中的匿名内部类（lambda表达式的基础）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public interface MyInterFace{
	void fangfa();
}


//接口的实现类只用一次
public class void main{
    public static void main(String[] args){
        MyInterface obj =new MyInterface(){				//接口作为抽象类，本不可以new对象
          	@override
            public void fangfa(){
                System.out.println("匿名内部类实现接口的重写方法！")
            }
        };						//分号
    }
}

注意事项：

  • new 接口名称(){…} 接口名称是匿名内部类需要实现哪个接口

    ​ {…} 匿名内部类的内容

  • 1、适用于实现类只用一次；

    2、匿名内部类作为匿名对象时

    ​ 

    1
    2
    3
    4
    5
    6
    new MyInterface(){				
              	@override
                public void fangfa(){
                    System.out.println("匿名内部类实现接口的重写方法！")
                }
             }.fangfa();			//但是匿名对象的方法只能用一个且一次

    3、匿名内部类 省略了实现类 ；匿名对象省略了对象名称；

8.4、类作为成员变量

​ 

1
2
3
public class Fu(){
	private String name;    //String 本质是一种类；
}

​

9、重写object的equal方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Objects;

public class person {
    String name;
        int age;

    @Override    //alt+enter
    public boolean equals(Object o) {
        if (this == o) return true;
//getClass() != o.getClass()使用反射技术，判断o是否为person类型，等同于o instanceof person
        if (o == null || getClass() != o.getClass()) return false;
        person person = (person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }
}

Objects.equals 可以容忍空指针异常

1
2
3
4
5
6
7
8
9
10
import java.util.Objects;
public class person {
    public static void main(String[] args) {
        String name=null    ;
        String banji=null;
        int age;
        boolean b = Objects.equals(name, banji);		//要在main方法下调用？？
        System.out.println(b);		//快捷键 Objects.equals(name, banji)。var
    }
}

10、日期时间类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main(String[] args) {
       Date date =new Date();           //构造实质上是Date型毫秒数，其实print把它tostring
       System.out.println(date);           //tostringThu May 14 14:48:54 CST 2020
       Date time=new Date(1589427125275L);//long型、构造
       System.out.println(time);        //print中tostringThu May 14 14:48:54 CST 2020

       long currT = System.currentTimeMillis();
       System.out.println(currT);             //1589438934925
       Long l=date.getTime();          	//成员
       System.out.println(l);              //1589438934869
    
    
   	 DateFormat fd=new SimpleDateFormat("yy年MM月dd日");
      	 Date sss = fd.parse("92年11月18日");

       System.out.println(((currentTime.getTime()-sss.getTime())/1000/3600/24/365)+"天");
   }

Date 类

  • 构造方法：public Date(){} 是毫秒数;public Date(Long型)
  • 成员方法：Date型对象.getTime() 返回的是long型

Dateformat 类是抽象类 他的子类SimpleDateFormate类 包含下面两个方法：

  • String time_a=new.SimpleDateformat(“yy年MM月dd日”).format(long 型) :

  • Date time_b=new.SimpleDateformat(“yy年MM月dd日”).parse(“2018年12月11日 “)

Stringbuilder()

image-20200514155730814

对象名.append()

image-20200514155548037

toString()

image-20200514155944394

11、注解Annotation

  • 注解概述
  • 注解示例
  • 自定义annotation
  • JDK中的元注解
  • 利用反射获取注解信息
  • JDK8中注解的新特性

12、反射

基本功项目训练

二、数据结构和算法

  • 几大基础数据结构类型得烂熟于心，比如：字符串、链表、二叉树、栈、队列等等；基本的几大算法要了如指掌，比如查找、排序、动态规划等等。

三、TCP/IP协议栈

  • TCP/IP协议栈可以说是当下互联网通信的基石，无论如何一定要对TCP/IP的协议栈了如指掌，包括：ARP协议、IP协议、ICMP协议、TCP和UDP协议、DNS协议、HTTP协议、HTTPS协议等等

数据链路层：以太网帧的格式;mtu

DAY1

  • 概述
  • 链路网
  • ip：国际协议

DAY2

  • ARP
  • ICMP
  • PING
  • Traceroute
  • IP选路

DAY3

  • UDP
  • 广播与多播
  • DNS
  • TFTP

DAY4\5

  • TCP

DAY6

  • 应用层

四、设计模式

  • 倒不需要23种设计模式全部很熟悉，常见的几个，比如：单例模式、工厂模式、代理模式、策略模式、模板方法模式等几个熟练于心即可

五、数据库和SQL

  • 数据库基本原理了解，SQL语句熟练书写，常见的优化方式熟悉

六、操作系统

  • 该部分重点包括：进程和线程的相关原理（原子性、并发、锁）、内存相关原理（内存分布、内存调度）等

  • 2、 年

-------------本文结束感谢您的阅读-------------