Java学习笔记

Java的方法重载

方法重载(Overload)：多个方法名称相同，但是参数列表不同。
只需要记住一个方法名称，就可以实现类似的多个功能。
方法的重载与参数的个数，类型，顺序有关。
方法的重载与方法的返回值类型无关。

	public static void main(String[] args) {
        int b = sum(1,3);
        int c = sum(1,3,5);
        int d = sum(1,3,5,7);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }

    public static int sum(int a, int b) {
        int res = a + b;
        return res;
    }
    public static int sum(int a, int b, int c) {
        int res = a + b + c;
        return res;
    }
    public static int sum(int a, int b, int c, int d) {
        int res = a + b + c + d;
        return res;
    }

Java的数组和内存划分

以下new一个数组和修改数组内元素的值的过程。

两个不相关的数组。

两个数组，将一个数组赋给另一个数组。

Array和String对象的综合练习题

• 题目：键盘输入一个字符串，并且统计其中各种字符出现的次数。种类有：大写字母，小写字母，数字，其他。

 public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();

        char[] arr = new char[s.length()];
        for (int i = 0; i < s.length(); i++) {
            arr[i] = s.charAt(i);
        }
        int upper = 0;
        int lower = 0;
        int integ = 0;
        int others = 0;

        for (int i = 0; i < arr.length; i++) {
            if(arr[i] >= 65 && arr[i] <= 90){
                upper++;
            }else if(arr[i] >= 97 && arr[i] <= 122){
                lower++;
            }else if (arr[i] >= 48&&arr[i] <=57){
                integ ++;
            }else {
                others++;
            }
        }
        System.out.println("大写："+upper+"小写："+lower+"数字："+integ+"其他："+others);

Java的静态Static关键字

• static关键字的特点

  • 随着类的加载而加载
  • 优先于对象存在
  • 被类的所有对象共享
    举例：咱们班级的学生应该共用同一个班级编号。其实这个特点也是在告诉我们什么时候使用静态?如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
  • 可以通过类名调用。其实它本身也可以通过对象名调用。但更推荐使用类名调用。

• static关键字的内存流程图
  

代码块

• 代码块概述
  在Java中，使用{}括起来的代码被称为代码块。
• 代码块分类
  根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
• 常见代码块的应用
  • 局部代码块。在方法中出现；限定变量生命周期，及早释放，提高内存利用率。
  • 构造代码块 (初始化块)。在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行。
  • 静态代码块。在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。

继承和抽象类

继承主要解决的问题是共性抽取。
在继承的关系中，“子类就是一个父类”。子类可以被当作父类看待。
定义子类继承的关键字extends。

子类中定义的方法想要访问父类中的成员变量可以使用关键字super。

继承中方法的覆盖重写（Override）：

• 重写（Override）：方法的名称一样，参数列表也一样。也叫方法的覆盖。
• 重载（Overload）：方法的名称一样，参数列表不一样。

方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。

• 方法覆盖重写的注意事项：

1. 必须保证父子类之间方法名称相同，参数列表也相同。
2. 子类方法的返回值必须小于或等于父类方法的返回值范围。
3. 子类方法的权限必须大于或等于父类方法的权限修饰符。（顺序：public>protected>(default)>private,default不是关键字default，而是什么都不写）

一点设计原则：对于已经投入使用的类，尽量不要进行修改。推荐方法是定义一个新的类，来重复利用其中共性内容，并且添加改动新内容。在子类的方法里使用super关键字可以访问到父类方法里的内容。

继承关系中，父子类构造方法的访问特点：
子类的构造方法中有一个默认隐含的super()调用。所以用构造方法new对象的时候是先调用父类构造，后调用子类构造。子类必须调用父类构造方法，不写则赠送super()，写了则用写的制定的super调用，super只能有一个且必须是第一个。

super和this关键字的内存图解

java继承的三个特点

• Java语言是单继承的，一个类的直接父类只能有唯一一个。
• Java语言可以多级继承。C有一个父类B，B有一个父类A，那么A也是C的父类。
• 一个子类的直接父类是唯一的，但是一个父类可以拥有很多个子类。

抽象

**抽象方法：**加上abstract关键字，然后去掉大括号，直接分号结束。
**抽象类：**抽象方法所在的类。

public abstract class Animal {
    // 这是一个抽象方法，代表吃东西，但是吃什么（大括号的内容）不确定。
    public abstract void eat();
}

如何使用抽象类和抽象方法：
1. 不能直接创建new抽象类对象。
2. 必须用一个子类来继承抽象父类。
3. 子类必须覆盖重写抽象父类中的所有抽象方法。
4. 创建子类对象进行使用。

注意事项：

1. 抽象类不能创建对象。
2. 抽象类中可以有构造方法，供子类创建对象时，初始化父类成员。
3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
4. 抽象类的子类必须重写抽象父类中的所有的抽象方法，否则编译无法通过而报错，除非该子类也是抽象类。

接口

接口就是一种公共的规范标准。只要符合规范标准，就可以大家通用。接口关键字是interface。

接口使用步骤：

1. 接口不能直接使用，必须有一个“实现类”来“实现”该接口。格式public class 实现类名称 implements 接口名称
2. 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
3. 创建实现类的对象，进行使用。

接口的内容小结

多态

父类引用指向子类对象，左父右子。

案例分析

案例图解

final 关键字

1. final关键字修饰一个类的时候，当前这个类不能有任何的子类。注意：一个类如果是final类，其中所有的成员方法都无法进行覆盖重写。
2. final关键字用来修饰一个方法时，这个方法就是最终方法，不能被覆盖重写。对于类和方法来说，abstract和final关键字不能同时使用，因为矛盾。
3. final关键字用来修饰局部变量时，这个变量不能进行更改。一次赋值终生不变。
4. final关键字用来修饰成员变量时，这个变量也照样不可变。但是成员变量具有默认值，所以一旦用了final之后必须手动赋值，不会再给默认值了。对于final修饰的成员变量，要么直接赋值，要么通过构造方法赋值，而且必须保证类当中所有重载的构造方法都会对final的成员变量进行赋值。

权限修饰符关键字

主要有以下的几种

	public	protected	(default)=不写	private
同一个类	√	√	√	√
同一个包	√	√	√	×
不同包，子类	√	√	×	×
不同包非子类	√	×	×	×

集合框架