Java学习笔记05-引入类-访问权限-static-final

快速回忆

知识讲解

5.1 引入类

        5.1.1 包

        包是java中管理类（接口等）的一个机制，用以区分名字相同的类或者将专门用于处理一种事务的工具类封装到一个包中。

        包的存储机制降低了类之间的依赖关系，提高程序代码的重用性，尽可能避免数据之间的大规模变动。

package src;

public class hello {
    public static void main(String[] args) {
        System.out.println("Hello World");
        System.out.println("锄禾日当午，\n汗滴禾下土。\n谁知盘中餐，\n粒粒皆辛苦。");
        //直角三角形
        for (int i = 1; i <= 5; i++) {
            String str = "";
            for (int j = 1; j <= i; j++) {
                str+="* ";
            }
            System.out.println(str);
        }
        //九九乘法表
        for (int i = 1; i <= 9; i++) {
            String str = "";
            for (int j = 1; j <= i; j++) {
                str += j + " * " + i + " = " + (i * j)+"\t";
            }
            System.out.println(str);
        }

    }
}

        package是声明包语句的关键字，指明该源文件定义的类所在的包。

package 包名

        包语句往往位于源文件的第一句，当包语句省略时可以认为类的源文件在当前目录中。不同包下的类在未引入前是无法使用的。

        5.1.2 import语句

        当编写的类和和方法中使用的类不在一个包时，就必须将所需类引入。import关键字可以将不同包下的类作为引入类代入当前类中。即在类初始化时将引入类加载到当前方法区中。

import 包名.类名

import java.util.Scanner;

public class print {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int num = scanner.nextInt();
        System.out.println("您输入的整数是：" + num);
    }
}

        “import java.util.Scanner;”，将scanner类作为引用类导入。

常用重要包
java.lang	所有基本语言类，一般默认导入不需要再书写
javax.swing	抽象窗口工具集中的图形、文本、窗口GUI类
java.io	所有的输入类和输出类
java.util	所有实用类
java.sql	操作数据库的类
java.net	实现网络功能的类

5.2 访问权限

         java中使用访问权限修饰符修饰权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限。

	public	protected	default	private
同一类	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

• 成员变量使用 private，隐藏细节。
• 构造方法使用 public，方便创建对象。
• 成员方法使用 public，方便调用方法。

5.3 static

        使用static关键字表示静态，static可以用来修饰的变量，方法，代码块，被修饰的成员是属于类的，而不是单单属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

类名.静态变量

类名.静态方法（）

        被static修饰后，变量和属性可以直接使用上面的写法从方法区中调用。修改值时，更改的是方法区中的内存。

 

类变量

        当 static 修饰成员变量时，该变量称为类变量。 该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

static 数据类型 变量名；

public class Ticket {
    //初始有10张票
    static int ticketNumber = 10; 
    void print(){
        System.out.println("票数剩余："+ticketNumber);
    }
}

public class testStatic {
    public static void main(String[] args) {
        Ticket t1 = new Ticket();
        Ticket t2 = new Ticket();
        Ticket ticket = new Ticket();
        t1.ticketNumber--;
        ticket.print();
        t2.ticketNumber -= 2;
        ticket.print();
        t1.ticketNumber--;
        t2.ticketNumber -= 2;
        ticket.print();
    }
    
}

        运行结果如上所示，说明三个实例中的 ticketNumber 访问的同一个变量，静态变量初始化存储在方法区，而不是堆内存。

静态方法

        当 static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。

修饰符 static 返回值类型 方法名 (参数列表){
   // 执行语句
}

public class Ticket {
    //初始有10张票
    static int ticketNumber = 10; 
    void print(){
        System.out.println("票数剩余："+ticketNumber);
    }
    static void testStatic(){
        System.out.println("票数剩余："+ticketNumber);
    }
}

public class testStatic {
    public static void main(String[] args) {
        Ticket t1 = new Ticket();
        Ticket t2 = new Ticket();
        t1.ticketNumber--;
        t2.ticketNumber -= 2;
        t1.ticketNumber--;
        t2.ticketNumber -= 2;
        Ticket.testStatic();
    }
}

        在Ticket中新增静态方法 testStatic()，不用实例化便可以直接调用。

1. 静态方法可以直接访问类变量和静态方法。
2. 静态方法只能访问静态成员。静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
3. 静态方法中，不能使用this关键字。→在main方法中不能用this关键字

静态代码块

        指在类中，方法外，使用static修饰的代码块{ }。特点是随着类的加载而执行且执行一次，优先于main方法和构造方法的执行，此处的“类的加载”指含有类变量或类方法的类被使用。

        即在java执行前先过滤一遍main中是否有着static关键字的使用，如果有，则会在main线程执行前完成静态资源的初始化。

public class 类名{
    static {
        // 执行语句
    }
}

 5.4 final

        final是常量的修饰符，被该关键词修饰的量只能赋值一次，不能再更改。除此之外它还能修饰类和方法。

final 数据类型 变量名;	只能赋值一次，且之后不能再修改
修饰符 final 返回值类型 方法名(参数列表){          //方法体  }	当本类作为父类被继承时，此方法不可重写
final class 类名{ }	被final修饰的类不可继承