java学习笔记（三）--java包的引入、访问控制、类的继承、super关键字、重载、重写、运算符、拆箱

1.包的引入

在 java 中，通过 import 导入类的方式有两种：

单类型导入（single-type-import）
- 例如 import java.io.File：这种方式比较容易理解，而且大部分时候我们用的都是这种方式，通过明确指明类和接口路径，将他们导入进来。
按需类型导入（type-import-on-demand）
- 例如 import java.io.：通过通配符定义导入方式，但是并不是直接导入这个包下的所有类，而是可以导入所有类。也就是说，如果需要就导入，不需要就不导入。

2. 同一个包，不用导入。不同的包，需要导入。

导入包的注意事项

一个类同时引入两个来自不同包名的同类名，必须通过完整的类名来区分。
package和import 的顺序是固定的。
- package必须位于第一行
- 只允许有一个package语句
- 其次是import
- 接着是类的声明

多个包中出现同名类，需要通过完整的类名进行区分。演示如下：

2.访问控制

访问控制： 指的是本类及本类内部的成员（成员变量、成员方法、内部类）对其他类的可见性，即这些内容是否允许其他类访问。

Java 中一共有四种访问权限控制，其权限控制的大小情况是这样的：public > protected > default(包访问权限) > private

访问修饰符有4种

java 复制代码

public class Person {
    //public成员变量可以被任何类访问
    public String name;

    //protected成员变量可以被同一个包中的类以及所有子类访问
    protected int age;

    //private成员变量只能被同一个类中的方法访问
    private double salary;

    //public成员方法可以被任何类调用
    public void getInfo() {
        System.out.println("Name: "+name+" Age: "+age+" Salary: "+salary);
    }

    //protected成员方法可以被同一个包中的类以及所有子类调用
    protected void setAge(int a) {
        age = a;
    }

    //private成员方法只能被同一个类中的方法调用
    private void setSalary(double s) {
        salary = s;
    }
}

各个修饰符含义：

public： 所修饰的类、变量、方法，在内外包均具有访问权限。
protected： 这种权限是为继承而设计的，protected所修饰的成员，对所有子类是可访问的，但只对同包的类是可访问的，对外包的非子类是不可以访问。
包访问权限（default）： 只对同包的类具有访问的权限，外包的所有类都不能访问。
private： 私有的权限，只对本类的方法可以使用。

注意： 要区分开 protected 权限、包访问权限，正确使用它们。

当某个成员能被所有的子类继承，但不能被外包的非子类访问，就是用protected。
当某个成员的访问权限只对同包的类开放，包括不能让外包的类继承这个成员，就用包访问权限。

使用访问权限控制的原因：

使用户不要碰触那些他们不该碰触的部分。
类库设计者可以更改类的内部工作的方式，而不会担心这样会对用户产生重大影响。

java 复制代码

public class Test {
    public int a; //可以被任何类访问
    protected int b; //可以被同一个包中的类以及所有子类访问
    private int c; //只能被同一个类中的方法访问
}


public class Test2 {
    public static void main(String args[]) {
        Test test = new Test();
        test.a = 1; //可以访问
        //test.b = 2; //不能访问
        //test.c = 3; //不能访问
    }
}


public class Test3 extends Test {
    public static void main(String args[]) {
        Test3 test3 = new Test3();
        test3.a = 1; //可以访问
        test3.b = 2; //可以访问
        //test3.c = 3; //不能访问
    }
}

3. 类的继承

查看类图

1、什么是继承?

继承，简单来说，就是一个类可以获取另一个类的属性和方法。被继承的类称为父类（超类、基类），继承的类称为子类（派生类）。
通过继承，子类不仅拥有了父类的非私有属性和方法，还可以添加自己特有的属性和方法，或者重写父类的方法以满足特定需求。
继承是面向对象的三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。

2.继承的特点

Java只能单继承，不能多继承、但可以多层继承。
Java只能单继承，不能多继承，也就相当于一个儿子只能有一个父亲(一个类只能有一个直接父类)。
如果子类继承了多个父类那么如果两个父类都有同一个方法名，那么子类到底该调取哪一个呢，所以Java为了解决这个问题就规定只能单继承，不能多继承。

