java中的访问控制符、构造器、this、super、final关键字、代码块总结

最新推荐文章于 2022-07-18 15:10:01 发布

麦麦麦迪

最新推荐文章于 2022-07-18 15:10:01 发布

阅读量269

点赞数 1

分类专栏： java基础学习笔记文章标签：访问控制符构造器 this super final

本文链接：https://blog.csdn.net/qq_34602408/article/details/78935408

版权

java基础学习笔记专栏收录该内容

21 篇文章 2 订阅

订阅专栏

1访问控制符

Java提供了3个访问控制符：private、protected、public，分别代表了3个访问控制级别，另外还有一个不加任何访问控制符的的访问控制级别。

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

Private：表示私有的，表示类访问权限。只能在本类中访问，离开本类之后就不能访问；
Default（缺省）：表示包私有，表示包访问权限，访问者的包必须和当前类的包相同才行；

Protected：表示子类访问权限，同包中的可以访问，即使不同包，但有继承关系也可以访问；

Public：全局的，公共的访问权限，在项目的任何地方都可以访问。

访问控制符使用原则：

1)类里的绝大部分成员变量都应该使用private修饰，只有一些static修饰的、类似全局变量的成员变量，才可能考虑使用public修饰。除此之外，有些方法只用于辅助实现该类的其他方法，这些方法被称为工具方法，工具方法也应该使用private修饰。

2)如果某个类主要用做其他类的父类，该类里包含的大部分方法可能仅希望被其子类重写，而不想被外界直接调用，则应该使用protected修饰这些方法。

3)希望暴露出来给其他类自由调用的方法应该使用public修饰。因此，类的构造器通过使用public修饰，从而允许在其他地方创建该类的实例。因为外部类通常都希望被其他类自由使用，所有大部分外部类都使用public修饰。

2.包的声明与访问

2.1 包的概念

java的包，其实就是文件夹，包里存放的是类文件。当类文件很多的时候，通常我们会采用多个包进行存放管理他们，这种方式称为分包管理。

类中声明的包必须与实际class文件所在的文件夹情况相一致，即类声明在a包下，则生成的.class文件必须在a文件夹下，否则，程序运行时会找不到类。

2.2 包的声明格式

通常使用公司网址反写，可以有多层包，包名采用全部小写字母，多层包之间用”.”连接

类中包的声明格式：

package 包名.包名.包名…;

注意：声明包的语句，必须写在程序有效代码的第一行（注释不算），即在声明包package后，定义所有类class前，使用导包import包名.包名.类名;

2.3 包的访问

在访问类时，为了能够找到该类，必须使用含有包名的类全名（包名.类名）。

包名.包名….类名

如：java.util.Scanner

java.util.Random

带有包的类，创建对象格式：包名.类名变量名 = new包名.类名();

前提：包的访问与访问权限密切相关，这里以一般情况来说，即类用public修饰的情况。

2.4 import导包

通过import导包的方式可以使用该类，可以避免使用全类名编写（即，包类.类名）。

导包的格式：import 包名.类名;

import的作用：使用import可以省略写包名；（使用import static可以连类名都省略）

Java默认为所有源文件导入java.lang包下所有类，因此在java程序中使用String、System类时都无需使用import语句来导入这些类。

2.5 java的常用包

java.lang:该包下包含了java语言的核心类，如String、Math、System类等。使用这个包下的类无需使用import语句导入，系统会自动导入这个包下所有类；

java.util:该包下包含了java的大量工具类/接口和集合框架类/接口，如Arrays和List 、Set等；

java.net:该包下包含了一些java网络编程相关的类/接口；

java.io:该包下包含了一些java输入输出编程相关的接口/类；

java.text:该包下包含了一些java格式化相关的类；

java.sql:该包下包含了java进行JDBC数据库编程的相关类/接口；

java.awt:该包下包含了抽象窗口工具集的相关类/接口；

java.swing:该包下包含了Swing图形用户界面编程的相关类/接口。

3.构造器

3.1构造器概述

构造器是一个特殊的方法，这个特殊的方法用于创建对象和初始化对象数据。

构造方法的格式：

