FisherYu626

一颗有趣的灵魂~

0%

java学习笔记2

发表于 分类于
本文字数： 5.8k 阅读时长 ≈ 5 分钟

Java学习笔记2

Java学习笔记

1.可变参数

在方法声明中，在指定参数类型后加一个省略号。

一个方法只能指定一个可变参数，它必须是方法的最后一个参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.fisher.base;

public class demo1 {

    public static void main(String[] args){
        System.out.println("hello,world");
        demo1 d = new demo1();
        d.test(32,2,5,6,9);
    }

    public void test(int... numbers){
        for(int i =0;i<numbers.length;i++){
            System.out.println("the number "+i+" is "+numbers[i]);
        }
    }
}

2.递归结构2部分

  • 递归头：什么时候不调用自身方法 终止条件
  • 地柜体： 什么时候需要调用自身方法

3.java内存浅析

Java内存主要由以下三部分组成

  1. 堆

    1. 存放new的对象和数组。
    2. 可以被所有的线程共享，不会存放别的对象引用

  2. 栈

    1. 存放基本变量类型，包含这个基本类型的具体数值
    2. 引用对象的变量（会存放这个引用在堆里的具体地址）

  3. 方法区

    1. 可以被所有的线程共享
    2. 包含了所有的class和static变量

声明数组时在栈里创建一个变量 存储的是对象的地址，相当于一个指针（声明）

image-20220225114445278

创建数组时用引用指向堆中的变量（初始化）

image-20220225114853450

4.数组的三种初始化方法

  • 静态初始化

    定义后不可改变

    1
    2
    int[] a = {1,2,3};
    Man[] mans = {new Man(1,1),new Man(2,2)};

  • 动态初始化 动态初始化的过程包含默认初始化

    1
    2
    3
    int[] a = new int[2];
    a[0] = 1;
    a[1] = 2;

  • 数组的默认初始化

    数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素按照实例变量同样的方式被隐式初始化。

5.数组的工具类

数组本身没有方法供大家使用，只有一个array.length可以查看长度。

Java提供一个数组工具类 java.utils.Arrays

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，不需要使用对象进行调用。

常用方法：fill() sort() equals() binarySearch()

6.稀疏数组

把具有不同值的元素和行列及值存储在一个小规模数组中，从而缩小程序的规模。

自己构造一个 sum+1行，3列的数组。

image-20220227165548591

7.类

一个项目应该只有一个main方法。

8.new关键字

使用new关键字创建的时候，除了分配内存空间以外，还会给创建好的对象进行默认的初始化以及类内构造器的调用。

构造器有以下两个特点：

  • 必须和类的名字相同

  • 必须没有返回类型，也不能写void

  • 一旦定义有参构造，必须显示定义无参构造

    image-20220301211903343

9.引用

除了八个基本类型以外的变量类型都为引用类型。

对象通过引用来操作： 栈 ——》堆

10.面向对象三大概念——封装

  • 封装 大多时候针对属性而言

    封装意义：

    1. 提高程序安全性，保护yins
    2. 隐藏代码实现细节
    3. 统一接口
    4. 系统可维护性增加

    • 该露的露，该藏的藏

      • 设计要求 高内聚、低耦合
        • 高内聚 类的内部数据操作细节自己完成，不允许外部干涉
        • 低耦合 仅暴露少量的方法给外部使用

    • 数据的隐藏

      通常 应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

    • 属性私有，get/set

11.面向对象三大概念——继承

  • 继承的本质 是对某一批类的抽象，从而实现对现实世界更好的建模。
  • extands的含义是扩展，子类是父类的一种扩展

  • Java中的类只有单继承，没有多继承

  • Java中所有的类都默认直接或者间接继承Object类

  • 子类和父类的关系为 子类is a 父类

idea查看继承关系快捷键 control+H

  • 私有的属性、方法无法被继承

12.super注意点

  1. super（）调用父类的构造方法，必须在构造方法的第一行
  2. super必须只能出现在子类的方法或者构造方法中
  3. super和this不能同时调用构造方法

super和this 的不同：

代表的对象不同：

  • this 调用者这个对象
  • super 代表父类对象的引用

前提：

  • this没有继承也能用
  • super 只有继承条件才可以使用

构造方法：

  • this 用来调用本类的构造方法
  • super 用来调用父类的构造方法

13.方法重写

重写都是方法的重写 与属性无关

1
2
3
4
5
6
7
8
9
10
11
public class Person {

    String name;

    public Person() {
    }

    public void test(){
        System.out.println("this is Pearson test");
    }
}
1
2
3
4
5
6
7
8
9
10
public class Student extends Person{
    public Student() {

    }

    @Override
    public void test() {
        System.out.println("this is Student test");
    }
}
1
2
3
4
5
6
7
8
9
10
public class demo {
    public static void main(String[] args) {
        Person A = new Student();
        Student B = new Student();

        A.test();
        B.test();
        return;
    }
}