子类到底能继承父类中哪些内容？

java类的初始化顺序为：1.父类属性->2.父类构造->3.子类属性->4.子类构造。

4.super和this关键字

1.this和super定义

this 是当前类的对象，代表对象本身。可以理解为：指向对象本身的一个指针。
super父类对象。可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。

super的注意事项

super能出现在实例方法和构造方法中,super调用方法时，只能是第一句。
super的语法是"super."和"super()"。
super不能出现在静态方法中。super也不能访问父类私有成员。
super大部分情况下是可以省略的。

super和this区别是：

this可以看做一个引用变量，保存了该对象的地址，是当前对象整体。
super代表的是父类型特征，是子类局部的一些东西，这些继承过来的东西已经在子类里面了，你可以输出整体this，但不能输出父类型特征super。因为super指向的东西不是一个整体，没法打印输出。

5.重载和重写

重写(Override)是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。关于多个类。即外壳不变，核心重写！

重写规则

方法名相同
参数列表相同
返回值类型相同或者是其子类
访问权限不能严于父类

重载（overloading）是在一个类里面 ，方法名字相同，而参数不同。返回类型可以相同也可以不同。重载规则

被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

重写与重载直接的区别

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做出更严格的限制（可以降低限制）

6. 运算符

Java的运算符是特定符号，用于执行特定操作。它们可以用于比较、赋值、逻辑操作、位运算等。运算符可以帮助我们完成各种复杂的计算操作，更加高效的完成编程任务。

1.Java场景的运算符有哪些？

算术运算符：+、-、*、/、%
关系运算符：>, <, >=, <=, ==, !=
逻辑运算符：&&、||、!
赋值运算符：=、+=、-=、*=、/=、%=
位运算符：&、|、^、~、<<、>>
条件运算符：?:
instanceof运算符：instanceof

在Java中,位运算符主要有以下几种:

& - 按位与运算符,两位都为1才为1
| - 按位或运算符,有一位为1就为1
^ - 按位异或运算符,两位不同则为1
~ - 按位取反运算符,0变1,1变0
<< - 左移运算符,各二进制位全部左移指定位数

java 复制代码

int a = 5; // 00000101  
int b = 3; // 00000011  
int c = a & b; // 00000001 按位与  
int d = a | b; // 00000111 按位或  
int e = a ^ b; // 00000110 按位异或  
int f = ~a; // 11111010 按位取反  
int g = a << 1; // 00001010 左移1位  
int h = a >> 1; // 00000010 右移1位

7.什么是拆箱和装箱？

先区分基本类型和包装类型

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

1.拆箱

拆箱是指将包装类对象转换为基本类型数据的操作。此操作可以通过调用基本类型的值来实现，如intValue(),doubleValue() 等。

2.装箱

装箱是指将基本类型数据转换为包装类对象的操作，它可以通过调用包装类的静态方法valueOf()来实现。

常用的基本类型和包装类型相互拆箱和装箱案例：

java 复制代码

byte b = Byte.valueOf(str); // 把字符串转换为byte
Byte bb = Byte.valueOf(b); // 把byte转换为Byte

short s = Short.valueOf(str); // 把字符串转换为short
Short ss = Short.valueOf(s); // 把short转换为Short

int i = Integer.valueOf(str); // 把字符串转换为int
Integer ii = Integer.valueOf(i); // 把int转换为Integer

long l = Long.valueOf(str); // 把字符串转换为long
Long ll = Long.valueOf(l); // 把long转换为Long

float f = Float.valueOf(str); // 把字符串转换为float
Float ff = Float.valueOf(f); // 把float转换为Float

double d = Double.valueOf(str); // 把字符串转换为double
Double dd = Double.valueOf(d); // 把double转换为Double

boolean b = Boolean.valueOf(str); // 把字符串转换为boolean
Boolean bb = Boolean.valueOf(b); // 把boolean转换为Boolean

char c = Character.valueOf(str); // 把字符串转换为char
Character cc = Character.valueOf(c); // 把char转换为Character