修饰、继承、接口、抽象类

 1.private

修饰属性或者方法,只能在本类中被访问,定义后需要加get()set()方法,这样提高数据的安全性

私有属性虽然不能直接访问,但是其对象 或者 子类对象可以通过公有方法进行设值和获取,这就是为什么最好加get和set方法

私有方法存在于本类并且不能在其他类中被使用

package my_acm;

class Hello{
    private int id=12;
    public int getid(){
        return this.id;
    }
    public void Setid(int id) {
        this.id=id;
    }
    private void Printid() {
        System.out.println("the id is "+this.id+"in class");
    }
}

public class Main extends Hello
{
    public static void main(String []args)
    {
        Hello hello = new Hello();
        Main main = new Main();
        int temp;
        temp = hello.getid();///通过公有方法 获取 私有属性值
        System.out.println(temp);
        temp = main.getid();
        System.out.println(temp);
        hello.Setid(130);
        main.Setid(111);
        temp = hello.getid();///通过公有方法 设置 私有属性值
        System.out.println(temp);
        temp = main.getid();
        System.out.println(temp);
        //main.Printid();//报错,不能访问私有方法
        //hello.Printid();//报错,不能访问私有方法
        ///结果是12 12 130 111
    }
}

2.protected

被protected修饰的成员对于本包和其子类可见,暂时只用一个包,还没有感受到和public不同的地方。

抽象类(因为方法不确定,所以叫抽象,所以先不写,所有只有名字没有内容,所以需要用的时候再写内容)

1.抽象类是为了被继承而存在的,一般是public的,如果没写,则默认公有

2.抽象类里可有可无抽象方法,也可以有非抽象方法

3.有抽象方法的一定是抽象类

4.抽象类被继承后,他的子类必须实现抽象类中定义的抽象方法

5.抽象类不能创建对象,需要被继承,他的子类可以创建对象

6.子类不能覆盖抽象父类的方法

7.abstract 不能和 final并列修饰同一个类

8.abstract 不能和 private static final修饰同一个方法

继承中的super

有父类Animal,其中有方法walk();

子类Cat重写了walk(),则子类对象无法直接调用父类的walk()方法,都重写了还要去调用父类就显得多此一举了。

但是在子类的方法中可以用super调用父类方法,这样就间接地调用了父类方法。

package my_acm;

public abstract class Animal {
    public String kind="动物";
    abstract void say();///抽象类可有可无抽象方法,可以有非抽象方法
    public void walk() {
        System.out.println("动物行走方法是爬行或者直立行走");
    }
}

class Cat extends Animal{
    //重写父类walk方法
    public void walk() {
        System.out.println("猫爬行");
    }
    void say() {
        super.walk();///在方法体里用super调用父类方法
        System.out.println("猫类 继承 抽象的动物类,此时必须实现抽象方法 say()");
    }
}

class Animal2 {
    public String kind="动物2";
    public void walk() {
        System.out.println("动物2行走方法是爬行或者直立行走");
    }
}
class Cat2 extends Animal2{
    public void walk() {
        super.walk();
        System.out.println("猫2爬行");
    }
}

/**
//报错,定义抽象方法必须要是抽象类
class Plant{
    abstract void say();
}
*/

Animal.java

package my_acm;

public class MyTest2{
    public static void main(String []args) {
        //Animal a1 = new Animal();//报错,动物类是抽象类,不能创建对象
        Cat c1=new Cat();
        c1.say();
        c1.walk();
        Cat2 c2=new Cat2();
        c2.walk();
    }
}

MyTest2.java

输出结果:

动物行走方法是爬行或者直立行走
猫类 继承 抽象的动物类,此时必须实现抽象方法 say()
猫爬行
动物2行走方法是爬行或者直立行走
猫2爬行

继承和接口

1.一个接口可以继承多个接口.
interface C extends A, B {}是可以的.
2.一个类可以实现多个接口:
class D implements A,B,C{}
3.但是一个类只能继承一个类,不能继承多个类
class B extends A{}
4.在继承类的同时,也可以继承接口:
class E extends D implements A,B,C{}
5.这也正是选择用接口而不是抽象类的原因。

接口和抽象类

1.接口对应的叫实现类,抽象类对应的叫子类

2.接口中有两种方法,抽象方法和默认方法default。

抽象方法需要在实现类中实现,默认方法则不需要。如果一个类同时实现两个接口,则两个接口不能有同名的默认方法,可以有同名的抽象方法。

3.接口中的数据成员隐含为public static final,即常量。接口中的属性都是全局静态常量,接口中的常量必须在定义时指定初始值。

4.不能用protected和private修饰成员

5.接口的实现类分两种,举例说明

接口Animal3中有 常量a3,抽象方法say3和say33,默认方法walk3

接口Animal4中有 抽象方法say4,默认方法walk4

(1)普通类,必须实现接口中的所有抽象方法

普通类Cat3实现接口Animal3和Animal4,总共有3个抽象方法,say3,say33,say4,少实现一个都不行

(2)抽象类,可以不实现接口中的抽象方法

