java自学第3期——继承、多态、接口、抽象类、final关键字、权限修饰符、内部类

2022-11-16 17:11:36

一.继承：

关键字extends

/*

定义一个父类：人类

定义父类格式：public class 父类名称{

}

定义子类格式：public class 子类名称 extends 父类名称{

}

*/

代码示范：

*要点：

1.子类中在main方法中创建父类对象可调用父类方法；

2.不加关键字直接访问本方法局部变量(可重名时区分)；

3.使用this关键字访问本类成员变量(可重名时区分)；

4.使用super关键字访问父类成员变量(可重名时区分)；

5.如果存在方法的重名：父类与子类有重名方法：

——对象new的谁则优先调用谁的重名方法，没有则向上寻找；

前面介绍了成员变量、成员方法继承的访问特点，接下来是构造方法：

——子类构造方法（父类无参时）中有一个默认赠送的super()方法

——父类有参时，子类里调用super的()里传参，重载时谁对的上调用谁；

6.如果要更新修改父类方法，本着设计原则尽量不去直接修改正在使用的类，

则可以进行覆盖重写：格式：通过使用super关键字继承父类需要的方法。

@Override

方法外部相同(){

   super.父类方法();

   //这里添加新的内容

}

/*

小结super

super关键字作用：

示例：

   public class demo06Super extends demo01people {

   public void method1(){

       System.out.println(super.num);	//1.在子类成员方法中访问父类的成员变量

   }

   public void method2(){

       super.methodChongMing();	// 2.在子类成员方法中访问父类的成员方法

   }

   public demo06Super(){

       super();	//3.在子类的构造方法中访问父类的构造方法

   }

}

*/

7.this关键字的作用小结：

this关键字的作用：

1.在本类的成员方法中访问本类的成员变量

2.在本类成员方法中访问本类的另一个成员方法

3.在本类的构造方法中访问本类的另一个构造方法：

(1)this(...)调用必须是构造方法的第一个语句，一个this；

(2)super和this两种构造调用不能同时使用

代码示范：

String name = "python";

public void method1(){

        String name = "python";

        System.out.println(name);//无关键字时直接访问本方法局部变量

        System.out.println(this.name);//访问本类成员变量

        System.out.println(super.num);//访问父类成员变量

        this.method2();//访问本类另一个成员方法

    }

8.最后，继承三大特点：

1.单继承：一个子类只有一个直接父类

2.多级继承：父类、子类、子类也可作父类再向下延伸，最上级为java.lang.object类

3.一个父类可以有多个子类

二、多态

1.多态性：父类引用指向子类对象

多态的一个用处：无论右边new的时候换成哪个子类对象，等号左边调用方法都不会发生变化

格式：

父类名称 对象名 = new 子类名称();

或者：

接口名 对象名 = new 实现类名称()。

2.成员方法：编译看左，运行看右；

成员变量：编译看左，运行也看左；实例变量不具备多态性.

代码示范：

//前面省略部分Zi类已经继承Fu类

  public static void main(String[] args) {

        Fu one = new Zi();//多态的写法

        one.methodcommon();//重名时，成员方法优先使用子类（new谁先调用谁）。

        one.fu1();//它的编译时类型为Fu，可以调用Fu中的方法

//      one.zi1(); 该调用编译时会报错，因为它的编译时类型为Fu,无法调用zi1方法；

        System.out.println(one.num);//优先看左边Fu类

        Zi two = (Zi) one;//将父类对象还原成子类对象。

        System.out.println(one instanceof Fu);//输出true,one可以做Fu类的实例对象

        System.out.println(one instanceof Zi);//输出true,one可以做Zi类的实例对象

    }

3.转型多态写法左父右子是正常的向上转型

4.向下转型：为了让对象调用子类方法（向上转型只能调用左边编译类型的父类方法）

左子类右父类，是一个还原的过程，将父类对象还原成子类对象，且不能向下转成别的子类。

格式：  子类名 对象名 = （子类名） 父类对象名；     （后者也可以是接口）

Fu fu = new Fu();//向上转型创建父类对象

Zi two = (Zi) one;//将父类对象还原成子类对象。

