java-abstract（抽象）、interface（接口）、内部类-day10

abstract（抽象）
关键字，修饰符 方法、类
1.概念
当所以的子类对父类的摸个方法都进行不同程度的重写，那么这个方法的方法
没有实际含义就可以把方法体去掉加上absract关键字修饰方法—，抽象方法。
一个类中如果出现抽象方法那么这个类就要边城抽象类。普通类继承抽象类需
要重写所有抽象类，如果不想抽象所有的抽象方法可以吧普通类变成抽象类
注意：
1.抽象方法能不能重载？可以重载
2.抽象类中一定含有抽象方法？ 不一定
3.抽象类中可以去定义属性以及普通方法？可以
4.抽象类可以定义构造方法、? 可以
5.抽象类中可以创建对象？抽象类没有对象
6.抽象方法可以被private/static/final单独修饰吗？不可以抽象类一定要重写
7.抽象类可以被fianl修饰？不可以 最终类不能被继承
8,。抽象类的没目的就是为了延展类 的继承结构

package cn.tedu.abstractx;

public class AbstractDemo1 {
    public static void main(String[] args) {
        //对象是匿名内部类的对象
        Shape s=new Shape(1,2) {
            @Override
            public double getGirth() {
                return 0;
            }
        };//匿名内部类
    }
}


//代表图形的类
//当类中出现抽象方法时类要变成抽象类
abstract class Shape{
    //私有化属性
    private double x;
    private double y;


    //提供构造方法来进行属性初始化
    public Shape(double x, double y){
        this.x=x;
        this.y=y;
    }

    //提供get方法
    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }


    //提供求周长和面积的方法
    //抽象方法---1.没有方法体  2.一定要重写
    public abstract double getGirth();
    //重载抽象方法
    //public abstract double getGirth(int i);
    //普通方法---实体方法
    public double getArea(){
        return 0.0;
    }



}

//代表矩形的类
//当普通类继承抽象类需要重写所有的抽象方法
//如果普通类不想重写抽象类中所有的抽象方法可以变为抽象类
abstract class Rectangle extends Shape {

    public Rectangle(double x, double y) {
        super(x, y);
    }

    //重写求周长和面积的方法
   /* public double getGirth(){
        return 2*(getX()+getY());
    }*/
    public double getArea() {
        return getX() * getY();
    }
}



    //代表正方形的类
    class Square extends Rectangle{

        public Square(double x) {
            super(x,x);
        }
        //重写求周长的方法
        public double getGirth(){
            return 2*(getX()+getY());
        }
    }

//代表圆形的类
class Circle extends Shape {

    public Circle(double r) {
        super(r, r);
    }

    //重写求周长和面积的方法
    public double getGirth() {
        return 2 * 3.14 * getX();
    }

    public double getArea() {
        return 3.14 * getX() * getX();
    }
}

interface（接口）
1.概念
当抽象类中所有的方法都是抽象方法时可以吧抽象类变成接口表示（用interface）
接口的本=本质不是个类，Java支持接口与接口之间的多继承，类与接口之间是
多实现就是为了实现类具有跟多丰富的功能，实现类需要重写接口所有的抽象
方法单如果不想都重写那就把实现类变成抽象类
注意：
1。接口里面的方法都是抽象方法？借口里的方法都是抽象方法（和版本有关系）
2.接口里可以定义构造方法？不能定义
3.接口可以创建对象？不能
4.接口可以去定义属性？可以定义属性 默认被 public final tatic 共同修饰
5,。接口声明的对象在编译时期可以就接受所有的类型对象的赋值，但是在
运行时期 检测对象实际类创建类是否是接口的实现类
6.在接口的目的就是让实现类注入更多的特此特性

package cn.tedu.interfacex;

import java.io.Serializable;

public class InterfaceDemo1 {
    public static void main(String[] args) {
        //System.out.println(Shape.i=2);
    }
}


//代表图形的类
//当抽象类里都是抽象方法时可以把类转成接口来表示
//接口本质不是类
//接口与接口之间支持多继承
interface Shape extends Cloneable, Serializable {
    //属性，默认被public final static共同修饰
    public final static int i=1;

    //抽象方法默认被Public abstract默认修饰
    public abstract double getGirth();
    double getArea();
}

//代表矩形类---普通类
//implements---代表类与接口之间的实现关系
//实现类
//类与接口之间支持多实现
//实现类需要把接口里的所有抽象方法进行重写，如果不想都重写可以把实现类变成抽象类
abstract class Rectangle implements Shape ,Cloneable{
   /* @Override
    public double getGirth() {
        return 0;
    }*/

    @Override
    public double getArea() {
        return 0;
    }
}

2.抽象类和接口的区别
1.接口不是类
2.接口里只有抽象方法
3.类与接口支持多实现，接口与接口支持多继承
4，接口里属性和抽象方法有默认修饰符
5，抽象类有构造方法
6，抽象类是为了延展类的继承结构，接口是为了注入更多特性

