java学习日志day10
2019年7月10日
温故知新
final(最终)
关键字---修饰值--数据、方法、类
数据—值不能变
class A{
stiatic final i;
静态区的初始值，仅仅是标记初始值，没有实际含义，新版本java弥补了此缺陷
}
final修饰方法时，方法可以重载，不能重写
--–---**–--------------------------–
关于抽象方法 abstract;
如果一个类中存在抽象方法，则必须将类也用 abstact 修饰，将类变成一个抽象类
格式 public abstract 类型 名（）；
public abstract double xx();
抽象方法没有方法体，只是提供了一个方法，让子类重写；
有方法体的方法 例如 public abstract double xx(){return 0.0；}
则被称为普通方法或者实体方法；
如果一个普通类继承了抽象类，抽象方法就一定要被子类重写，否则错误；
如果不想重写所有的抽象方法，就可以将子类 用abstract修饰，变成抽象类；
所有的子类对父类的某个方法都进行了不同程度的重写，父类的这个方法的方
法体就没有实际含义了，就可以把方法体去掉，用 abstract修饰就变成了抽象方法。
抽象方法可以重载
抽象方法不能被 static/final/private 分别修饰，因为被此修饰不能重写
抽象类不一定含有抽象方法，有抽象方法的类一定是抽象类；
抽象类含有构造方法，其他编程语言通过构造方法创建出了对象，但是这个对象对于
java而言无法获取，所以在java角度可以理解为，在java中抽象类无法创建对象
最终类 final类不能被继承
-––*--–----------------**--------*–**-
interface—接口，不是类；
如果一个抽象类中的所有的方法都是抽象方法，则可以将类转变为一个接口
例如
interface Xx{
public abstract double x();
public abstract double y();
}
如何将类与接口产生关联关系
通过关键字 implement --让类与接口产生关联关系
而一个普通类实现了一个接口，就要重写所有的抽象方法；
class Yy implements Xx{
}
如果不想重写所有的抽象方法，则将这个类变成一个抽象类；
例如
abstract class Yy implements Xx{
}
一个类可以实现多个接口
例如
class Yy implements Xx，Zz{
}
接口可以继承接口，接口与接口是同类，且可以多继承
例如
interfaces Xx extends Yy，Zz{
}
注意事项：
接口中不能创建对象；因为不能定义构造方法；
接口内可以给定属性并赋值，但是不能声明，属性值被
public static final 默认修饰；
在java中接口中的抽象方法默认被 public abstract修饰
例如
interface Xx{
double x();
double y();
}
向下转型
关于向下转型，顾名思义，以父类声明 创造子类对象后，再用子类声明原对象
也就是如果以父类声明，则调用父类的方法，如果再想要使用子类的没有被重写的其他
方法和属性时，向下转型；
向下转型时，必须要先向上造型才能向下转型
例如
两个类继承
class A{}
class B extends A{}
在main方法中
向上造型
A b = new B();
再向下转型；
B d = (B)b;
关于interface
类与类之间是树状结构，能够快速检测两个类之间的关系，在编译和运行之间都已经检测
类与接口之间是多实现的网状结构，不能快速检测两个类型之间的关系，所以在编译时期就不检测了，
只在运行时期检测类型之间是否存在实现关系。
接口可以接受所有类型（引用类型）的值的强制转换
如何将实体方法定义在接口中：
从java1.8开始，java提供两种在接口中定义实体方法的方式；
//比如cc是计算机作用
interface cc{
//求和
//实体方法被default修饰–默认实体方法
public default int sum（int m，int n）{
return m+n；
}
第二种方法，被 static定义静态的实体方法
public static int jt（int m，int n）{
return m+n；
}
}
interface ca{
int max（int m，int n）；
}
从jdk1.8开始提供一步重写interface中方法的方式
使用Lambda表达式
Lambda表达式使用的前提是，interface中必须只有一个抽象方法；
ca c =（int m，int n）-> {return m>n?m:n;}
格式 (参数列表)->{重写方法的方法体}
如果方法体只有一句代码就可以省略 return以及{}
例如
ca c =（int m，int n）-> m>n?m:n;
或者 ca c =（ m，n）-> m>n?m:n;
如果interface中只有一个抽象方法，则这个接口就是一个函数式接口。
//给数组进行排序
interface are{
抽象方法
void sort(int[]arr);
}
在main方法中
创建一个新数组
int [] arr ={1,8,6,5,0,2,3};
利用Lambda表达式进行重写
are a = (int[] arr1)->{Arrays.sort(arr1);};
调用接口方法
a.sort(arr);
输出数组
System.out.println(Arrays.toString(arr));
如果一个参数的情况下，可以去掉参数的小括号；
最简形式为 are a =Arrays：：sort 但不常用
两个冒号的意思为，如果一直用的是静态方法则用双冒号；
双冒号后一定保证是静态方法；
接口的优点—优点
1、当做一个约束或者当做一个模板；
2、向上造型类型统一（接口类型）；
----------**-----–------–----–-------------------**–-*
关于内部类
顾名思义 就是类或者接口中再定义一个类
类中再定义一个类
方法内部类
成员内部类
静态内部类
匿名内部类
方法内部类
方法内部类可以定义非静态的属性和方法以及静态常量
可以继承与实现，不能被访问权限修饰符修饰，可以被final
或者 abstract 修饰；
内部类可以获取外部类所有信息，包括private修饰的信息；
可以获取方法内的信息，但是前提是方法内的信息是常量
//外部类
class A{
intj=1；
//方法
public void m(){
//方法内部类
方法内部类可以继承类，也可以实现接口
class Int extends XX implements XY {
static final int i =10;
public void mn(){}
}
Int a = new Int();
}
public void n(){}
}
成员内部类
在main方法创建成员内部类对象方法
XX.XY a =new XX（）.new XX2();
class XX{
创建成员内部类的对象；
new XX（）.new XX2();
XX.XY a =new XX（）.new XX2();
int x =1；
//创建一个成员内部类
可以定义非静态的属性和方法，也可以 extends 继承与 implemment 实现
可以被访问权限修饰符修饰，以及可以 final最终类 与 abstract 抽象
和正常类相同，也可以拿到外部类中的所有属性与方法；
class XX2{
int i = 1；
public void n(){}
}
}
静态内部类
class XX{
int i =1;
静态内部类中，可以定义任意信息
可以 extends 继承与 implement 实现
可以被访问权限修饰符以及 被当做 final最终类以及abstract抽象
只能获取到外部类的静态信息
static class XY{
int k =10；
public void n(){}
}
}
静态内部类在main方法中创建对象时
XX.XY x = new XX().XY();
匿名内部类
匿名内部类的创建
匿名内部类就是在继承抽象类，重写方法
A a = new A（）{
}
匿名内部类亦可以继承普通类，并重写方法
B b = new B（）{
}
匿名内部类也可以实现接口
D d = new D（）{
}
抽象
abstract class A{
方法
public abstract void m（）；
}
普通类
class B{}
接口
interface D{}；
如果匿名内部类在方法中出现，则被看做是一个方法内部类；
如果匿名内部类在成员位置出现，则按成员内部类来使用
在接口中定义一个类
接口中的内部类默认是静态的；
interface A{
static class B{
int i =10；
}
}
关于内部接口
例如
interface A{
static class B{
int i =10；
}
interface D{
int j =100；
}
}
接口中可以定义接口，接口中内部类中，也可以定义接口
所有的内部接口默认都是静态的；