Java开发必备的三大修饰符
一、abstract 抽象的
抽象类：被abstract 修饰的类
语法： abstract class 类名｛｝
抽象方法 ： 被abstract 修饰的方法
定义语法：
访问修饰符 abstract 返回值类型 方法名（参数列表）；
abstract 访问修饰符 返回值类型 方法名（参数列表）；
特点：
1.当一个类中存在抽象方法 那么这个类也必须是抽象的
2.一个抽象类中可以有抽象方法也可以有非抽象方法
3.如果一个类继承了抽象类，这个类如果不想成为抽象类，那么这个类必须实现抽象类中的所有抽象方法
4.抽象类不能创建对象，但是可以声明引用，抽象类的对象是存在的，是由子类创建子类对象时调用父类构造方法创建的，是无法自己手动去new 抽象类的对象的
抽象类的好处：强制使用多态
案例：
public class Demo{
public static void main(String[] args) {
}
}
abstract class Animal{
//抽象方法
public abstract void eat();
public abstract void sleep();
public void m1() {
System.out.println("m1");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("狗吃屎");
}
public void sleep(){
System.out.println("狗睡");
}
}
案例：
public class Demo{
public static void main(String[] args) {
Animal a = new Dog();
}
}
abstract class Animal{
public Animal() {
System.out.println("动物类的构造被调用 创建了 对象");
}
//抽象方法
abstract public void eat();
public abstract void sleep();
public void m1() {
System.out.println("m1");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("狗吃屎");
}
public void sleep(){
System.out.println("狗睡");
}
}
二、static 静态的
static修饰成员变量：类变量 静态变量 静态属性
定义语法：
访问修饰符 static 数据类型 变量名 = 变量值；
static 访问修饰符 数据类型 变量名 = 变量值；
访问的方式（特点）
1.类变量可以用 类名.属性名 访问
2.可以通过创建对象 用引用去访问 （不推荐）
案例：
public class Demo{
public static void main(String[] args) {
Test t1 = new Test();
Test t2 = new Test();
t1.a++;
t1.b++;
System.out.println(t2.a);//10
System.out.println(t2.b);//21
}
}
class Test{
int a = 10;//实例变量
static int b = 20;//类变量
}
案例2:
public class Demo{
public static void main(String[] args) {
/*Test t1 = new Test();
Test t2 = new Test();
t1.a++;
t1.b++;
System.out.println(t2.a);
System.out.println(t2.b);*/
System.out.println(Test.b);//20
}
}
class Test{
int a = 10;//实例变量
static int b = 20;//类变量
}
static修饰成员方法： 静态方法
语法：
访问修饰符 static 返回值类型 方法名（形参列表）｛
方法的实现；
｝
static 访问修饰符 返回值类型 方法名（形参列表）｛
方法的实现；
｝
特点：
1.静态的方法中 不可以直接访问非静态的成员（成员变量 和 成员方法）
2.如果要访问非静态的成员 必须创建对象 通过引用取访问
3.静态方法可以通过 类名.方法名（） 访问 也可以通过引用去访问（不建议）
4.静态的方法可以被继承 静态的方法不能被非静态的方法所覆盖 只能被静态方法覆盖 但是没有多态（引用是什么类型 调用的方法就是这个类型中的方法）
5.在静态方法中是不可以使用 this 和 super 关键字 因为 this 和 super都是和对象有关的 而静态的成员和对象无关 先于对象存在
案例：关于静态方法 访问非静态的成员
public class Demo{
public static void main(String[] args) {
/*Test t1 = new Test();
Test t2 = new Test();
t1.a++;
t1.b++;
System.out.println(t2.a);
System.out.println(t2.b);*/
//System.out.println(Test.b);//20
}
}
class Test{
int a = 10;//实例变量
static int b = 20;//类变量
//静态方法
public static void m1() {
m2();
//System.out.println(a);
}
//成员方法
public void m2() {
}
}
案例：关于 静态方法的使用 和 通过引用去访问非静态的成员
public class Demo{
public static void main(String[] args) {
//Test.m1();
Test t = new Test();
t.m1();
}
}
class Test{
int a = 10;//实例变量
static int b = 20;//类变量
//静态方法
public static void m1() {
Test t = new Test();
System.out.println(t.a);
t.m2();
}
//成员方法
public void m2() {
System.out.println("m2");
}
}
案例：关于 静态方法被继承
public class Demo{
public static void main(String[] args) {
/*Dog d = new Dog();
d.eat();*/
Dog.eat();
}
}
//定义动物类
class Animal{
public static void eat() {
System.out.println("动物吃");
}
}
class Dog extends Animal{
}
案例：关于 静态方法中是否能使用 this 和 super
public class Demo{
public static void main(String[] args) {
/*Dog d = new Dog();
d.eat();*/
//Dog.eat();
/*Animal a = new Dog();
a.eat();*/
Dog.eat();
}
}
//定义动物类
class Animal{
String sex = "狗妖";
public static void eat() {
System.out.println("动物吃");
}
}
class Dog extends Animal{
/*static String name = "金毛";
static int age = 3;*/
String sex = "母";//成员变量
public static void eat() {
String sex = "公"; //局部变量
System.out.println(super.sex);
/*System.out.println(name);
System.out.println(age);
System.out.println("狗吃");*/
}
}
初始代码块：定义在类中 方法外 用于在创建对象时 和 成员变量 按照从上向下的顺序执行初始化的操作 也叫做 动态代码块
语法：
｛初始化代码块 ｝
案例：
public class Demo{
public static void main(String[] args) {
Test t = new Test();
System.out.println(t.a);
System.out.println(t.b);
System.out.println(t.c);
}
}
class Test{
int a = 10;
int c;
int b;
{//初始化属性的
c = 30;
b = 20;
}
}
static 修饰初始化代码块：静态代码块
静态代码块的作用：在类加载时 和静态的属性 按照顺序执行 为类进行初始化操作
语法：
static{
}
案例：
public class Demo{
public static void main(String[] args) {
System.out.println(Test.a);
System.out.println(Test.b);
}
}
class Test{
static int a = 20;
static{
b = 40;
}
static int b;
}
注意：静态变量 时有默认值 先进行赋默认值 再初始化
==================================================================
类加载：当jvm第一次使用一个类时 需要通过classpath 找到.class = 字节码文件
读入这个类中的信息（包名 类名 属性 方法 静态的变量 静态的方法 。。。）并保存在虚拟机中 类加载只进行一次
类加载的时机：
1.创建对象时
2.类名访问静态成员（静态属性 静态方法）
3.子类进行类加载时 会先进行父类的类加载
案例：关于 1和2 两种情况类加载
public class Demo{
public static void main(String[] args) {
//1.创建对象
//Test t = new Test();
//2. 访问静态的成员
System.out.println(Test.a);
}
}
class Test{
static int a = 20;
static{
System.out.println("父类 类加载了");
}
}
案例：关于 3 情况的类加载
public class Demo{
public static void main(String[] args) {
//创建子类的对象
//Sub s = new Sub();
System.out.println(Sub.b);
}
}
class Test{
static int a = 20;
static{
System.out.println("父类 类加载了");
}
}
class Sub extends Test{
static int b = 30;
static{
System.out.println("子类进行类加载了");
}
}
三、final 最终的
修饰变量
局部变量：final修饰的局部变量只能赋值一次 值一旦赋值不可以改变
常量的定义：
public static final double PI = 3.14159265457;
案例：
public class Demo{
public static void main(String[] args) {
int a = 20;//局部变量
final int b = 10;
a++;
b++;
System.out.println(a);
System.out.println(b);
}
}
public class Demo{
public static void main(String[] args) {
final int a ;//声明
a = 10;
a = 20;//报错
System.out.println(a);
}
}
实例变量
特点：
1.final修饰的实例变量没有默认值
2.final修饰的实例变量只能赋值一次
3.final修饰的实例变量可以在构造方法中初始化 但是要保证每个构造都必须能够为这个变量初始化
案例：
public class Demo{
public static void main(String[] args) {
Animal a = new Animal(250);
//System.out.println(a.a);//0
System.out.println(a.b);
}
}
class Animal{
/*int a = 10;//实例变量
final int b = 20;*/
int a;
final int b = 20;
public Animal(int b) {
this.b = b;
}
}
public class Demo{
public static void main(String[] args) {
Animal a = new Animal(250);
//System.out.println(a.a);//0
System.out.println(a.b);
}
}
class Animal{
/*int a = 10;//实例变量
final int b = 20;*/
int a;
final int b ;
public Animal(int b) {
this.b = b;
}
public Animal() {
b = 30;
}
}
类变量
特点：
1.final修饰的类变量没有默认值
2.final修饰的类变量可以通过静态代码块进行初始化
案例：
public class Demo{
public static void main(String[] args) {
System.out.println(Animal.a);
System.out.println(Animal.b);
}
}
class Animal{
static int a ;
final static int b ;
static{
b = 250;
}
}
修饰方法
成员方法：
特点：
1.final修饰的成员方法可以重载
2.final修饰的成员方法不可以被覆盖
语法：
public final void m1() {
}
final public void m1() {
}
案例：
public class Demo{
public static void main(String[] args) {
}
}
class Animal{
public void m1() {
System.out.println("m1");
}
}
class Dog extends Animal{
public final void m1() {
System.out.println();
}
}
静态方法：
特点：
1.final修饰的静态方法可以重载
2.final修饰的静态方法不可以被覆盖
案例：
public class Demo{
public static void main(String[] args) {
}
}
class Animal{
public final static void m1() {
System.out.println("m1");
}
public final static void m1(int a) {
System.out.println("m1");
}
}
class Dog extends Animal{
}
修饰类
语法：
final class Animal{
}
特点：final修饰的类没有子类 俗称断子绝孙类
jdk的类库中有哪些final修饰的类？
String Math System
案例：
public class Demo{
public static void main(String[] args) {
}
}
class Dog extends System{
}
四、关于修饰符混搭的原则
class Animal{
public final static void m1() {
System.out.println("m1");
}
public final static void m1(int a) {
System.out.println("m1");
}
}
class Dog extends Animal{
}
##### 修饰类
```java
语法：
final class Animal{
}
特点：final修饰的类没有子类 俗称断子绝孙类
jdk的类库中有哪些final修饰的类？
String Math System
案例：
public class Demo{
public static void main(String[] args) {
}
}
class Dog extends System{
}
五、关于修饰符混搭的原则
到此这篇关于Java开发必备的三大修饰符的文章就介绍到这了,更多相关Java三大修饰符内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！
相关推荐
-
Java import导入及访问控制权限修饰符原理解析
这篇文章主要介绍了Java import导入及访问控制权限修饰符过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一.import 1.import语句用来完成导入其他类,同一个包下的类不需要再导入 不在同一个包下需要手动导入. 2.import语法格式 import 类名: import 包名.*; //import语句需要编写到package语句之下,class语句之上. 3.java.lang.*;不需要手动引入,系统自动引入.
-
JavaSE static final及abstract修饰符实例解析
static :静态常量,静态方法,静态代码块 静态变量: 静态变量属于类的,使用类名来访问,非静态变量是属于对象的,"必须"使用对象来访问. 注意:静态变量对于类而言在内存中只有一个,能被类中所有的实例共享. 实例变量对于类的每一个实例都有一份, 它们之间互不影在加载类的过程中为静态变量分配内存,实例变量在创建对象时分配内存 所以静态变量可以使用类名来直接访问,而不需要使用对象来访问. package com.len.collection;public class PersonTes
-
Java四种访问控制修饰符知识点总结
java有四种访问控制修饰符. public protected private default(默认为空,不加任何修饰) 为了用代码对比出其中的区别,首先建立两个包,分别为area1和area2:五个类,分别是Person.PersonDemo.PersonSon.PersonTest.OutPerson. 然后Person.PersonDemo.PersonSon放在area1包下. PersonTest.OutPerson放在area2包下. 四个访问控制修饰符在同类下的代码例子: pac
-
浅谈Java中各种修饰符与访问修饰符的说明
JAVA中的类只能是public 或者package的.这是符合逻辑的:人们定义类的初衷就是为了让别人用的.倘若是private,别人怎么调用?但是有一个内部类可以被定义为private.严格上说,内部类,算不得上是一种光明正大的类,内部类在某种意义上是类这个王国里的特务和地下工作者.特务和地下工作者为王国起了不少作用,但是几乎从来不敢在公众场合抛投露面.就算要露面,也要在主人(class)的同意下,向导(Interface)的引导下,才敢战战兢兢的走出来.下面是常规的一些类的修饰符和访问修饰符
-
一文搞懂JAVA 修饰符
Java语言提供了很多修饰符,主要分为以下两类: 访问修饰符 非访问修饰符 修饰符用来定义类.方法或者变量,通常放在语句的最前端.我们通过下面的例子来说明: public class ClassName { // ... } private boolean myFlag; static final double weeks = 9.5; protected static final int BOXWIDTH = 42; public static void main(String[] argum
-
Java中常用修饰符的使用方法汇总
修饰符汇总: 一:public protected default private 修饰类,修饰方法,修饰属性,修饰代码块. 类: 顶级类只能用public 修饰,顶级类不能使用private 和protected 修饰. 外部类可以被public修饰或者默认不写,不能用private和protected. 内部类可为静态,可用protected和private修饰. 方法: 通常方法可以被四个访问修饰符修饰,构造方法也可以被四个访问修饰符修饰. 抽象类中的抽象方法不能被private修饰,可以
-
浅析java修饰符访问权限(动力节点Java学院整理)
Java有四种访问权限,其中三种有访问权限修饰符,分别为private,public和protected,还有一种不带任何修饰符: 1. private: Java语言中对访问权限限制的最窄的修饰符,一般称之为"私有的".被其修饰的类.属性以及方法只能被该类的对象访问,其子类不能访问,更不能允许跨包访问. 2. default:即不加任何访问修饰符,通常称为"默认访问模式".该模式下,只允许在同一个包中进行访问. 3. protect: 介于public 和 pri
-
关于Java中修饰符的总结(fina除外)
public/protected/private public表示公开,private表示私有,protected表示保护,什么都不写表示默认default. 方法: public protected default private √ √ √ √ 同一类中 √ √ √ × 同一包中 √ √ × × 子类中 √ × × × 不同包中 成员变量: 考虑的安全性和健壮性的问题,成员变量一般为私有,并对外提供一些public的方法修改成员变量,在修改的方法中对输入进行判断和控制. Private成员变
-
Java中的权限修饰符(protected)示例详解
前言 大部分来自:https://blog.csdn.net/justloveyou_/article/details/61672133.并在这个博客的基础上,加上了自己的一些理解. 权限控制表 修饰词 本类 同一个包的类 继承类 其他类 private √ × × × 无(默认) √ √ × × protected √ √ √ × public √ √ √ √ 关于protected 最近在看Effective Java时,遇到了一个关于protected修饰符的问题.这个问题中,对于它的认识
-
Java访问修饰符原理及代码解析
一.概述 访问等级比较:public > protected > default > private 无论是方法还是成员变量,这四种访问权限修饰符作用都一样 public:不管包外包内,所有类(子类+非子类)均可使用 protected 包内:所有类可使用 包外:子类可使用,非子类不可使用 default 包内:所有类可使用 包外:所有类不可使用 private:仅本类可使用 二.示例代码 Test包内的父类Permission public class Permission { pri