面向对象（包、final、权限修饰符、代码块、抽象）-优快云博客

1.包

（1）定义

1.包就是文件夹。用来管理各种不同功能的java类，方便后期代码维护

2.包名的规则：公司域名反写+包的作用，需要全部英文小写，见名知意

3.包名+类名，称为，全类名或全限定名

（2）导包

1.两个类在使用同一包中的类时，不需要导包

2.当使用java.lang包中的类时，不需要导包

3.其他情况需要导包

4.如果同时使用两个包中的同名类，需要用全类名

2.final

（1）定义

1.当修饰方法的时候，说明该方法时最终方法，不能被重写

2.当修饰类的时候，说明该类时最终类，不能被继承

3.当修饰变量的时候，此时叫做常量，只能被赋值一次，一旦赋值就不能改变

（2）常量

1.实际开发中，常量一般作为系统的配置信息，方便维护，提高可读性

2.常量的命名规范：单个单词，全部大写；多个单词，全部大写，单词之间用下划线隔开

（3）细节

1.final修饰的变量是基本数据类型：那么变量存储的数据值不能发生改变

2.final修饰的变量是引用数据类型：那么变量存储的地址值不能发生改变，对象内部的可以改变

3.权限修饰符

（1）定义

1.权限修饰符是用来控制一个成员能够被访问的范围的

2.可以修饰成员变量，方法，构造方法，内部类

（2）分类

1.范围：private(私有)<默认/缺省(空着不写)<protected(守保护的)<public(公共)

2.private：可以在同一个类中使用

3.默认：可以在同一个类、同一个包中的其他类使用

4.protected：可以在同一个类、同一个包中的其他类、不同包下的子类使用

5.public：可以在同一个类、同一个包中的其他类、不同包下的子类、不同包下的无关类使用

（3）说明

1.在实际中，一般只用private和public，成员变量是私有，方法是公开

2.如果方法中的代码是抽取其他方法中共性代码，这个方法一般也私有

4.代码块

（1）局部代码块

1.格式：{ }

2.作用：提前结束变量的生命周期（已淘汰）

（2）构造代码块

1.格式：{ }

2.写在成员位置的代码块

3.作用：可以把多个构造方法中重复的代码抽取出来（不够灵活）

4.执行时机：在创建本类对象的时候会先执行构造代码块在执行构造方法

（3）静态代码块

1.格式：static { }

2.特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次

3.使用场景：在类加载的时候，做一些数据初始化的时候使用

（4）示例

1.局部代码块

public class Text {
    public static void main(String[] args) {

       //局部代码块
        {
            int a = 10;
            System.out.println("a = " + a);    //输出：a = 10
        }
        //   System.out.println("a =" + a);   <---错误
        
    }
}

2.构造代码块

public class Text {
    private String name;
    
    //构造代码块
    {
        System.out.println("构造代码块执行");
    }
    
    public Text(){
        System.out.println("无参构造被执行");
    }
    public Text(String name){
        this.name=name;
        System.out.println("有参构造被执行");
    }

   //测试类
    public static void main(String[] args) {

        Text t = new Text();
        Text t1 = new Text("zhangsan");
    }
}
//输出：构造代码块执行
//     无参构造被执行
//     构造代码块执行
//     有参构造被执行

3.静态代码块

public class Text {
    private String name;

    //构造代码块
     static {
        System.out.println("构造代码块执行");
    }

    public Text(){
        System.out.println("无参构造被执行");
    }
    public Text(String name){
        this.name=name;
        System.out.println("有参构造被执行");
    }

   //测试类
    public static void main(String[] args) {

        Text t = new Text();
        Text t1 = new Text("zhangsan");
    }
}
//输出：构造代码块执行
//     无参构造被执行
//     有参构造被执行

5.抽象

（1）抽象方法

1.抽象方法：将共性的行为（方法）抽取到父类之后。由于一些子类执行的内容是不一样，所以，在父类中不能确定具体的方法体。该方法就可以定义为抽象方法

2.定义格式：public abstract 返回值类型方法名(参数列表)；

（2）抽象类

1.抽象类：如果一个类中存在抽象方法，那么该类就必须声明为抽象类

2.定义格式：public abstract class 类名{ }

（3）注意事项

1.抽象类不能实例化，抽象类不能创建对象

2.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

3.抽象类可以有构造方法（当创建对象时，给属性进行赋值）

4.抽象类的子类：（1）要么重写抽象类中的所有抽象方法

（2）要么子类本身也是抽象类

（4）示例

父类：

public abstract class  Person {

    public abstract void work();
    private String name;
    private int age;

//抽象类可以有构造方法
    public Person() {}
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

子类：

public  class Student extends Person {

    public Student() {
    }

    public Student(String name, int age) {
        super(name, age);
    }

    @Override                //重写抽象类里的方法
    public void work() {

    }
}
//或者：public abstract Student extends Person {    <---如果子类本身也是抽象类就不能创建对象
//}

测试类：

public class Text {
    public static void main(String[] args) {
        Student s =new Student("xiaoming", 18);  //创建子类的对象
        System.out.println(s.getName() + "," + s.getAge());

    }
}