【详细+超基础】Java-学习笔记 09-CSDN博客

本文链接：https://blog.csdn.net/qq_51808107/article/details/113408143

在这里插入图片描述

【详细+超基础】Java-学习笔记

Java学习笔记系列持续更新中…

修饰符

1.1 package与 import

包的概念
包就是文件夹，用来管理类文件的
包的定义格式
package 包名; (多级包用.分开)
例如：package com.jumper.demo;
带包编译&带包运行
带包编译：javac –d . 类名.java
例如：javac -d . com.jumper.demo.HelloWorld.java
带包运行：java 包名+类名
例如：java com.jumper.demo.HelloWorld
导包的意义
使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了
为了简化带包的操作，Java就提供了导包的功能
导包的格式
格式：import 包名;
范例：import java.util.Scanner;
示例代码（没有使用导包，创建的Scanner对象）

package com.heima;
public class Demo {
	public static void main(String[] args) {
	// 1. 没有导包，创建Scnaner对象
java.util.Scanner sc = new java.util.Scanner(System.in);
	}
}

示例代码（使用导包后，创建的Scanner对象）

package com.heima;
import java.util.Scanner;
public class Demo {
	public static void main(String[] args) {
	// 1. 没有导包，创建Scnaner对象
		Scanner sc = new Scanner(System.in);
	}
}

1.2 访问修饰符

在前面定义类时使用了public，定义属性时使用了private，定义方法时使用了public。它们都是java的访问修饰符。java一共定义了四种访问权限控制符：private、默认访问权限、protected、public,通过权限控制符合包能够控制访问权限。

private

private可以用来修饰成员变量、成员方法、构造方法以及内部类（内部类是定义在另
个类里面的类，跟成员变量一样属于另一个类的成员)。private 修饰的成员只能被它所属的
类内的其他方法访问，不能被该类以外的其他类访问。
默认访问权限
默认访问权限也称为包访问权限，不写访问控制符的就是默认访问权限。默认访问权限可以用来修饰成员变量、成员方法、构造方法、类和接口。默认访问权限定义的内容可以被同一个包中的类所访问，包括它本身，但不能被别的包中的类访问。
protected
protected可以用来修饰成员变量、成员方法、构造方法以及内部类。protected 修饰的成员可以被同一个包内的其他类访问，不同包如果是它的子类也可以访问，其他包中不是它的子类的类不能访问。
public
public可以用来修饰成员变量、成员方法、构造方法以及类和接口。pulie修饰的成员可以被任何类访问，无论是否在同一一个包内。

访问权限表

修饰符	同一个类	同一个包中子类无关类	不同包的子类	不同包的无关类
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

类变量、实例变量与局部变量

定义在类体内且在方法外的变量称为成员变量，定义在方法内的变量称为局部变量。

成员变量：

类的成员变量有两种:一种是类变量，一种是实例变量，定义成员变量时，若变量前有关键字static, 则称为类变量，若没有static 关键字，则称为实例变量。类变量存储在类的公用区，属于类所有，所有该类的对象共享这一个类变量;而实例变量属于对象所有，每个对象拥有自己独立的实例变量，保存在对象的内存中。

局部变量：

定义在方法中的变量称为局部变量。局部变量也有两种:一种是方法的形参，一种是方法体内定义的变量。局部变量的生命周期只存在于方法内，方法调用结束，局部变重也就不存在了。

方法体内的局部变量必须赋初值后才能使用，否则编译器认为该变量没有初始化，不能使用。

实例方法与类方法

方法声明时，方法名前不加static的是实例方法，加static的是类方法。
当以类为模板创建多个对象时，则每个对象拥有自己独立的实例方法，但是所有对象共用类的类方法。
(1) 实例方法调用。

对象名.方法();

(2) 类方法调用。
调用类方法有两种格式: “对象名.方法0” 或者 “类名方法0”，建议使用 “类名方法()”。

**案例：**编写一个员工类，假设所有员工的基本工资都一样，但津贴不一样，员工类
具有返回总薪水的方法和普调工资的方法，具体代码如下:

public class Employee {
    static double wage;  // 基本工资，static变量，所有对象都一样
    double allowance;    // 津贴，实例变量，每个对象的津贴可能都不一样
    public double getSalary() { //实例方法。可以使用实例变量和类变量
        return wage+allowance;
    }
    public static void addWage(int a) {
        wage=wage+a;
        // allowance=allowance+a; 错误：因为类方法只能使用类变量
    }
    public static void main(String[] args) {
        Employee e1=new Employee();
        Employee.wage=1000;
        e1.allowance=200;
        Employee.addWage(500);
        System.out.println(e1.wage);
        System.out.println(e1.getSalary());
    }
}

**总结：**类方法属于类所有，第一次加载类时就存在于类的内存了，不用创建对象就可以使用，所以类方法只能使用类变量，因为它们都是在类加载时就存在了。但实例变量不同，实例变量必须在创建了对象后才存在于对象的内存里，所以类方法不能使用实例变量。实例方法是在对象创建后才存在，有了实例方法后，类变量和实例变量肯定都存在了，所以实例方法可以使用类变量和实例变量。

1.1 final关键字

fianl关键字的作用

final代表最终的意思，可以修饰成员方法，成员变量，类

final修饰类、方法、变量的效果

fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）

final修饰方法：该方法不能被重写

final修饰变量：表明该变量是一个常量，不能再次赋值

fianl修饰基本数据类型变量

final 修饰指的是基本类型的数据值不能发生改变

final修饰引用数据类型变量

final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

举例：

public static void main(String[] args){
	final Student s = new Student(23);
	s = new Student(24); // 错误
	s.setAge(24); // 正确
}

1.2 static关键字

static的概念

static关键字是静态的意思，可以修饰【成员方法】，【成员变量】

static修饰的特点

被类的所有对象共享，这也是我们判断是否使用静态关键字的条件

可以通过类名调用当然，也可以通过对象名调用【推荐使用类名调用】

示例代码：

class Student {
	public String name; //姓名
	public int age; //年龄
	public static String university; //学校 共享数据！所以设计为静态！
	public void show() {
		System.out.println(name + "," + age + "," + university);
	}
}
public class StaticDemo {
    public static void main(String[] args) {
        // 为对象的共享数据赋值
        Student.university = "山东建筑大学";
        Student s1 = new Student();
        s1.name = "孙不坚";
        s1.age = 18;
        s1.show();
        Student s2 = new Student();
        s2.name = "孙铭";
        s2.age = 17;
        s2.show();
    }
}

static的访问特点

非静态的成员方法

能访问静态的成员变量

能访问非静态的成员变量

能访问静态的成员方法

能访问非静态的成员方法

静态的成员方法

能访问静态的成员变量

能访问静态的成员方法

总结成一句话就是：静态成员方法只能访问静态成员

对象的初始化顺序

父类静态变量、父类静态代码块、子类静态变量、子类静态代码块、父类非静态变量(实例变量)、父类非静态代码块、父类构造器(构造方法)、子类非静态变量、子类非静态代码块、子类构造器(构造方法)
先父后子，先静态后非静态，先量再块后方法。

代码块的初始顺序

class person{
    private String name;
    static {
        System.out.println("这是静态代码块1");
    }
    {
        System.out.println("这是实例代码块")
    }
     static {
        System.out.println("这是静态代码块2");
    }
    public person (String name) {
        this.name=name;
         System.out.println("这是构造函数");
    }   
}
执行结果如下
    这是静态代码块1
    这是静态代码块2
    这是实例代码块
    这是构造函数