image-20220302204559591

注解：有功能的注释

alt+insert 万能键、

重写需要有继承关系 子类重写父类的方法

  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符：范围可以扩大 但不能缩小public>protected>Default>private
  4. 抛出的异常：异常的范围可以被缩小 但不能扩大

重写 子类的方法和父类要一致，方法体不同

为什么要重写？

  1. 父类的功能，子类不一定需要，或者不一定满足！

    alt+Insert : opverride

14.面向对象三大概念——多态

  • 同一方法可以根据发送对象的不同采用多种不同的行为方式

  • 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多。 （父类，有关系的类）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.fisher.duotai;

/**
 * @author Fisheryu
 * @date 2022/3/2 20:51
 */

public class Person {
    public Person() {
    }

    public void run(){
        System.out.println("Person run");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.fisher.duotai;

/**
 * @author Fisheryu
 * @date 2022/3/2 20:52
 */

public class Student extends Person{
    public Student() {
    }

    @Override
    public void run() {
        System.out.println("Student run");
    }
    public void eat(){
        System.out.println("Student eat");
    }
}
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 com.fisher.duotai;
/**
 * @author Fisheryu
 * @date 2022/3/2 20:51
 */

public class demo {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型不确定，父类的引用可以指向子类

        //Student引用能调用的方法都是自己的 或者 继承父类的方法
        Student s1 = new Student();
        //Person父类型可以指向子类 但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();
    
        //对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大
        s1.run();//子类重写了父类的方法，则执行子类的方法 具体运行的方法是根据运行期间确定的，而不是根据引用
        s2.run();
    }
}

image-20220302210909497

  • 多态是方法的多态
  • 父类和子类之间有联系 需要继承关系（类型转换异常）ClassCastEXception！
  • 存在的条件： 继承关系 方法需要重写 父类引用指向子类

静态方法属于类 不属于任何一个实例 不能被重写

final 修饰的方法 在常量池中 不能重写

private方法不能重写

总结：

1
Object object = new Student();
  1. 父类引用指向子类对象
  2. 把子类转换为父类，向上转型，可能会丢失原来的一些方法。
  3. 把父类转换为子类，向下转型，强制转换。
  4. 方便放发的调用，减少重复的代码，简洁。

15.instanceof 类型转换（引用类型的类型转换）

instanceof 判断一个对象是个什么类型

X instance Y

编译能不能通过根据X是否是Y的子类型

运行结果是不是true根据X实际执行的对象是会不是Y的子类型

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
public class demo {
    public static void main(String[] args) {
        Object object = new Student();
        Person person = new Student();
        Student student = new Student();

        System.out.println(object instanceof Student);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof Teacher);
        System.out.println(object instanceof String);

        System.out.println("------------------------");

        System.out.println(person instanceof Student);
        System.out.println(person instanceof Person);
        System.out.println(person instanceof Object);
        System.out.println(person instanceof Teacher);
        //编译直接出错
        // System.out.println(person instanceof String);

        System.out.println("------------------------");
        System.out.println(student instanceof Student);
        System.out.println(student instanceof Person);
        System.out.println(student instanceof Object);
        //编译直接出错
        //System.out.println(student instanceof Teacher);
        //System.out.println(student instanceof String);
    }
}

image-20220303164224606

16.static关键字

  • static修饰属性

    静态属性可以直接通过类名访问

    静态属性是某个类中所有对象共享的

    1、在内存中存放位置不同 所有带static修饰符的属性或者方法都存放在内存中的方法区 而非静态属性存放在内存中的堆区

    2、出现时机不同 静态属性或方法在没创建对象之前就已经存在 而非静态属性在创建对象之后才存在

    3、静态属性是在某个类中的所有对象是共享的

    4、生命周期不同 静态属性在类消失之后才销毁 而非晶态属性在对象销毁之后才销毁

    5、用法：

    　　a.静态属性可以直接通过类名直接访问 非静态属性不能通过类直接访问只能通过对象访问

    　　b.二者的相同点是都可以在创建完对象后使用下面看个静态属性是在某个类中的所有对象是共享的例子

  • static修饰方法 属于类的方法

  • static匿名代码块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Person {
    //创建对象时会在构造方法前加载匿名代码块 用于赋初值
    {
        System.out.println("匿名代码块");
    }
    //加载类的时候会调用静态代码块 只执行一次
    static{
        System.out.println("静态代码块");
    }

    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person = new Person();
        return;
    }
}

image-20220303170558372

  • 静态import

    静态导入包 导入包里的静态方法和静态属性

    1
    2
    import static java.lang.Math.random;
    import static java.lang.Math.PI;

17.final关键字

final修饰的类不能再被继承 （final之后断子绝孙）