修饰符构造方法名(参数列表)

{

}

3.2构造器的特点:

类都有一个默认构造器,当不显示的定义构造器的时候,编译器会在编译的时候,提供一个默认构造器.

1):构造器的名字必须和当前所在类的类名相同.

2):不需要定义返回值类型,更加不能使用void作为返回.构造器的目的在于创建和返回当前类的对象,即使要编写返回类型,也应该是当前类名,如:Student Student(){}, 既然和当前类名相同,就规定统统省略.

3):构造器中不需要使用return来返回当前构造的对象.

3.3默认构造器:

1):无参数,无方法体.

2):构造器的访问修饰符和当前类的修饰符相同(是否有public).

3):一旦在类中显示地提供了构造器,则默认的构造器就不再提供了.

一个类至少有一个构造器(即使没有自定义,编译器也会创建一个默认的).但一旦程序员提供了自定义的构造器，系统就不再提供默认的构造器。

3.4方法重载与构造器重载的区别

方法的重载:在同一个类中,方法同名,但是参数列表不同.解决了相同的功能方法,因为参数列表不同,而带来参数名不同的问题.

构造器重载:不同类的构造器是不相同的. 对于构造器重载来说,肯定是在同一个类中,并且构造器都是和类名相同.所以在同一个类中的多个构造器就必须参数列表不同 (参数类型,参数个数,参数顺序).

为了在构造器中调用另一个构造器的初始化代码，又不会重新创建一个java对象，可以使用this关键字来调用相应的构造器。使用this调用另一个重载的构造器只能在构造器中使用，而且必须作为构造器执行体的第一条语句。使用this调用重载的构造器时系统会根据this后括号里的实参来调用形参列表与之对应的构造器。

4.this关键字

4.1 this概述

this表示当前对象。当一个对象创建之后,JVM会分配一个引用自身的引用:this

this主要存在的两个位置:

构造器中: 表示当前创建的对象.

方法中: 哪一个对象调用this所在的方法,那么此时this就表示哪一个对象.

4.2 this调用构造方法

构造方法之间的调用，可以通过this关键字来完成。构造方法调用格式：this(参数列表);

构造方法的调用

    class Person {
         //Person的成员属性
         privateint age;
         privateString name;
         //无参数的构造方法
         Person(){
         }
         //给姓名初始化的构造方法
         Person(Stringnm) {
                  name= nm;
         }
         //给姓名和年龄初始化的构造方法
         Person(Stringnm, int a) {
                  //调用其他构造方法，需要通过this关键字来调用
                  this(nm);
                  //给年龄初始化
                  age= a;
         }
    }

4.3 成员变量和局部变量同名问题

当在方法中出现了局部变量和成员变量同名的时候，那么在方法中可以在成员变量名前面加上this.来区别成员变量和局部变量

   class Person {
         privateint age;
         privateString name;
 
         //给姓名和年龄初始化的构造方法
         Person(Stringname, int age) {
                  this.name= name;
                  this.age= age;
         }
 
         publicvoid speak() {
                  System.out.println("name="+ this.name + ",age=" + this.age);
         }
    }
 
    class PersonDemo {
         publicstatic void main(String[] args) {
                  Personp = new Person("薛之谦", 32);
                  p.speak();
         }
    }

对于static修饰的方法而言，可以使用类来直接调用该方法，如果在static修饰的方法中使用this关键字，则这个关键字就无法指向合适的对象。所以static修饰的方法中不能使用this引用。

5.super关键字

5.1 super概述

Super是java提供的一个关键字，super用于限定该对象调用它从父类继承得到的实例变量或方法。正如this不能出现在static修饰的方法中一样，super也不能出现在static修饰的方法中。如果在构造器中使用super，则super用于限定该构造器初始化的是该对象从父类继承得到的实例变量，而不是该类自己定义的实例变量。

如果子类里没有包含和父类同名的成员变量，那么在子类实例方法中访问该成员变量时，则无须显式使用super或父类名作为调用者。如果在某个方法中访问名为a的成员变量，但没有显式指定调用者，则系统查找a的顺序为：

