修饰符
1、Package包
1.1 包的概述和使用<br />其实就是文件夹，作用就是对类文件进行分类管理<br /> 包的定义格式<br />格式：package 包名; （多级包用符号"."分开）<br />范例：package com.xxx<br /> 带包的Java类编译和执行<br />手动建包：<br />按照以前的格式编译java文件 javac HelloWorld.java<br />手动建包 在E盘建立文件夹com，然后com下建立文件夹xxx<br />把class文件放到包的最里面 把HelloWorld.class文件放到com下的xxx这个文件下<br />把包执行 java com.xxx.HelloWorld<br />自动建包：<br />javac-d.HelloWorld.java java com.xxx.HelloWorld
2、导包
2.1 导包的概述和使用
使用不同包下的类时，使用的时候要写类的全路径，因为书写过多，简化操作
导包的格式
格式：import 包名；
范例：import xxx.xxx
3、修饰符
3.1 修饰符的分类
1、权限修饰符
修饰符 同一个类中 同一个包中子类无关类 不同包的子类 不同包的无关类
private √
默认(无) √ √
protected √ √ √ √
public √ √ √ √
// Zi需要使用extends关键字，继承同一包下的父类
public class Zi extends Fu{
public static void main(String[] args) {
// 调用该方法需要创建该类的对象,无参构造方法
Zi zi = new Zi();
// 没有private修饰符的Fu方法，无法调用
zi.show();
zi.show1();
zi.show3(); } }
// 同一包下的父类
public class Fu {
public void show() { System.out.println(“public”); }
void show1(){ System.out.println(“默认”); }
private void show2(){ System.out.println(“private”); }
protected void show3(){ System.out.println(“protected”); }
public static void main(String[] args) {
// 调用该方法需要创建该类的对象,无参构造方法
Fu fu = new Fu();
fu.show();
fu.show1();
fu.show2();
fu.show3(); } }
// 同一包下的公共类
public class ExtendsDemo {
public static void main(String[] args) {
// 调用该方法需要创建该类的对象,无参构造方法
Fu fu = new Fu();
// 在同一包下，即使没有继承关系也可以访问其他修饰符定义的方法
fu.show();
fu.show1();
fu.show3(); } }
——————————————————————————————————————
// 不同包下的公共类
public class Demo {
public static void main(String[] args) {
// 不同包下无关的类
Fu fu = new Fu();
// 只能访问public修饰符的方法
fu.show(); } }
// 不同包下的子类继承不同包下的父类
public class Zi extends Fu {
// 不同包下创建Zi类继承不同包的Fu类，测试哪些方法能被调用
public static void main(String[] args) {
Zi zi = new Zi();
// 只能访问public和protected修饰符的方法
zi.show();
zi.show3(); } }
3.2 状态修饰符
1、final （最终态）
final 关键字是最终的意思，可以修饰成员方法，成员变量，类
父类
// 定义类的方法被final修饰
//public class Fu { public final void show(){ System.out.println(“FU类方法”); } }
// 定义类final修饰
public final class Fu { public void show(){ System.out.println(“FU类方法”); }}
———————————————————————————————————————————
子类
// 父类被final修饰无法继承
public class Zi extends Fu{
// 成员变量被final修饰
public final int age = 20;
public void method(){
// 重新赋值age
// 如果成员变量被final修饰则不能重新赋值
// age = 100;
System.out.println(age); }
// @Override
// Fu 类定义final方法 Zi类不能重写
// public void show() { System.out.println(“Zi method”);; } }
final 修饰的特点
1、修饰方法：表示该方法是最终方法，不能被重写
2、修饰变量：表明该变量是常量，不能再次被赋值
final 修饰局部变量
变量是基本类型：final修饰指的是基本类型的数据值不能发生改变
变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以可以发生改变的
2、static（静态）
static关键字是最终的意思，可以修饰成员方法，成员变量
public class Student {
public String name;
public int age;
// 定义一个可以共享的成员变量使用static修饰符
public static String school;
public void show() { System.out.println(name + “,” + age + “,” + school); } }
————————————————————————————————————————————-
public class StaticDemo {
public static void main(String[] args) {
// 建议直接通过类名赋值给static修饰的成员变量
Student.school=”常青藤大学”;
Student student = new Student();
// 因为public修饰符,定义的引用类型可以直接调用类的成员变量
student.name = “李畅”;
student.age = 20;
// 因为成员变量被static修饰是共享的变量所以赋值一个其余都可用
// 不建议通过对象去访问被static修饰的成员变量
// student.school = “常青藤大学”;
student.show();
Student student1 = new Student();
// 因为public修饰符,定义的引用类型可以直接调用类的成员变量
student1.name = “法外狂徒”;
student1.age = 30;
// student1.school = “常青藤大学”;
student1.show(); } }
static 修饰的特点：
1、被该类的所有对象共享—>该条件也是判断是否使用静态关键字的条件
2、可以通过类名直接调用。当然也可以通过对象名调用—> 推荐使用类名调用
static 修饰的访问特点：
1、非静态成员方法—> 可以访问静态和非静态的变量和方法
2、静态成员方法 —> 只能访问静态的成员变量和方法
public class Student {
// 非静态成员变量
private String name = “李畅”;
// 静态成员变量
public static String school = “常青藤大学”;
// 非静态成员方法
public void show() { }
// 非静态成员方法—> 可以访问静态和非静态的变量和方法
public void show1() {
System.out.println(name); // 非静态成员变量
System.out.println(school);// 静态成员变量
show();// 非静态成员方法
show3();// 静态成员方法 }
// 静态成员方法
public static void show2() { }
// 静态成员方法 —> 只能访问静态的成员变量和方法
public static void show3() {
System.out.println(name); // 非静态成员变量—>error
System.out.println(school);// 静态成员变量
show();// 非静态成员方法—>error
show3();// 静态成员方法 } }
若有收获，就点个赞吧
0 人点赞