5.强制向下转型时，判断前面的对象是否是后面类型的实例，是否可以成功转换，从而保证代码更加健壮。

格式：对象 instanceof 类型

得到一个boolean值结果(true/false)，判断前面的对象能否作为后面类型的实例

Zi two = (Zi) one;//将父类对象还原成子类对象。

        System.out.println(one instanceof Fu);//输出true,one可以做Fu类的实例对象

        System.out.println(one instanceof Zi);//输出true,one可以做Zi类的实例对象

三、接口

1.接口定义了某一批类需要遵守的规范。这就意味着接口里通常是定义一组公用方法。

2.接口是一种引用数据类型（类、接口、数组），注意其中的抽象方法。

3.接口可以继承接口，但不能继承类。

4.Java9 里可以有常量、抽象方法、默认方法、静态方法、私有方法。

5.备注：接口编译后生成的同样是.class的字节码文件

//格式

public interface 接口名称(首字母大写){

	//抽象方法

}

接口里的成员变量只能是常量，必须用public static final修饰,可省略

 //final即为不可改变

    public static final int MAX_NUMBER = 20;

接口里的[普通方法]只能是抽象方法，public abstract可以省略

 public abstract void out();

   				 void getDate();

接口中的[默认方法]需要用default修饰

    /*

    当接口新添加方法时，新方法写为默认方法，则可以不去动其实现类，默认方法自动被其继承

    默认方法同样可以被覆写。

     */

    public default void print() {

        foo();

        System.out.println("默认方法调用3");

    }

接口中定义[静态方法]，需要用static修饰

public static void staticTest() {

        System.out.println("静态方法！");

    }

当俩默认方法中有重复内容时，抽取出来定义私有方法

//定义私有默认方法,给默认方法调用，但不应被实现类使用，所以权限为私有

    private void foo() {

        System.out.println("默认方法调用2");

    }

//定义私有静态方法，给静态方法调用，但不应被实现类使用，所以权限为私有

    private static void bar() {

        System.out.println("bar私有静态方法");

    }

}

接口不能创建实例，但能用于声明引用类型变量，且必须引用到实现类的对象；
一个实现类可以同时实现多个接口

//格式：

.public class 实现类名称 impliments{

 	//必须覆写接口中所有抽象方法；

},

在实现类(impliments)中进行接口的实现：

//

public class Demo01InterfaceImpl implements Demo01Interface,Demo02Interface {

    //1，2接口都有out抽象方法，但只需覆写一次

    @Override

    public void out() {

        System.out.println("抽象方法覆写！");

    }

    @Override

    public void getDate() {

        System.out.println("抽象方法覆写！");

    }

    @Override

    public void print(){

        System.out.println("冲突的默认方法也需要覆写！");//不冲突则不用覆写

    }

}

然后在main类里创建实现类的对象，进行调用

public class Impliments  {

    public static void main(String[] args) {

  	    //创建实现类的对象

        Demo01InterfaceImpl ImplementationObject1 = new Demo01InterfaceImpl();

        ImplementationObject1.getDate();

        ImplementationObject1.out();

        ImplementationObject1.print();//调用实现类里继承自接口的默认方法。

		//接口里的静态方法只能通过接口名称直接调用。

        Demo01Interface.staticTest();

		//通过接口名直接访问常量。

        System.out.println(Demo01Interface.MAX_NUMBER);

    }

}

接口是多继承，一个接口可以有多个父接口。
多个父接口中的抽象方法如果存在重名，正常覆写；但默认方法重名需要带有default关键字覆写。
正常不冲突抽象方法不需要再覆写（实现类多个接口时也是如此）。

//接口的多继承，同样使用extends关键字

public interface Demo03InterfaceExtends extends Demo01Interface,Demo02Interface {

    @Override

    default void print() {

		//覆写父接口的默认方法不能省略default关键字

    }

}

四、抽象类

抽象方法：加上abstract关键字，去掉大括号，直接分号结束；
抽象类：抽象方法所在的类必须是抽象类，再class之前写上abstract即可
不能直接new抽象类对象，必须用一个子类来继承抽象父类

（抽象类对象调用的方法存在没有具体内容的方法体，因此没有意义）
创建子类对象，不可创建抽象父类对象；

