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;
}
}
接口中可以定义接口,接口中内部类中,也可以定义接口
所有的内部接口默认都是静态的;