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();
}
*/

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();
    }
}

输出结果：

动物行走方法是爬行或者直立行走
猫类 继承 抽象的动物类，此时必须实现抽象方法 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方法是普通方法

狗类的抽象方法被实现了