public abstract class demo01Abstract {

    public abstract void method1();

    public abstract void method2();

}

子类必须覆写抽象类中的所有抽象方法（去掉abstrat，补上大括号）。

（假设不全部覆写，对象调用的方法存在抽象方法，没有意义）

//使用extends继承抽象父类

public abstract class demo02Zi extends demo01Abstract {

    //只覆写了一个抽象方法，没有将抽象方法全部覆写完，也就是说本子类还存在着继承下来的未覆写的抽象方法

    //所以该类也同样是抽象类

    @Override

    public void method1() {

        System.out.println("已经覆写第method1方法！");

    }

}

//在这个子子类中已经将所有抽象方法全部覆写，所以该类不再是抽象类！

public class demo03Sun extends demo02Zi {

    @Override

    public void method2() {

        System.out.println("已经覆写method2方法！");

    }

}

最后在main类中的main方法里创建对象进行调用即可。

五、final关键字

final表示它修饰的类、方法、成员变量、局部变量不可改变。
final修饰的类不可被继承下去。无子类，不可被覆盖重写。

public final class 类名(){}

final修饰的方法不可被覆盖重写。

public final void method(){}

类和方法不能同时使用final和abstract，二者矛盾。abstract表示抽象，是待定的；final表示最终的，是确定的。
final修饰局部变量，若是基本数据类型的数值，则不可改变；若是引用数据类型，则地址值不可改变，但地址指向的对象的内容可以改变。
final修饰成员变量，也不可变，但必须要进行手动赋值，成员变量加final后不允许再拥有默认值。

public final class Demo01Final {

    public static void main(String[] args) {

        int NUM = 1;

        System.out.println(NUM);

        NUM = 2;//可以改变

        System.out.println(NUM);

        final int NUM1 = 2;

//      NUM1 = 3;  错误，NUM是确定的值，不可被改变。

    }

}

六、权限修饰符

权限大小：

四种权限修饰符，访问权限从大到小：

public > protected > 空 > private

同一个类： yes yes yes yes

同一个包： yes yes yes no

不同包子类： yes yes no no

不同包非子类：yes no no no

七、内部类

一个外部类包含的一个嵌套的类，叫内部类。

分类：

1.成员内部类。

2.局部内部类（包含匿名内部类）。

注意：内部类可以无限制地访问外部类，外部类访问内部类需要内部类对象。
各个类对应可以使用的权限修饰符如下：

外部类：public/(default)

成员内部类:public.protect.(default).private

局部内部类：什么都没有，注意并不是(default)
内部类定义示例：

public class main {

    private String name = "成员变量";

    //定义一个成员内部类

    public class innerClass {

        private String innername = "内部成员变量";

    }

		// 定义一个成员内部类内的成员方法

        public void innermethod1() {

            System.out.println("内部类方法");

            System.out.println(name);

        }

  }

使用内部类的两种方式：

1.直接：在main方法中创建内部类对象：格式：

外.内 = new 外().内();

外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

 public static void main(String[] args) {

        //直接创建内部类的对象。

        InnerclassUsing.innerClass object = new InnerclassUsing().new innerClass();

        object.innermethod1();

    }

2.间接：在外部类的方法中，只用内部类，main只是调用外部类的方法，通过外部类方法访问内部类。

public class InnerclassUsing {

    private String name = "成员变量";

    //定义一个成员内部类

    public class innerClass {

        private String innername = "内部成员变量";

        // 定义一个成员内部类的成员方法

        public void innermethod1() {

            System.out.println("内部类方法");

            System.out.println(name);

        }

    }

    public void outMethod() {

        System.out.println("外部类成员方法");

  //    System.out.println(innername);  错误。

        //通过匿名对象访问内部类变量和方法

        System.out.println(new innerClass().innername);

        //创建匿名对象并调用innermethod1方法。

        new innerClass().innermethod1();

    }

 }

内部类的重名变量访问格式：

本方法：空
本类成员变量：this.
外部类成员变量：外部类的名称.this.

public class Demo03CommonName {

	//外部类成员变量

    int NAME = 1;

    public class innerClass{

    	//内部类成员变量

        int NAME = 2;

