纯净、安全、绿色的下载网站

首页|软件分类|下载排行|最新软件|IT学院

当前位置:首页IT学院IT技术

Java三大修饰符 Java开发必备的三大修饰符

北夷烟雪江中雨   2021-06-02 我要评论
想了解Java开发必备的三大修饰符的相关内容吗,北夷烟雪江中雨在本文为您仔细讲解Java三大修饰符的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Java修饰符用法,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{
    
}

五、关于修饰符混搭的原则

在这里插入图片描述

在这里插入图片描述


相关文章

猜您喜欢

  • 小程序wx.getUserProfile接口 小程序wx.getUserProfile接口的具体使用

    想了解小程序wx.getUserProfile接口的具体使用的相关内容吗,空如夏沐在本文为您仔细讲解小程序wx.getUserProfile接口的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:小程序wx.getUserProfile接口,小程序wx.getUserProfile,下面大家一起来学习吧。..
  • Java回溯算法解数独 教你怎么用Java回溯算法解数独

    想了解教你怎么用Java回溯算法解数独的相关内容吗,趋向_quxiang在本文为您仔细讲解Java回溯算法解数独的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Java回溯算法,java数独,下面大家一起来学习吧。..

网友评论

Copyright 2020 www.hao45.cc 【好下载】 版权所有 软件发布

声明:所有软件和文章来自软件开发商或者作者 如有异议 请与本站联系 点此查看联系方式