1)查找该方法中是否有名为a的局部变量；

2)查找当前类中是否包含名为a的成员变量；

3)查找a的直接父类中是否包含名为a的成员变量，依次上溯a的所有父类，直到java.lang.Object类，如果最终不能找到名为a的成员变量，则系统出现编译错误。

5.2子父类中构造方法的调用

在创建子类对象时，父类的构造方法会先执行，因为子类中所有构造方法的第一行有默认的隐式super();语句。

格式：

调用本类中的构造方法

this(实参列表);

调用父类中的空参数构造方法

super();

调用父类中的有参数构造方法

super(实参列表);

子类会继承父类中的内容，所以子类在初始化时，必须先到父类中去执行父类的初始化动作，然后才可以使用父类中的内容。

当父类中没有空参数构造方法时，子类的构造方法必须有显示的super语句，指定要访问的父类有参数构造方法。

示例：

public class Test {
    publicstatic void main(String[] args) {
        newZi();
    }
   
}
class Fu{
    int num ;
    Fu(){
        System.out.println("Fu构造方法"+num);
        num =4;
    }
}
class Zi extends Fu{
    Zi(){
        //super(); 调用父类空参数构造方法
        System.out.println("Zi构造方法"+num);
    }
}

执行结果：　　

Fu构造方法0

　　 Zi构造方法4

5.3子类对象创建过程的细节

使用super调用父类构造器和使用this调用构造器很像，区别在于super调用的是其父类的构造器，而this调用的是同一个类中重载的构造器。因此，使用super调用父类构造器也必须出现在子类构造器执行体的第一行，所以super调用和this调用不会同时出现。

不管是否使用super调用来执行父类构造器的初始化代码，子类构造器总会调用父类构造器一次。子类构造器调用父类构造器分如下情况：

(1)子类构造器执行体的第一行使用super显式调用父类构造器，系统将根据super调用里传入的实参列表调用父类对应的构造器。

(2)子类构造器执行体的第一行代码使用this显式调用本类中重载的构造器，系统将根据this调用里传入的实参列表调用本类中的另一个构造器。执行本类中另一个构造器时即会调用父类构造器。

(3)子类构造器执行体中既没有super调用，也没有this调用，系统将会在执行子类构造器之前，隐式调用父类无参数构造器。

注意：

1)类中的构造方法默认第一行都有隐式的super()语句，在访问父类中的空参数构造方法。所以父类的构造方法既可以给自己的对象初始化，也可以给自己的子类对象初始化。

2)如果默认的隐式super()语句在父类中没有对应的构造方法，那么必须在构造方法中通过this或者super的形式明确要调用的构造方法。

6.static关键字

static关键字是静态修饰符，一般用来修饰类中的成员。

6.1static特点

(1)被static修饰的成员变量属于类，不属于这个类的某个对象。（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）

class Demo {
         publicstatic int num = 100;
}
 
class Test {
         publicstatic void main(String[] args) {
                  Demod1 = new Demo();
                  Demod2 = new Demo();
                  d1.num= 200;
                  System.out.println(d1.num);//结果为200
                  System.out.println(d2.num);//结果为200
         }
}

(2)被static修饰的成员可以并且建议通过类名直接访问。

访问静态成员的格式：

类名.静态成员变量名

类名.静态成员方法名(参数)

对象名.静态成员变量名

对象名.静态成员方法名(参数)

class Demo {
         //静态成员变量
         publicstatic int num = 100;
         //静态方法
         publicstatic void method(){
                  System.out.println("静态方法");
         }
}
class Test {
         publicstatic void main(String[] args) {
                  System.out.println(Demo.num);
                  Demo.method();
         }
}

static注意事项:

(1) 静态内容是优先于对象存在，只能访问静态，不能使用this/super。静态修饰的内容存于静态区。

(2)同一个类中，静态成员只能访问静态成员

(3)main方法为静态方法仅仅为程序执行入口，它不属于任何一个对象，可以定义在任意类中。

6.2定义静态常量

开发中，我们想在类中定义一个静态常量，通常使用public static final修饰的变量来完成定义。此时变量名用全部大写，多个单词使用下划线连接。

