一.继承：
关键字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();//最后，女武神使用这把武器进行攻击