1、抽象
1.1 概述
当一个类中，描述一个物体(对象)不够具体时，那么这个类就要定义成抽象类
1.2 语法和特征
使用abstract 关键字来定义
访问修饰符 abstract class 类名{
}
特点
抽象类中可以有构造方法，但不能(new)对象普通类中定义的属性和方法，都可以在抽象类中定用抽象类中可以存在抽象对象抽象类中可以没有抽象对象，但有抽象对象的一定是抽象类抽象方法，定义语句
访问修饰符 abstrast 返回值类型 方法名(参数列表) 抽象方法没有方法体，只有方法的声明抽象类中的抽象方法，必须由子列来实现；如果子类没有实现，那么子类也要定义成抽象方法，并由子类的子类来实现
package com.bdit.test;
public class Test01 {
public static void main(String[] args) {
// Xingz xingz = new Xingz(); 抽象类中可以有构造方法，但是不能创建(new)对象
Zhengfx zhengfx = new Zhengfx(12,5);
zhengfx.mianji();
zhengfx.zhouchang();
Xingz xz = new Zhengfx();
xz.Ffa();
xz.aa();
}
}
abstract class Xingz{
int whigh;
int height;
public Xingz(){}
public Xingz(int height){}
public Xingz(int whigh,int height){
this.whigh=whigh;
this.height=height;
}
public void Ffa(){
System.out.println("父普通方法");
}
public static void aa(){
System.out.println("父 静态");
}
/* 抽象方法，定义语法：
访问修饰符 abstract 返回值类型 方法名(参数列表);*/
public abstract void zhouchang();
public abstract void mianji();
}
class Zhengfx extends Xingz{
public Zhengfx(){}
public Zhengfx(int whigh,int height){
super(whigh, height);
}
public void zhouchang(){
System.out.println("周长"+(super.height+super.whigh)*2);
}
public void mianji(){
System.out.println("面积"+(super.height*super.whigh));
};
}
abstract class Yuan1 extends Xingz{
public void zhouchang(){
System.out.println("周长"+(super.height+super.whigh)*2);
}
}
class Yuan2 extends Yuan1{
public void mianji(){
System.out.println("周长"+(super.height+super.whigh)*2);
}
}
2、 接口
2.1 概述
接口，是Java语言的一种引用类型，是方法的集合，也是标准。类中内部封装了成员变量、构造方法、成员方法，那么接口的内部主要是封装了方法，包含抽象方法、默认方法和静态方法、私有方法。
接口：就是用来定义公共方法或者标准的
接口的定义：
使用 interface 关键字，它也会编译成class文件，但它不是类，而是另一种的引用数据类型 接口并不能创建对象，但可以被实现 imlements 类似于被继承，一个可以实现接口的类，需要实现接口类中的所有的抽象方法，创建该类后，就可以调用方法，否则它必须是一个抽象类特点：
接口中不能有构造方法，也不能创造接口对象接口中可以有抽象对象。接口中所有的抽象方法，只能使用public来修饰，即使不写，默认也是public接口中定义的变量，都是静态的变量，而且完整的修饰语法：
public static final 数据类型 常量名 = 常量值；接口中可以直接简写成：数据类型 常量 = 常量值； 接口需要类来实现，而且一个类可以是实现多个接口，接口之间用逗号隔开接口还可以弥补Java中单一继承，也就是可以多继承
2.2 接口的定义
public interface 接口名称{ //常量 //抽象方法 //默认方法 //静态方法 //私有方法 }
接口命名也是采用大驼峰命名法
有些问题会在下面讲述
2.2.1 接口、抽象
抽象方法：使用 abstract 关键字修饰，但是也可以省略，没有方法体，该方法供子类来实现
package com.bdit.test;
//接口
//接口中定义的变量，都是静态的常量，而且完整的修饰语法：
public class Test04 {
public static void main(String[] args) {
System.out.println(Inter01.a);
System.out.println(Inter02.a);
// Inter01.menth01()
Interclass interclass = new Interclass();
interclass.menth01();
interclass.menth02();
}
}
//定义抽象方法的接口
interface Inter01{
int a = 1;
// public static final 数据类型 常量名=常量值;
public static final
int b = 12;//接口中可以简写，直接写 数据类型 常量名=常量值;
public abstract void menth01();
void menth02();
}
interface Inter02 extends Inter01{
void menth01();
}
class Interclass implements Inter01{
@Override
public void menth01() {
System.out.println("抽象1");
}
@Override
public void menth02() {
System.out.println("抽象2");
}
}
2.2.2 默认方法、静态方法
默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写静态方法：使用 static 修饰，供接口直接调用
package com.bdit.test;
//接口
//默认方法
//静态方法
public class Test05 {
public static void main(String[] args) {
Interfa01.stat01();//静态可以直接访问
System.out.println(Interfa02.a);
Interfaclass interfaclass = new Interfaclass();
interfaclass.defa01();//接口的默认方法--->调用的类里面，因为重写，不重写调用接口里面的
interfaclass.abst01();//接口的抽象
interfaclass.abst02();//接口的抽象
}
}
interface Interfa01{
int a=111;
public default void defa01(){
System.out.println("接口中默认方法");
}
public static void stat01(){
System.out.println("接口中静态方法");
}
void abst01();//接口中抽象方法
public abstract void abst02();//接口中抽象方法
}
interface Interfa02 extends Interfa01{
}
class Interfaclass implements Interfa01,Interfa02{
@Override
public void abst01() {
System.out.println("抽象1");
}
@Override
public void abst02() {
System.out.println("抽象1");
}
public void defa01(){
System.out.println("在class中重写default");
}
}
2.2.3 私有静态方法、静态方法
私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用静态与类中静态方法使用一样，只能使用接口名调用，不可以通过实现类的类名或者实现类 的对象调用。私有方法：只有默认方法可以调用私有静态方法，默认方法和静态方法均可调用如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私 有方法中，供默认方法调用。从设计的角度讲，私有的方法时对默认方法和静态方法的辅助
package com.bdit.test;
//接口
//私有静态方法
//静态方法
public class Test06 {
public static void main(String[] args) {
//Interra里的私有方法无法访问，但可以通过Interra里的默认方法来访问
Inshixan inshixan = new Inshixan();
inshixan.defau();
}
}
interface Interra{
public default void defau(){
syst();
prst();
}
private void syst(){
System.out.println("接口中私有方法");
}
private static void prst(){
System.out.println("接口里面的私有静态方法");
}
}
class Inshixan implements Interra{
}
2.2.3 接口多实现
package com.bdit.test;
//接口的基本实现---implements----->(访问修饰符 class 类名 implements 接口名{ })
//接口的多实现
public class Test07 {
public static void main(String[] args) {
}
}
interface Interce01{
}
interface Interce02{}
class Cass01{}
class Cass02 extends Cass01 implements Interce01,Interce02{
}
2.2.4 抽象名一致需重写
package com.bdit.test;
//接口
//接口中，有多个抽象方法时，实现类必须重写所有的抽象方法，
// 如果抽象方法有重名，只需 要重写一次
public class Test08 {
public static void main(String[] args) {
Clas clas = new Clas();
clas.c1();
}
}
interface Inttr01{
void c1();
}
interface Inttr02{
void c1();
}
class Clas implements Inttr01,Inttr02{
@Override
public void c1() {
System.out.println("多个抽象方法中有相同的抽象名时，只重写一个就够了");
}
}
2.2.5 默认方法一致需重写
package com.bdit.test;
//接口中，有多个默认方法时，实现类都可以继承使用，如果默认方法有重名，必须要重写一 次。
public class Ttest09 {
public static void main(String[] args) {
Caa caa =new Caa();
caa.deff01();
}
}
interface Intre01{
default void deff01(){
System.out.println("Intre01中的默认方法");
}
}
interface Intre02{
default void deff01(){
System.out.println("Intre02中的默认方法，但与01中的方法名一致");
}
}
class Caa implements Intre01,Intre02{
@Override
public void deff01() {
System.out.println("Caa中重写的默认方法");
}
}
2.3 接口的基本实现
类与接口的关系为实现关系，即类实现接口，该类可以成为接口的实现类，也成为接口的子类，实现类类似继承，格式类似，只是关键字不同，实现接口用 implements 关键字。实现接口也是一种特俗的继承关系非抽象子类实现接口：必须重写接口中所有的抽象类继承了接口的默认方法，即可以直接调用，也可以重写
访问修饰符 class 类名 implements 接口名{
}
2.4 接口的多实现
在继承中一个类只能继承一个父类，但对于接口而言，一个类可以继承多个接口，这叫接口的多实现，而且一个类只能继承一个父类同时还能同时实现多个接口，如本文的：2.2.3 接口多实现
访问修饰符 class 类名 [extends 父类] implements 接口 1,接口 2,接口 3,…{ }
[]：表示可选操作
2.5 静态方法
默认方法、抽象方法、等如果一个接口中有多个默认方法，但是多个默认方法都重名，必须要重新给一次
接口中，存在同名的静态方法并不会冲突，原因是只能通过各自的接口名访问静态方法
2.6优先级的问题
当一个类，即继承了一个父类，又实现了若干个接口时，父类中的成员方法与接口中的默认 方法重名，子类就近选择执行父类的成员方法
2.7 接口的多继承
一个接口能继承多个接口，接口的继承也是使用 extends 关键字，而且多个接口之间使用逗 号隔开即可。子接口继承了父接口的方法，如果某个类实现了子接口，就要实现子接口以及 父接口中所有的抽象方法。【如果父接口中的默认方法有重名的，那么子接口需要重写一次】。
package com.bdit.test;
public class Test10{
public static void main(String[] args) {
System.out.println(Interff03.a);
Inclass inclass = new Inclass();
inclass.t1();
inclass.t3();
Interff02.tt2();//只能通过各自的接口名访问静态方法
}
}
interface Interff01{
int a = 100;
void t1();
private void t2(){
System.out.println("Interff01的私有方法");
}
default void t3(){
t2();
System.out.println("Interff01的默认方法");
}
}
interface Interff02{
public static void tt2(){
System.out.println("tt2");
}
}
interface Interff03 extends Interff01,Interff02{
}
class Inclass implements Interff03{
@Override
public void t1() {
System.out.println("t1");
}
@Override
public void t3() {
}
}