定义格式：

publicstatic final 数据类型变量名 = 值;

如下演示：

classCompany {

public static final String COMPANY_NAME= "演员";

public static void method(){

System.out.println("我好像在哪见过你");

}

当我们想使用类的静态成员时，不需要创建对象，直接使用类名来访问即可。

注意：

接口中的每个成员变量都默认使用public static final修饰。

所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值。可以直接用接口名访问。

interfaceInter {

public static final int COUNT = 100;

}

访问接口中的静态变量

Inter. COUNT

7.final关键字

final可用于修饰类、变量和方法。Final修饰变量时，表示该变量一旦获得了初始值就不可被改变，final既可以修饰成员变量（包括类变量和实例变量），也可以修饰局部变量、形参。

7.1final的特点

(1) final修饰类不可以被继承，但是可以继承其他类。

class Y {}

final class Fu extendsY{} //可以继承Y类

class Zi extends Fu{} //不能继承Fu类

(2)final修饰的方法不可以被覆盖,但父类中没有被final修饰方法，子类覆盖后可以加final。

class Fu {

// final修饰的方法，不可以被覆盖，但可以继承使用

public final void method1(){}

public void method2(){}

}

class Zi extends Fu {

//重写method2方法

public final void method2(){}

}

(3)final修饰的变量称为常量，这些变量只能赋值一次。

final int i = 20;

i= 30; //赋值报错，final修饰的变量只能赋值一次

(4)引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改。

final Person p = new Person();

Person p2 = newPerson();

p = p2; //final修饰的变量p，所记录的地址值不能改变

p.name = "小明";//可以更改p对象中name属性值

p不能为别的对象，而p对象中的name或age属性值可更改。

(5)修饰成员变量，需要在创建对象前赋值，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值。)

class Demo {

//直接赋值

finalint m= 100;

//final修饰的成员变量，需要在创建对象前赋值，否则报错。

finalint n;

publicDemo(){

//创建对象时所调用的构造方法中，为变量n赋值

n = 2018;

}

7.2 不可变类

不可变类指的是创建该类实例后，该实例的实例变量是不可改变的。Java提供的8个包装类和java.lang.String类都是不可变类。如果需要创建自定义的不可变类，可遵守如下规则：

(1)使用private和final修饰符来修饰该类的成员变量；

(2)提供带参数的构造器，用于根据传入参数来初始化类里的成员变量；

(3)仅为该类的成员变量提供getter方法，不要为该类的成员提供setter方法，因为普通方法无法修改final修饰的成员变量；

(4)如果有必要，重写Object类的hashCode和equals方法。

总结：

(1)final修饰的成员变量一旦有了初始值就不能被重新赋值，如果既没有在定义成员变量时指定初始值，也没有在初始化块、构造器中为成员变量指定初始值，那么这些成员变量的值将由系统默认指定(java语法规定：final修饰的成员变量必须由程序员显式的指定初始值)；

(2)final修饰局部变量时既可以在定义时指定初始值，也可以不指定初始值。如果final修饰的局部变量在定义时没有指定默认值，则在后面代码中可以为该final变量赋初始值，但只能一次，不能重复赋值；

(3)当使用final修饰基本类型变量时，不能对基本类型变量重新赋值，但对引用类型变量而言，它保存的仅仅是个引用，final只保证这个引用类型变量所引用的地址不会改变，即一直引用同一个对象，但这个对象完全可以改变；

8.代码块

8.1局部代码块

局部代码块是定义在方法或语句中

特点：

(1)以”{}”划定的代码区域，此时只需要关注作用域的不同即可

(2)方法和类都是以代码块的方式划定边界的

8.2构造代码块

构造代码块是定义在类中成员位置的代码块

特点：

(1)优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作

(2)每创建一个对象均会执行一次构造代码块。

8.3静态代码块

静态代码块是定义在成员位置，使用static修饰的代码块。

特点：

(1) 它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。

(2)该类不管创建多少对象，静态代码块只执行一次。

(3) 可用于给静态变量赋值，用来给类进行初始化。

麦麦麦迪

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录