抽象类Dog实现接口Animal3和Animal4,总共有3个抽象方法,say3,say33,say4,可以选择0-3个实现,举例1个

但是,抽象类还要被继承,接口中没有实现的抽象方法需要子类实现(父债子偿)

子类Dog_son继承抽象类Dog,需要把 接口Animal3和Animal4在抽象类Dog中没有实现的抽象方法 实现,举例还剩2个

package my_acm;

public interface Animal3 {

    public int a3=333;//不可再改,默认是常量,public static final修饰
    //protected和private报错提示:only public, abstract, default, static and strictfp are permitted

    public abstract void say3();
    abstract public void say33();//abstract 和 public 可以换位置

    default void walk3() {///默认方法不同于抽象方法,不需要在实现类中再次实现
        System.out.println("动物3的行走方法");
    }
}

interface Animal4{
    public void say4();///没写abstract,默认加abstract,即抽象方法
    default void walk4() {
        System.out.println("动物4的行走方法");
    }
}

class Cat3 implements Animal4,Animal3 {

    public void say3(){//实现动物3接口中的say3方法
        System.out.println("猫3中实现了 动物3接口 中的say3方法");
    }
    public void say33() {
        System.out.println("猫3中实现了 动物3接口 中的say33方法");
    }
    public void say4() {//实现动物4接口中的say4方法
        System.out.println("猫3中实现了 动物4接口 中的say4方法");
    }
    public void walk() {//猫3自己的方法
        System.out.println("猫3自己的walk方法");
    }
}

abstract class Dog implements Animal3,Animal4{//抽象类 狗 可以只实现接口中的部分抽象方法
    public void say3() {//只实现了say3,没有实现say33和say4
        System.out.println("狗实现了 动物3接口 中的say3方法");
    }
    public void dogsay() {
        System.out.println("抽象类可以有普通方法,这里狗自己的dogsay方法是普通方法");
    }
    abstract public void dog_abstract();

}
class Dog_son extends Dog{
    public void dog_abstract(){
        System.out.println("狗类的抽象方法被实现了");
    }
    public void say33() {
        System.out.println("狗的子类继承了抽象狗类,狗中还没有实现的接口抽象方法say33需要儿子来实现");
    }
    public void say4() {
        System.out.println("狗的子类继承了抽象狗类,狗中还没有实现的接口抽象方法say4需要儿子来实现");
    }
}
package my_acm;

public class MyTest3 {
    public static void main(String []args) {
        Cat3 c3=new Cat3();
        c3.say3();
        c3.say4();
        c3.walk();
        c3.walk3();
        c3.walk4();
        //c3.a3=130;报错,没办法改变,因为接口中的数据成员隐含为public static final,即常量
        System.out.println("动物3中的a3变量="+c3.a3);
        System.out.println();
        Dog_son son = new Dog_son();
        son.say3();
        son.say33();
        son.say4();
        son.dogsay();
        son.dog_abstract();
    }
}

输出结果:

猫3中实现了 动物3接口 中的say3方法

猫3中实现了 动物4接口 中的say4方法

猫3自己的walk方法

动物3的行走方法

动物4的行走方法

动物3中的a3变量=333

狗实现了 动物3接口 中的say3方法

狗的子类继承了抽象狗类,狗中还没有实现的接口抽象方法say33需要儿子来实现

狗的子类继承了抽象狗类,狗中还没有实现的接口抽象方法say4需要儿子来实现

抽象类可以有普通方法,这里狗自己的dogsay方法是普通方法

狗类的抽象方法被实现了

原文地址:https://www.cnblogs.com/shoulinniao/p/11509623.html

时间: 2024-10-19 02:18:05

修饰、继承、接口、抽象类的相关文章

毕向东Java视频学习笔记【Day09 继承+接口+抽象类】

Java_Day09 继承+接口+抽象类 构造函数 子父类中的构造函数特点. 在子类构造对象时,发现访问子类构造函数时,父类也运行了. 为什么呢? 因为:在子类的构造函数中第一行有一个默认的隐式语句 super() 子类的实例化过程:子类中所有的构造函数默认都会访问父类中的空参构造函数. 在每个子类构造函数中,都有一个隐式的super()调用父类空参构造函数. 如果想输出22行内容,必须在29行改为super(5),这样可以访问到父类带参数的构造函数. 为什么子类实例化的时候会访问到父类的构造函

【Java面试题】60 接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法?

接口可以继承接口.抽象类可以实现(implements)接口,抽象类可以继承具体类.抽象类中可以有静态的main方法. 问:  抽象类是否可继承实体类 (concrete class) 答: 抽象类是可以继承实体类,但前提是实体类必须有明确的构造函数. 答案很明确,可以继承.其实从Object就是个实体类,Java的API文档里,每个抽象类的条目里都明确写着直接或间接继承自Object,所以这点是没有疑问的. 关键在于这答案里所说的"前提是实体类必须有明确的构造函数"一句,是什么意思.

15、接口是否可继承接口?抽象类是否可实现(implements)接口?抽象类是否可继承具体类(concreteclass)?抽象类中是否可以有静态的main方法?

