首页 > 其他分享> 文章详细

面向对象进阶

2022-07-15 23:00:18 阅读：85 来源： 互联网

标签：name age System 面向对象 Student println public 进阶

包、final、权限修饰符、代码块

包

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

包名的规则：公司域名反写+包的作用,需要全部英文小写,见名知意 package com.he.domain;

使用其他类的规则:

使用其他类时,需要使用全类名

import com.he.domain.Student;//导包
public class Test{
    public static void main(String[] args){}
        //com.he.domain.Student s = new com.he.domain.Student();过于繁琐
    Studnet s = new Student();
    }
}

使用同一个包中的类时,不需要导包

使用java.lang包中的类时,不需要导包

其他情况都需要导包

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

public class Test {
    public static void main(String[] args) {
        //同一个包中的类不需要导包
//        Student s = new Student();
//        s.setName("何况是");
//        s.setAge(11);
//        System.out.println(s.getName()+"  "+s.getAge());

        //使用java.lang包中的类时也不需要导包
//        String s1 = "abc";
//        System.out.println(s);

        //使用其他包需要导包
//       Teacher t = new Teacher();
//        t.setName("也是") ;
//        t.setAge(22);
//        System.out.println(t.getName()+"  "+t.getAge());

        //使用两个包中的同名类时，需要使用全类名
        com.he.domain1.Teacher t = new  com.he.domain1.Teacher();
        com.he.domain2.Teacher t2 = new com.he.domain2.Teacher();
    }
}

final

最终的、不可被改变的

可以用来修饰方法,类,变量

方法:表示该方法是最终方法,不能被重写

类:表示该类是最终类,不能被继承

变量:叫做常量,只能被赋值一次

public class Test {
    public static void main(String[] args) {
        final int a = 10;//常量不能修改,必须赋值
        System.out.println(a);
    }
}
final class Fu{
    public final void show(){
        System.out.println("父类的show方法");
    }
}
//被final修饰的类不能被继承,使用环境和方法同理
//class Zi extends Fu{
    //被final修饰的方法不能被重写,常被用类定义不可被修改的规则
//    @Override
//    public void show() {
//        System.out.println("子类的show方法");
//    }
//}

常量

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

常量的命名规范:

单个单词:全部大写

多个单词:全部大写,单词之间用下划线隔开

细节：

final修饰的变量是基本类型:那么变量存储的数据值不能方式改变

final修饰的变量是引用类型:那么变量存储的地址值不能方法改变,对象内部的可以改变

public class Test {
    public static void main(String[] args) {
        /*
        核心:
            常量记录的数据是不能发生改变的
            
        字符串是不可变的
         */
        final double PI=3.14;
        final Student s = new Student("何况是",11);
        //记录的地址值不能发生改变,内部的属性值还是可以改变的
//        s=new Student();
        s.setName("也是");
        s.setAge(12);
        System.out.println(s.getName()+"   "+s.getAge());

        //数组:记录的是地址值
        final int[] ARR ={1,2,3,5,6};
//        ARR = new int[];
        ARR[2]=22;
        for (int i = 0; i < ARR.length; i++) {
            System.out.println(ARR[i]);
        }
    }
}

权限修饰符

是用来控制一个成员能够被访问的范围的

可以修饰成员变量,方法,构造方法,内部类

分类

有四种作用范围由小到大(private<空着不写(缺省/默认)<protected<public)

修饰符	同一个类中	同包不同类	不同包子类	不同包不同类
private	√
空着不写	√	√
protected	√	√	√
public	√	√	√	√

使用规则

实际开发中,一般只用priva和public

成员变量私有

方法公开

特例：如果方法中的代码是抽取其他方法中共性的代码,这个方法一般也私有

代码块

局部代码块

用完之后接着回收(一次性用品),主要用途为节省内存,现在不需要,提取结束变量的生命周期(已淘汰)

构造代码块

抽取构造方法中的重复代码(不够灵活)

public class Student {
    private String name;
    private int age;
    //构造代码块:
    //1.写在成员位置的代码块
    //2.作用:可以吧多个构造方法中重复的代码抽取出来
    //3.执行时机:我们在创建本类对象的时候会先执行构造代码块在执行构造方法
    //渐渐淘汰了 
    {
        System.out.println("开始创建对象");
    }
    public Student(String name, int age) {
        System.out.println("有参对象");
        this.name = name;
        this.age = age;
    }
    public Student() {
        System.out.println("空参对象");
    }
    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 CodeBlockDemo1 {
    public static void main(String[] args) {
        Student s = new Student();//空参对象
        Student s2 = new Student("何况是",22);//有参对象
    }
}

静态代码块

格式：static{}

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

使用场景:在类加载的时候,做一些数据初始化的时候使用

public class Student {
    private String name;
    private int age;

    //执行时间:
    //随着类的加载而加载,并且只执行一次
    static{
        System.out.println("静态代码块执行了");
    }
    public Student() {
        System.out.println("空参构造");
    }

    public Student(String name, int age) {
        System.out.println("有参构造");
        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;
    }
}

标签：name,age,System,面向对象,Student,println,public,进阶
来源： https://www.cnblogs.com/kuangshihe/p/16483044.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9