        public void method (){

        	//内部类局部变量

            int NAME = 3;

            System.out.println(NAME);//3,局部变量，就近原则。

            System.out.println(this.NAME);//2,本类成员变量。

            System.out.println(Demo03CommonName.this.NAME);//1,外部类的成员变量；

        }

    }

}

如果一个类定义在方法内部，那么这个类叫局部内部类。

局部内部类只能被当前所属的方法所使用，外部不可。

格式：

public class Localinnerclass {

    String NAME = "外部成员变量";

    public void method(){

    	//定义局部内部类

        class localLinnerClass{

            String ONE = "局部内部类成员变量";

            public void nmethod2(){

                System.out.println("局部内部类的成员方法");

                System.out.println(ONE);

            }

        }

    }

}

局部内部类，如果希望访问所在方法的局部变量，该变量应该满足【有效final】的条件

public class Demo04Final {

    public void method1(){

        //这里即使不写final的话，不去修改 也算是有效final [从java8开始]

        final String NAME = "bilibili";

        class LocalInnerclass{

            public void localInnerMethod(){

            	//局部内部类内的方法访问所在类外部的方法的局部变量

                System.out.println(NAME);

            }

        }

    }

}

当接口是实现类只使用唯一一次时，可以使用匿名内部类

格式

接口名称 对象名 = new 接口名称(){

    //这里进行抽象方法的覆写。

};    //别忘了结尾的分号

匿名内部类在创建对象的时候，只能使用唯一一次

匿名对象在使用方法时，只能使用唯一一次

匿名内部类是省略了（实现类/子类名称），而匿名对象则是省略了对象名称，二者不同。

//当实现类只使用一次时，可以使用匿名内部类的写法！

        Anonymous obj6 = new Anonymous() {

            //覆写匿名内部类里所有抽象方法！

            @Override

            public void method1() {

                System.out.println("bilibili?");

            }

            @Override

            public void method2(){

                System.out.println("覆写method!");

            }

        };

        obj6.method1();//打印内容

        obj6.method2();

将类作为成员变量的写法

//定义一个武器类

public class Weapon {

    private String itsname;//武器名称

    private int attacknum;//武器攻击力

	//无参构造方法

    public Weapon() {

    }

	//全参方法

    public Weapon(String itsname, int attacknum) {

        this.itsname = itsname;

        this.attacknum = attacknum;

    }

	//get名字

    public String getItsname() {

        return itsname;

    }

	//set名字

    public void setItsname(String itsname) {

        this.itsname = itsname;

    }

	//get攻击力

    public int getAttacknum() {

        return attacknum;

    }

	//set攻击力

    public void setAttacknum(int attacknum) {

        this.attacknum = attacknum;

    }

}

//定义一个女武神类

public class Valkyrie1 {

    private String name;//女武神之名

    private Weapon weapon;//将武器类变为成员变量 交给女武神类

	//女武神攻击方法

    public void attack(){

        System.out.println(name + "使用的" + weapon.getItsname() + "具有" + weapon.getAttacknum() +"点攻击力");

    }

	//无参构造

    public Valkyrie1() {};

	//全参

    public Valkyrie1(String name, Weapon weapon) {

        this.name = name;

        this.weapon = weapon;

    }

	//get女武神名字

    public String getName() {

        return name;

    }

	//set女武神名字

    public void setName(String name) {

        this.name = name;

    }

	//get女武神武器

    public Weapon getWeapon() {

        return weapon;

    }

	//set女武神武器

    public void setWeapon(Weapon weapon) {

        this.weapon = weapon;

    }

}

定义了女武神类和武器类后，在main方法中进行调用

 		Valkyrie1 valkyrie = new Valkyrie1();//创建一个女武神

        valkyrie.setName("bronya"); //set女武神名字叫bronya

        Weapon weapon = new Weapon("真理之钥",1000);//创建一把武器，并同时赋予名称和攻击力

//     也可以分开写： weapon.setItsname("真理之钥");//武器名字

//     也可以分开写： weapon.setAttacknum(1000);//武器攻击力

        valkyrie.setWeapon(weapon);//将定义好的武器交给女武神

        valkyrie.attack();//最后，女武神使用这把武器进行攻击

码农公寓