精华内容
下载资源
问答
  • 抽象类可以用private修饰吗
    千次阅读
    2021-06-18 23:34:22

    不可以,抽象方法存在的目的就是被子类重写,而private的方法是不能被子类重写的,所以不能修饰

    不可以,抽象方法存在的目的就是被子类重写,而static的方法是不能被子类重写的,所以不能修饰

    不可以,抽象方法存在的目的就是被子类重写,而final的方法是不能被子类重写的,所以不能修饰

    更多相关内容
  • 一、抽象类(abstract) 具备某种对象的特征,但不完整。 程序中的抽象类 像是一个模板,供其他类继承使用,但同时定义的一些抽象方法,子类必须实现 无法被实例化,只能被继承 类里面的内容和普通类区别在于...

    一、抽象类(abstract)

    具备某种对象的特征,但不完整。

    • 程序中的抽象类
      像是一个模板,供其他类继承使用,但同时定义的一些抽象方法,子类必须实现
    • 无法被实例化,只能被继承
    • 类里面的内容和普通类区别在于,它可以些抽象方法
    • 里面可以有抽象方法(也可以没有),
      抽象方法的作用,是继承该抽象类的类,必须实现这些抽象方法,这就是抽象类的主要作用

    抽象类头里必须带着abstract,就是说abstract class 类名

    //Animal抽象类
    public abstract class Animal {
        String breed;
        int age;
        //抽象方法
        public abstract void eat();
        
        public abstract void run();
    }
    
    //继承Animal抽象类
    public class Dog extends Animal{
        @Override
        public void eat() {
            System.out.println("狗在吃");
        }
    
        @Override
        public void run() {
            System.out.println("狗在跑");
        }
    }
    //如果不吧抽象方法重写完,他会报错
    

    普通类:你和我都是类吧

    抽象类:嗯,但我不能被实例化,我的作用只是用来继承

    普通方法:你说你定义的抽象方法必须被,我找普通方法也可以啊,重写一下方法谁不会啊。

    抽象类:但你往往会忘记重写方法,而直接调用父类的方法了,你明明不是狮子却用了狮子类的方法,所以我必须这样规定好,不自己写等着报错吧

    1.2 abstract修饰符修饰类里的各种元素

    1.2.1修饰类名

    这是抽象类必须有的,只有abstract修饰过的类名才叫抽象类,才能些抽象方法

    public abstract class Animal {
    }
    
    1.2.2 修饰构造方法

    抽象类能修饰构造方法吗?

    答案是不能

    public abstract class Animal {
        abstract Animal(){    //报错
            System.out.println("我是动物");
        }
    }
    //报错抽象类不能修饰构造方法
    
    1.2.3 修饰成员属性与方法

    属性
    抽象类能修饰属性吗?
    不能,很显然修饰属性没有意义。

    方法
    抽象类主要作用就是抽象方法,抽象方法不能写函数体(不能有内容),继承抽象类的子类必须重写抽象方法

    public abstract class Animal {
        //这就是没有方法体
        public abstract void eat();
    
        public abstract void run();
    }
    
    1.2.4构造块(了解)

    abstract不能修饰构造块

    总结:(除了开头需要定义为抽象类)abstract只能修饰方法

    二、static(静态)

    static修饰的属性与方法,代表为静态的,是属于类的,而不是属于对象的,在类写完时候就加载完了

    静态就是无需实例化即可以使用的,动态是实例化之后才能使用的。

    public class Utile {
        static String name = "静态类";
        
        static void method(){
            System.out.println("我是静态方法");
        }
    }
    
    public class TestUtile {
        public static void main(String[] args) {
            //调用属性
            System.out.println(Utile.name);
            //调用方法
            Utile.method();
        }
    }
    结果:
    静态类
    我是静态方法
    

    可以看到无需实例化,即可直接调用

    • 调用静态方法
      类名.方法名()
    • 调用静态属性
      类名.属性

    2.2静态属性与方法

    属性
    上面说静态属性和方法是属于类的,刚刚就证明了,无需实例化即可使用,但如果我实例化后对他们进行修改呢?

    实例化后把上面的静态属性改了

    public class TestUtile {
        public static void main(String[] args) {
            //实例化类后修改属性
            Utile utile = new Utile();
            utile.name = "hello world";
    
            //实例化多个Utile类
            Utile utile1 = new Utile();
            System.out.println(utile1.name);
            Utile utile2 = new Utile();
            System.out.println(utile2.name);
        }
    }
    结果:
    hello world
    hello world
    

    可以看到静态改了,后面全部都改了

    2.3继承的方法和属性

    怎么才能使其方法修改呢?继承重写

    但事实上,静态方法并没有继承这说法,来看看下面的吧

    public class Utile {
        static String name = "静态类";
    
        static void method(){
            System.out.println("我是静态方法");
        }
    }
    
    
    //继承了上面的
    public class ChangeUtile extends Utile{
     	static String name = "继承后的类";
     	
        static void method(){
            System.out.println("修改后的方法");
        }
    }
    
    public class TestUtile {
        public static void main(String[] args) {
            Utile.method();
            ChangeUtile.method();
            System.out.println("---------------------");
            System.out.println("Utile.name:"+Utile.name);
            System.out.println("ChangeUtile.name:"+ChangeUtile.name);
        }
    }
    
    结果:
    我是静态方法
    修改后的方法
    ---------------------
    Utile.name:静态类
    ChangeUtile.name:继承后的类
    

    可以看到,静态方法和属性没有重写,不会重叠了不会影响父类

    但是,如果不取重写

    public class demo2 {
        public static void main(String[] args) {
            Cat cat = new Cat();
            cat.say = "我是猫";
    
            System.out.println(Animal.say);
        }
    }
    
    class Animal{
        static String say = "hello,我是动物";
    }
    class Cat extends Animal{}
    结果:
    我是猫
    

    也就是说,子类继承了父类的static值,子类继承的static改变了,父类的也改变了!!!

    2.3静态方法里的结构

    刚刚上面说了静态方法没有重写这一概念

    下面说下静态方法里面的构造

    静态方法里不能有未确定的元素

    什么样的元素叫不确定元素呢?

    因为静态属性和方法是在类存在时候就加载完了,但普通的成员属性和方法是实例化后才加载进去的,所以我们不能吧一个未加载的元素放到静态方法中(重点)

    public class Demo02 {
        public static void main(String[] args) {
            go();
        }
    
        private static void go() {
            System.out.println("gogogo");
        }
    }
    

    我们经常写的主函数,就是一个一个静态方法,如果我想调用本类里面的一个方法,就要是写成静态方法,同理,我们在静态方法里调用外面的属性,也该是静态属性

    三、final(常量)

    被final修饰的属性一定要被赋值且不能修改

    什么样的数是常量呢?
    例如pi = 3.14159…

    public class Demo02 {
        public static void main(String[] args) {
            double pi = Math.PI;
        }
    }
    

    在这里插入图片描述
    可以看到PI就是常量,我们不能改变PI的大小,这是宇宙的公理(这里也用带了静态属性哦)

    总结(非常重要)

    1、private 高级复习

    • 构造方法:private修饰的构造方法,实例化将不能调用,且报错,private修饰的无参构造的类,不能被继承且报错

    其意义在于不能被实例化,常用于所有元素都为static静态的类中,由类本身去调用元素

    • 方法与属性:1、private修饰的方法,实例化也是不能直接调用的,需要在类内部使用,如this.方法,2、属性不能在实例化后赋值,所以由set\get方法来给予赋值,函数也是通过第三方函数来调用,可重载。

    • 继承:private修饰的属性与方法等都不能被继承

    • 类:不允许修饰类 private class Test{} 报错!

    private修饰的构造方法的类,如Math类,不能被继承,里面全是静态方法。

    2、static

    static为静态,被他修饰的属性与方法不需要实例化即可调用,如类名.属性,类名.方法

    • 构造方法:static不允许修饰构造方法

    • 构造块:静态构造块是仅次于静态代码块执行,
      在类生成时,会先执行静态属性,再执行静态代码块

    • 方法与属性:1、static修饰的方法和属性都是属于类本身的,也就不需要实例化即可调用,在static修饰值改变后,所有实例化后的属性值都改变

    ​ 2、static修饰的方法里不能用普通成员属性!static修饰的方法,在类加载的时候是被首 先加载的,实例化后才加载非static内容,所以加载static时 是不能有非static内容的

    ​ 3、可重载

    • 继承:子类继承了父类的static值,子类继承的static改变了,父类的也改变了!!!
      static修饰的属性和方法不能重写。

    • 类:类用不了static修饰

    调用静态方法尽量不要用引用对象(不用实例化对象的名字调用)如用Math.max()(Math类是不能实例化的)

    3、final

    • 构造方法:final不能修饰构造方法

    • 构造块:不能修饰构造块

    • 方法与属性:1、final修饰的属性必须在定义时候赋值,不能final int a; 不能实例化后才赋值,是最终 的唯一,是常量

    ​ 2、final修饰的方法可以调用但继承不能被修改。

    ​ 3、可被重载

    • 继承:可被继承,但继承的方法和属性都不可被重写,被final修饰的类不能被继承

    • 类:被final修饰的类不能被继承

    被final修饰的属性和方法都为不可覆盖(如继承后不能重写)

    静态公开唯一的属性为常量,一般应该都是全大写

    public static final double PI = 3.14159265…;

    • 问:为何需要将类标记为final ? 这不会破坏面向对象的目的吗?
      答:会也不会。将类标记为final主要目的是为了安全。例如String这个类,假使有人继承过,弄一个行为很不一致的版本,就会对于其操作String的程序产生很多问题。

    • 问:如果类已经是final的,再标记final方法是不是很多余?
      答:不只是多余,而且多了很多。如果一个类不能被子类化,则它根本就无法被覆盖。如果只是想限制部分的方法不能被覆盖过,那就单独地标记它们的final的就行了。

    4、abstract

    抽象类是一个模板,供其他类使用

    • 构造方法:不能修饰构造方法
    • 构造块:不能修饰构造块
    • 属性:不能修饰属性
    • 方法:修饰的方法不能写代码,为模板作用,只能被子类继承重写
    • 继承:1、可以被abstract类继承,继承过去的抽象方法可以选择性重写
      2、被普通类继承时,必须重写抽象方法
      3、抽象类本身不能实例化
    • 类:可被修饰类,但不能被实例化,只能被继承,为模板作用
      继承的类需要重写他的抽象方法
    展开全文
  • 1. 抽象类中不能有static修饰的方法。 打个比方: 被static修饰的方法在和没有static修饰的方法在内存中的位置不一样。。 被static修饰的方法属于类,是类自己的东西,不是给子类来继承的。就好像类是个房子,它的...

    1. 抽象类中不能有static修饰的方法。

    打个比方:

    被static修饰的方法在和没有static修饰的方法在内存中的位置不一样。。
    被static修饰的方法属于类,是类自己的东西,不是给子类来继承的。就好像类是个房子,它的静态方法是里面的一面墙,每个人都可已在墙上画画,你画的东西别人也能看到,属于大家共同使用。你想通过继承来把这面墙拿走也不可能拿走,他是从属于类的。
    而抽象方法本身没有实现,就是用来给子类继承,存在内存中的位置也不是一样的。用static修饰就不能被子类继承了。同样 你可以这么理解。
    抽象方法相当于房子中地上的白纸,继承了它的子类就必须从地上拿一张白纸回去画画,你想怎么画怎么画。
    一个相当于墙,你是拿不走的。一个相当于地上的纸,而且规定你实现了就必须拿走。

    2. 抽象类中不能有final,private修饰的方法:

    final修饰的类不可继承,而抽象类本事是不能被实例化的,是需要让子类去继承,如果父类使用了final修饰符修饰方法,子类继承后,也无法重写该方法。
    private的访问权限是本类中,子类继承父类后,是无法方法private修饰的方法的。

    所以,一个抽象类中的抽象方法是不能用static,final和private修饰的。

    展开全文
  • 普通类和抽象类之间的区别? 接口和抽象类之间的区别?

    1、普通类和抽象类之间的区别?

    抽象类是包含抽象方法的类,其中的某些方法声明为abstract来表示一个类是抽象类。抽象类是一种模板模式,子类可以在这个模板上进行扩展。抽象类的存在还可以避免子类设计的随意性。实现了代码设计与实现的分离。

    (1)抽象类不可以被实例化,不可以new一个实例化对象。
    (2)只要有抽象方法的类,必须定义成抽象类。
    (3)抽象类可以包含属性、方法、构造方法。但是构造方法只能被子类调用,不可以用来实例化对象。
    (4)抽象类只能用来继承,并且子类必须重写其抽象方法,除非子类自身也是抽象类。

    注:抽象类中可以有普通方法。抽象方法只有方法声明,没有方法体。

    2、接口和抽象类之间的区别?

    接口和抽象类是支持抽象类定义的两种机制。
    抽象类是包含抽象方法的类,其中的某些方法声明为abstract来表示一个类是抽象类。
    接口是指一个方法的集合,其中所有的方法都没有方法体,通过关键字implements来实现。接口中只有常量和抽象方法。
    相同点(2点):
    (1)抽象类和接口都不能被实例化。
    (2)抽象类的子类和接口的实现类都只有在实现了抽象类或者接口中的方法之后才可以被实例化。

    不同点(6点):
    (1)方法的定义与实现。
    java8之前,接口只能定义方法,不能实现,只有实现接口的实现类可以实现方法。但是抽象类中的方法可以有定义+实现。
    (2)实现与继承。
    接口实现用implements,抽象类只能用继承extends。一个类可以实现多个接口,但是只能继承一个抽象类。因此接口可以间接达到多重继承的目的。
    (3)设计理念。
    接口强调功能的实现,设计理念:has——a;抽象类强调所属关系,设计理念:is——a。
    (4)成员变量的不同点。
    接口中成员变量默认为public static final,只能有静态的不能被修改的数据成员,而且必须给其赋初始值。
    抽象类可以有自己的数据成员变量。抽象类中的成员变量默认为default,当然也可以被定义为public、protected和private,这些成员变量可以在子类中被重新定义,也可以被重新赋值。
    (5)成员方法的不同点。
    接口中的成员方法都只能是public abstract的,且只能被这两个关键字修饰。
    抽象类中可以有非抽象的成员方法。抽象类的抽象方法(前有abstract修饰)不能用private、static、synchronized、native等修饰符修饰。同时必须以分号结尾,不能有花括号。
    (6)应用方面。
    接口被运用于比较常见的功能,便于日后维护或者增加删除方法。
    抽象类更倾向于充当公共角色,不适用于日后重新对里面的代码进行修改。

    其他说明:
    接口是一种特殊的抽象类。接口可以继承接口。
    抽象类可以实现接口,抽象类也可以继承具体类。抽象类可以有静态的main方法。

    3、抽象类必须要有抽象方法吗?

    (1)抽象类一定有abstract修饰。
    (2)抽象类不一定要有抽象方法。
    (3)有抽象方法的类一定是抽象类。

    4、抽象类能使用final修饰吗?

    不可以。
    用final修饰的类不可以被继承。
    抽象类是一种模板模式,子类可以在这个模板上进行扩展。抽象类的存在还可以避免子类设计的随意性。实现了代码设计与实现的分离。就是要通过子类的继承实现其中的抽象方法。而final修饰抽象类的做法违背了抽象类的初衷。

    展开全文
  • 抽象类中不能有static,final,private修饰的方法 1. 抽象类中不能有static修饰的方法。 打个比方: 被static修饰的方法在和没有static修饰的方法在内存中的位置不一样。。被static修饰的方法属于类,是类自己的...
  • 原因如下:抽象方法没有方法体,是用来被继承的,所以不能用private修饰;static修饰的方法可以通过类名来访问该方法(即该方法的方法体),抽象方法static修饰没有意义;使用synchronized关键字是为该方法加一个...
  • 而是多个该的实例共享使用该变量。所有该的对象都可以操作这块存储空间。如果final修饰就另当别论了。创建完成就需要进行初始化1. 定义时直接初始化2. 如果需要通过计算来初始化你的static变量,可以声明一个...
  • https://blog.csdn.net/qq_29440353/article/details/89091681 ... 抽象类中不能有static修饰的方法。 打个比方: 1. 被static修饰的方法在和没有static修饰的方法在内存中的位置不一样。。 2. 被stat...
  • Java基础-抽象类与static修饰符 static 修饰符 static修饰可以修饰属性、方法、内部类。而经过static修饰的属性和方法都会随着类加载时进行初始化加载,当其他类想使用被static修饰修饰过的方法时可以直接...
  • 抽象类中不能有static,final,private修饰的方法 1. 抽象类中不能有static修饰的方法。 打个比方: 被static修饰的方法在和没有static修饰的方法在内存中的位置不一样。。 被static修饰的方法属于类,是类自己的...
  • 主要介绍了Java抽象类和抽象方法定义与用法,结合实例形式详细分析了Java抽象类和抽象方法相关原理、定义、使用方法及操作注意事项,需要的朋友可以参考下
  • 抽象类、访问修饰

    2021-09-22 21:50:57
    抽象类:如果一个类没有足够的信息来描述一个具体的对象,而需要其他具体的类来补充。 注意:含有抽象方法的类是抽象类抽象类中不一定有抽象方法。 抽象类不能直接创建对象,必须通过子类实现。 abstract不能...
  • Java修饰符,抽象类

    千次阅读 2019-05-08 20:01:36
    final修饰符 final主要用法有以下四种: 一、用来修饰数据,包括成员变量和局部变量,该变量只能被赋值一次且它的值无法被改变。对于成员变量来讲,我们必须在声明时、构造方法或者初始化块中对它赋值; 1. public ...
  • Java抽象类、抽象方法、final修饰

    千次阅读 2020-03-25 16:06:26
    使用abstract修饰修饰的类被称为抽象类 抽象类不能实例化对象,只能被继承。 抽象类和抽象方法都通过abstract关键字来修饰 示例如下: /** * 交通工具的抽象类 */ public abstract class Traffic { } 什么...
  • 抽象类和访问修饰

    2021-09-22 21:31:00
    抽象类可以没有抽象方法,如果抽象类中有抽象方法,则一定是抽象类; 一个类继承于一个抽象类,如果父类中有抽象方法,则必须在子类中重新; 如果子类不重写这个抽象方法,那么这个子类也是抽象类抽象类不能...
  • JDK 1.8以前,抽象类的方法默认访问权限为protected(可以是public和protected) JDK 1.8时,抽象类的方法默认访问权限变为默认访问权限(可以是public和protected或者不写) 接口方法 JDK 1.8以前,接口中的方法...
  • 1.抽象类:被abstract关键字修饰的类称为抽象类 抽象类不能实例化对象,只能够被继承之后创建子类的对象 2.抽象方法:被abstract关键字修饰的方法称为抽象方法 抽象方法不能有方法体,即不能有{},子类必须重写抽象...
  • 抽象方法哪些修饰修饰

    千次阅读 2018-04-04 17:53:57
    问:抽象的(abstract)方法是否可同时是静态的(static),是否可同时是本地方法(native),是否可同时被synchronized修饰?  答: 实例说明: public abstract class Demo { int a; public Demo(int a...
  • 所以,必然不能用private修饰抽象方法.抽象方法一定是要被子去重写的. static  Java中用static修饰修饰的方法为静态方法,下面讲一下static修饰的方法的用法以及特点.Java中static修饰的方法属于整个方法...
  • 一:接口中可用的修饰符  1:在成员变量zh
  • /*** 抽象类继承* abstract修饰类就是抽象类* abstract修饰方法就是抽象方法(一般使用比较少)* 抽象类不能被实例化*/public classMain {public static voidmain(String[] args) {Animal an= newCat();...
  • 原因如下:抽象方法没有方法体,是用来被继承的,所以不能用private修饰;static修饰的方法可以通过类名来访问该方法(即该方法的方法体),抽象方法static修饰没有意义;使用synchronized关键字是为该方法加一个...
  • 抽象类和接口的修饰

    千次阅读 2017-09-05 18:50:23
    1、抽象类中的抽象方法(其前有abstract修饰)不能private、static、synchronized、native访问修饰符修饰。 原因如下:抽象方法没有方法体,是用来被继承的,所以不能用private修饰;static修饰的方法可以通过...
  • 接口 抽象类 类略详解一、权限修饰符1.1概述1.2不同修饰符可访问文件权限1.3 static1.3.1 概述1.3.2 修饰类1.3.3 修饰方法1.3.4 修饰变量1.4 synchronized1.4.1概述1.4.2 修饰类1.4.3 修饰方法1.4.4 修饰变量1.5 ...
  • 【接口可以定义私有private方法了,你知道吗?】 接口只可以定义以下类型方法: interface AbstractAndInterface { private void pa2() { } //私有 private static void pa4(){} //私有静态 default void da...
  • abstract class 雇员{private String name;private String id;private double pay;雇员(String name,String id,double pay){this.name=name;this.id=id;this.pay=pay;}public abstract void work();}class 程序员 ...
  • 当多个类中出现相同功能,...3, 抽象类可以用new创建对象。因为调用抽象方法没有意义。 4, 抽象类中的方法要被使用,必须由子类复写所有的抽象方法后,建立子类对象调用。 如果子类只覆盖了部分抽象方法,那么...
  • 转自:http://blog.sina.com.cn/s/blog_7ffb8dd5010111yu.html ... 1、抽象类中的抽象方法(其前有abstract修饰)不能用private、static、synchronized、native访...
  • 抽象方法存在的意义是被子继承和重写。 private方法不能被重写, static方法可以被继承,但是也不能被重写, ...private,static,final修饰的方法都不能重写,所以和抽象方法存在的意义冲突,所以不能。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 153,338
精华内容 61,335
关键字:

抽象类可以用private修饰吗