目录
一、包
二、权限修饰符
1、private
2、无修饰符
3、prtected
4、public
三、final
1、修饰类
2、修饰方法
3、修饰变量
四、常量
五、枚举
六、抽象
七、接口
1、被实现
2、多继承
3、默认方法
4、静态方法
5、私有方法
一、包
package javase;
（1）相同包下的类可以直接访问，不同包下的类必须导包才能使用 import.包名.类名;
package javase;
import java.Name;
public class Test {
Name n = new Name();
}
（2）类中使用不同包下的相同类名，默认只能导入一个类的包，另一个类要使用全名访问
package java1;
public class Name {
}
package java2;
public class Name {
}
package javase;
import java1.Name;
public class Test {
Name n1 = new Name();
java2.Name n2 = new java2.Name();
}
二、权限修饰符
控制能够被访问的范围，作用范围从小到大：private > 无修饰符 > protected > public
1、private
同一个类中
2、无修饰符
同一个类中、同一个包中其他类
3、prtected
同一个类中、同一个包中其他类、不同包下的子类
4、public
同一个类中、同一个包中其他类、不同包下的子类、不同包下的无关类
（1）不同包下的子类（需使用子类的构造器）
package javase;
public class Test {
protected void protectedrun(){
}
public void publicrun(){
}
}
package java1;
import javase.Test;
public class Test1 extends Test {
public static void main(String[] args) {
Test1 t = new Test1();
t.protectedrun();
t.publicrun();
}
}
（2）不同包下的无关类
package javase;
public class Test {
public void publicrun(){
}
}
package java2;
import javase.Test;
public class Test2 {
public static void main(String[] args) {
Test t = new Test();
t.publicrun();
}
}
三、final
1、修饰类
该类是最终类，不能被继承
final class father{
}
class son extends father{ //报错
}
2、修饰方法
该方法是最终方法，不能被重写
class father{
public final void run(){
System.out.println(1);
}
}
class son extends father{
@Override
public void run() { //报错
super.run();
}
}
3、修饰变量
该变量第一次被赋值后，不能再次被赋值
（1）修饰的变量是基本类型，数据值不能改变
修饰局部变量
public class Test {
public static void main(String[] args) {
final int n = 1;
n = 2; //报错
}
}
修饰静态成员变量
public class Test {
public static final int n = 1;
public static void main(String[] args) {
n = 2; //报错
}
}
修饰实例成员变量
public class Test {
private final int n = 1;
public static void main(String[] args) {
Test t = new Test();
t.n = 2; //报错
}
}
（2）修饰的变量是引用类型 ，地址值不能改变，地址指向的对象内容可以发生变化
public class Test {
public static void main(String[] args) {
final Numbers n1 = new Numbers();
n1 = null; //报错
}
}
class Numbers{
private int number;
}
四、常量
使用 public static final 修饰的成员变量，必须有初始化值，其值不能改变
命名规范：英文单词全部大写，多个单词用下划线连接起来
public class Test {
public static final int NUMBER = 1;
public static void main(String[] args) {
System.out.println(NUMBER);
}
}
五、枚举
定义枚举类：修饰符 enum 枚举名称{}
（1）枚举类都是继承了枚举类型：java.lang.Enum
（2）枚举类都是最终类，不可被继承
（3）构造器都是私有的，对外不能创造对象
（4）枚举类的第一行默认都是罗列枚举对象的名称
六、抽象
abstract
修饰类：一般作为父类，让子类来继承
修饰方法：抽象方法只有方法签名，不能写方法体代码
（1）类有的，抽象类中都有
（2）抽象类中不一定有抽象方法，但有抽象方法的必须是抽象类
（3）一个类继承了抽象类，那这个类必须重写完抽象类的全部抽象方法，否则这个类必须被定义成抽象类
（4）抽象类不能够创造对象
public abstract class Test1 {
public abstract void run();
}
public class Test2 extends Test1{
@Override
public void run() {
}
}
七、接口
public interface 接口名{ 常量 抽象方法 }
public interface face {
public static final int number = 1;
public abstract void run();
}
接口中体现一种规范，规范默认都是公开的，public static final和public abstract可以省略不写
public interface face {
int number = 1;
void run();
}
1、被实现
修饰符 class 实现类 implements 接口,接口....{}
接口不能创建对象，是用来被类实现的，可以被类单实现，也可以被类多实现
一个类实现接口，那这个类必须重写完全部接口的全部抽象方法，否则这个类必须被定义成抽象类
实现接口的类为实现类，实现类可以理解为所谓的子类
public interface face1 {
void run();
}
public interface face2 {
void walk();
}
public class Test{
public static void main(String[] args) {
Abc a = new Abc();
a.run();
a.walk();
}
}
class Abc implements face1,face2 {
@Override
public void run() {
System.out.println(1);
}
@Override
public void walk() {
System.out.println(2);
}
}
一个类实现了多个接口，多个接口中存在同名方法，不冲突，这个类重写方法即可
class Face implements face1,face2{
@Override
public void run() {
}
}
interface face1{
default void run(){
System.out.println(1);
}
}
interface face2{
default void run(){
System.out.println(2);
}
}
一个类继承了父类，同时又实现了接口，父类和接口中有同名方法，默认用父类的
public class Test{
public static void main(String[] args) {
Son s = new Son();
s.run();
}
}
class Son extends Father implements face{
}
class Father{
public void run(){
System.out.println(1);
}
}
interface face{
default void run(){
System.out.println(2);
}
}
2、多继承
public interface 接口1 extends 接口2,接口3....{}
整合多个接口为一个接口，便于子类的实现
public interface face1{
void run();
}
public interface face2 extends face1{
void walk();
}
public class Test{
public static void main(String[] args) {
Abc a = new Abc();
a.run();
a.walk();
}
}
class Abc implements face2{
@Override
System.out.println(1);
}
@Override
public void walk() {
System.out.println(2);
}
}
一个接口继承多个接口，如果多个接口中出现规范冲突则不能继承
interface face extends face1,face2{ //报错
}
interface face1{
int run();
}
interface face2{
void run();
}
3、默认方法
用default修饰，默认用public修饰（可以省略不写）
接口不能创建对象，方法过继给实现类，由实现类的对象调用
public interface face{
default void run(){
System.out.println(1);
}
}
public class Test{
public static void main(String[] args) {
Abc a = new Abc();
a.run();
}
}
class Abc implements face{
}
4、静态方法
用static修饰，默认用public修饰（可以省略不写）
接口的静态方法，必须接口名自己调用
public interface face{
static void run(){
System.out.println(1);
}
}
public class Test{
public static void main(String[] args) {
Abc a = new Abc();
face.run();
}
}
class Abc implements face{
}
一个类实现多个接口，多个接口中有同样的静态方法不冲突
class face implements face1,face2{
public static void main(String[] args) {
face1.run();
face2.run();
}
}
interface face1{
public static void run(){
System.out.println(1);
}
}
interface face2{
public static void run(){
System.out.println(2);
}
}
5、私有方法
用private修饰
只能在借口内部被调用
public interface face1 {
default void run1(){
System.out.println(1);
run2();
}
private void run2(){
System.out.println(2);
}
}
public class Test{
public static void main(String[] args) {
Abc a = new Abc();
a.run1();
}
}
class Abc implements face1{
}