3.接口的优点
模板、约束
内部类
类、接口里再定义一个类、
1.类里定义一个类
方法内部类
在方法内定义类
可以定义所有的非静态信息以及静态常量
可以正常的继承和实现
不能访问修饰符来修饰但是可以被abstract和final修饰
可以获取外部类所有的信息
只能获取当前方法的常量信息

package cn.tedu.inner;

public class InnerDemo1 {
    public static void main(String[] args) {
        //创建外部类对象调用方法执行创建内部类对象的语句
        new Outer1().m();
    }
}


//外部类
class Outer1{
    //属性
    static int k=1;
    //方法
    public void m(){
        int y=1;//在jdk1.8以前定义常量需要手动加上final
                //在jdk1.8及其以后定义变量时底层默认会添加final但是如果手动添加了
                //底层就不再添加

        //方法内部类
        //定义所有非静态信息以及静态常量
        //可以正常的继承与实现
        //不能被访问权限修饰符来修饰但是可以被abstract以及final来修饰
        //可以获取外部类所有的信息
        //只能获取本方法的常量
        class Inner1 extends Object implements Cloneable{
            static final int x=1;
            public void n(){
                System.out.println(k);
                System.out.println(y);
            }
        }



        //创建方法内部类对象
        Inner1 in1=new Inner1();
        in1.n();



    }
}

2.成员内部类
在成员位置定义类
可以定义所有的非静态信息以及静态常量
可以正常的继承和实现
可以被访问权限修饰符以及abstract和final修饰修饰
可以获取外部类所有信息
Outer2.Inner2 inner2=new Outer2().new Inner2();

package cn.tedu.inner;

import java.util.Scanner;

public class InnerDemo2 {
    public static void main(String[] args) {
        //Outer2.Inner2表示内部类
        //Outer2.Inner2 inner2=new Outer2().in2;
        //in2=new Inner2();
        Outer2.Inner2 inner2=new Outer2().new Inner2();

    }
}
//外部类
class Outer2{
    //属性
    static int k=1;


    //非静态属性
    //Inner2 in2=new Inner2();

    //成员内部类
    //可以定义所有的非静态信息以及静态常量
    //可以正常的继承和实现
    //可以让访问权限修饰符以及abstract和final来修饰
    //可以获取外部类所有的信息
    class Inner2 extends Object implements Cloneable{
        static final int x=1;
        public void n(){
            System.out.println(k);
            m();
        }
    }


    //方法
    public void m(){}
}

3.静态内部类
成员内部类被static来修饰
可以定义所有信息
可以正常继承和实现
可以被访问权限修饰符以及abstract和final修饰修饰、
只能获取外部类的静态信息
Outer3.Inner3 inner3=new Outer3.Inner3();

package cn.tedu.inner;

public class InnerDemo3 {
    public static void main(String[] args) {
        //创建静态内部类对象
        Outer3.Inner3 inner3=new Outer3.Inner3();

    }
}


//外部类
class Outer3{
    //属性
    static int k=1;

    //
    static Inner3 in3=new Inner3();

    //静态内部类
    //可以定义所有信息
    //可以进行正常的继承和实现
    //可以让访问权限修饰符以及abstract和final来修饰
    //只能获取外部类静态信息
    static class Inner3 extends Object implements Cloneable{
        static final int x=1;
        public void n(){
            System.out.println(k);
        }
    }


    //方法
    public void m(){}
}

4.匿名内部类
用于继承类/实现接口、重写抽象方法
可以被继承的类/接口都可以拥有匿名内部类的形式
匿名内部类只能使用一次
当做参数传递时使用

package cn.tedu.inner;

public class InnerDemo4 {
public static void main(String[] args) {
//创建抽象类子类对象
/* D d=new D();
d.m();*/

    //匿名内部类
    //继承类，重写抽象方法，创建匿名内部类对象
    //当类可以被继承/是接口时，拥有匿名内部类的形式
    //只能使用一次
    C c=new C() {
        @Override
        public void m() {
            System.out.println(1);
        }
    };
    c.m();

    //普通类也具有匿名内部类的形式
    B b=new B(){};

    //接口也具有匿名内部类的形式
    A a=new A() {
    };


    //调用方法
    //匿名内部类当做参数使用
    m(new A(){});
}


//
public static void m(A a){//只能接收A接口的实现类对象

}

}

//接口
interface A{}


//普通类
class B{}


//抽象类
abstract class C{
    public abstract void m();
}
class D extends C{
    @Override
    public void m() {
        System.out.println(1);
    }
}

接口里定义类/内部接口默认都是被static修饰

package cn.tedu.inner;

public class InnerDemo5 {
    public static void main(String[] args) {
        System.out.println(Outer5.Inner5.i);
        System.out.println(Outer5.Inner6.j);
        System.out.println(Outer5.Inner5.Inner7.x);
    }
}


interface Outer5{

    //接口里定义接口，默认被static修饰
    static interface Inner6{
        int j=1;
    }

    //接口里定义内部类默认被static修饰
    static class Inner5{
        static int i=1;

        //类里定义接口,默认被static修饰
        static interface Inner7{
            int x=1;
        }
    }
}