接口可以继承接口.抽象类可以实现(implements)接口,抽象类可以继承具体类.抽象类中可以有静态的main方法. 问:  抽象类是否可继承实体类 (concrete class) 答: 抽象类是可以继承实体类,但前提是实体类必须有明确的构造函数. 答案很明确,可以继承.其实从Object就是个实体类,Java的API文档里,每个抽象类的条目里都明确写着直接或间接继承自Object,所以这点是没有疑问的. 关键在于这答案里所说的“前提是实体类必须有明确的构造函数”一句,是什么意思. 一般学习

C#OOP之八 继承 接口和抽象类

继承 在现实生活中有所谓的"种瓜得瓜.种豆得豆"的说法,在生物学概念上就是"遗传"的概念,在面向对象中"继承"就类似于生物学中的遗传,通过继承,可以更好的实现代码的重用(复用,多次使用的意思).增加扩展性.简化代码等. 下面是现实生活中的引用: 定义与使用继承 继承一次最常用的就是通过合法程序(比如遗嘱)从别人那里接受财产或爵位等,有点类似于世袭制. 另外一个含义,是人从父母那里继承一些特征,如果孩子从父母继承的身高.相貌等特征.那么在什么情况下

php面向对象-修饰符和抽象类和接口

PHP中有三种访问修饰符,分别是: public(公共的.默认)protected(受保护的)private(私有的) 它们可以分别用在类的属性和方法上(类的属性和方法统称为类的成员),用来修饰类成员的访问权限.public(公共的.默认)?在PHP5中如果类没有指定成员的访问修饰符,默认就是public的访问权限. /*以下两个方法声明访问权限效果相同*/function say(){};publilc function say(){}; 当类的成员被声明为public的访问修饰符时,该成员能

JAVA基础笔记(很实用)继承-多态-抽象类-接口-异常-集合-IO-线程-Socket

第七章:Java继承 一.继承的概念 1.一个父类派生出一个子类的机制称为继承. 2.承是重用程序代码的有力手段,当多个类之间存在相同的属性和方法时,可以从这些类中抽象出父类. 3.们只需要在父类中定义这些属性和方法,而子类无须重新定义这些属性和方法,直接从父类继承即可. 4.通过继承,子类就会自动的拥有在父类中定义的属性和方法. 5.两个或多个类的成员中存在一部分相同的情况,通过继承机制,可以利用现有的类来创建新的类. 6.子类不但拥有父类的成员,还可以定义新的成员. 7.可以提高软件的可重用

Java基础笔记-继承、抽象类、接口、多态、内部类、异常

继承:多个类具有相同的属性和行为时,将这些内容单独抽取到一个单独的类中,那么多个类无需再定义这些属性和行为,直接继承那个类即可 1)  多个类称为子类,单独的类称为父类或者超类 2)  子类可以继承父类中非私有的属性和方法 3)  通过extends关键字让类与类之间建立继承关系 4)  继承的出现提高了代码的复用性,让类与类之间产生了关系,为多态的出现提供了前提 5)  不能为了实现某类的功能,简化代码而继承,必须是类与类之间具有所属关系才可以继承,所属关系:is a 6)  特点:java只

类的继承,抽象类,接口,方法重写和重载

类的继承 C#与java:1.C#中继承用“:”,Java中继承用extends2.重写父类的方法,C#中需要关键字override,Java中不需要3.C#中调用父类的成员用base,Java中使用super4.子类的构造方法中如果没有显示的调用父类的构造方法,   编译器会自动在第一行代码添加super() 抽象类: 1.含有抽象方法的类必须是抽象类,抽象类中不一定有抽象方法2.抽象类的子类如果是抽象类,可以不需要重写父类的抽象方法3.抽象类不能被实例化,构造方法和静态方法不能是抽象的 接口

JAVA的abstract修饰符 && 接口interface用法 && 抽象类和interface的差别

abstract修饰符可以修饰类和方法. (1)abstract修饰类,会使这个类成为一个抽象类,这个类将不能生成对象实例,但可以做为对象变量声明的类型(见后面实例),也就是编译时类型.抽象类就相当于一类的半成品,需要子类继承并覆盖其中的抽象方法. (2)abstract修饰方法,会使这个方法变成抽象方法,也就是只有声明而没有实现,需要子类继承实现. (3)注意的地方: A:有抽象方法的类一定是抽象类.但是抽象类中不一定都是抽象方法,也可以全是具体方法.abstract修饰符在修饰类时必须放在类

Java入门系列之类继承、抽象类、接口(五)

前言 C#和Java关于类.抽象类.接口使用方式基本相似,只是对应关键字使用不同罢了,本节呢,我们只是对照C#和Java中关于这三个概念在具体使用时,看看有哪些不一样的地方. 类继承 C#和Java在定义类方式上是一致的,这点没有什么太多要讲解的,我们直接进入到类继承上,在Java中实现继承通过extends关键字,而在C#中则是以冒号(:)来继承,非常优雅而简洁,Java如下: class Animal{} class Tiger extends Animal{} 在C#中如下: class