• Java的修饰、继承、接口、抽象类


     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修饰的成员对于本类、本包、其子类可见

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

    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.所有类(无论是否抽象)都直接或间接继承自Object,接口(interface)不继承Object

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

    接口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方法是普通方法

    狗类的抽象方法被实现了

  • 相关阅读:
    图片合成
    ASP.net常用对象之一(Request对象)
    vs2010新增功能
    ASP.NET MVC 入门5、View与ViewData【转】
    ASP.NET MVC 入门3、Routing【转】
    ASP.NET MVC 入门2、项目的目录结构与核心的DLL[转]
    ASP.NET MVC 入门4、Controller与Action【转】
    jquery相关文摘
    application技术整理
    vb datagrid中的欄目順序要與recordset的順序一致
  • 原文地址:https://www.cnblogs.com/shoulinniao/p/11509623.html
Copyright © 2020-2023  润新知