小梁同学 の
Java学习旅途
你好! 这是小梁同学使用 博客 所记录的文章笔记,作为一个初学者的从基础到未来的记录,如果你想和我一起在Java学习路程上坚持下去,欢迎你的关注与指正。
新的将来
万丈高楼平地起,未来只能靠自己
从无到有,从零到一,学习路上没有尽头
每日一文,每日一记,跟着软件向前努力
加油!!!!!
详解代码均在以下标题后的链接中
以下所有有关代码,都是个人在上完课后自己重新敲代码之后所做笔记后上传,并非原搬直接上传,谢谢理解
十.接口
1.定义:
接口:interface ==》只有功能,没有特征
数据类型中,只注重功能,可以用接口进行表示
接口中的方法 默认是被public abstract修饰抽象方法
2.书写及接口实现
public interface Shape{
//public abstract void area();
void area();
}
//实现类 实现 父接口======》多实现
public interface A{
void a();
}
//类类型 可以写方法==》建立类和接口的关系 实现
public class Circle implements Shape,A{
@Override
public void area(){
}
@Override
public void a(){
}
}
3.继承在前实现再后
一个类可以继承类的同时实现接口,继承在前实现再后
public class Circle extends Pet implements Shape,A{
@Override
public void area(){
}
@Override
public void a(){
}
}
4.类和接口的关系:
1 类和类之间:
**单根继承:**类和类之间出现了相同的代码,继承
2 类和接口之间:
**多实现:**一个类需要有多种功能,类实现接口
写项目,先创建接口,再写实现类==》有利于项目的扩展
**抽象类:**都是抽象方法,不能替代接口
**类:**拥有了父类的特征和行为,只需要拥有某个功能===》实现==》面向接口的开发==》mybatis
3 接口和接口之间的关系:
多继承
public interface Shape extents A,B{
}
4 接口和类没有关系
5.static,final关键词
1.常量
接口中 默认被public static final 修饰的变量
public interface Shape extents A,B{
public static final int a=10;
}
2.程序执行流程
1 类加载的问题:
只有使用的类,才能被加载(用到类,这个类就会被加载到内存)=====》类惰性加载
2 对象分配存储空间的顺序
只有new 调用了构造方法,对象才分配了空间,对象才能调用方法
3.static静态的
1.特点:
优先(跟其他的内容进行比较,相比较而言)分配内存
2.static修饰的方法
Static 可以修饰方法,修饰的方法,类方法
通过类名.方法名的方式进行方法的调用
**注意:**如果现在调用的static的方法,和当前使用这个方法的方法再同一个类中,类名可以省略
如果要调用的static方法,和当前使用这个方法的方法不在同一个类中,类名不能省略
Main方法所在的类中,不是只有static方法,只不过调用时,通过对象进行调用
总结:
类可以调用静态方法,不能直接调用普通方法
对象可以调用普通方法,可以调用静态方法
3.static可以修饰
1. static修饰的全局变量===》类变量
2. static修饰的定义方法=》类方法=》static修饰的方法,不能被重写
public class Pet {
public void run(){
System.out.println("pet run");
}
public static void go(){
System.out.println("pet go");
}
}
public class Cat extends Pet{
@Override
public void run(){
System.out.println("cat run");
}
public static void go(){
System.out.println("cat go");
}
}
public static void main(String[] args){
Pet p = new Cat();
p.run();
p.go();
Cat c = new Cat();
c.run();
c.go();
}
============================
cat run//向上转型,动态绑定
pet go//static修饰方法,不被重写
cat run
cat go
3. static 可以修饰代码块===》静态代码块
随着类的加载自动执行,只执行一次
例:static{
逻辑代码:一次执行的代码
}
继承关系的类中代码块输出顺序:
父类静态代码块
子类的static代码块
父类构造代码块
父类的构造方法
子类中的{}的代码块
子类构造方法
4.static不可以修饰
1. static不能修改类:类惰性加载,static优先分配===》冲突
2. static不能修饰局部变量
3. static不能修饰set方法 (this当前对象static类方法,不涉及对象)
4. static不能修饰get方法
5. static不能修饰构造方法
6. static不能修饰抽象方法
抽象方法如果被static修饰,可以被类调用,调用时,方法没有方法体,不能同时static和abstract使用
5.单例
1.private +static 单例
1 构造方法用private修饰
2 类中进行了对象的创建,提供静态方法
3 类中定义一个全局的静态变量 判断变量值的情况给他赋值
2.懒汉模式
public class Print {
//什么时候使用,什么时候创建
private static Print p;
private Print(){
}
public void run(){
System.out.println("打印成功==================");
}
public static Print getInstance(){
if (p==null){
p=new Print();
}
return p;
}
}
public class Test {
public static void main(String[] args) {
int a=1;
System.out.println(a);
Print.getInstance().run();
int b = 2;
System.out.println(b);
Print.getInstance().run();
}
}
============================
1
打印成功==================
2
打印成功==================
3.饿汉模式
public class Print {
//对象创建功能,不管是否使用,对象都已经存在
private static Print p=new Print();
private Print(){
}
public void run(){
System.out.println("打印成功==================");
}
public static Print getInstance(){
return p;
}
}
public class Test {
public static void main(String[] args) {
int a=1;
System.out.println(a);
Print.getInstance().run();
int b = 2;
System.out.println(b);
Print.getInstance().run();
}
}
============================
1
打印成功==================
2
打印成功==================
6.final
最终的,最后的,不能修改的===》文件,只读,只能看,不能改
**final修饰的数据:**只能看,不能改(普通的变量)
7.java中可以被final修饰:
1.final可以修饰类(不影响我们创建对象)===》final修饰的类不能被继承
2.final可以修饰全局变量
全局变量赋值方式:
1.定义变量时,进行final变量的赋值
2.可以在构造方法中赋值
3.可以在构造代码块中赋值
3.final修饰局部变量
4.final可以修饰get/set===>但是一般不这么用
8.java中不能被final修饰:
1.final不能修饰构造方法
2.final不能修饰抽象方法
9.static final
static final修饰的常量===>大写字母表示
static final 修饰的是基本数据类型,int A =100;A的值不能改变
static final 修饰的是引用数据类型, int[] ARR=new int[10];地址不能变
10.接口与抽象类
1.相同点
常量,抽象方法,向上转型,方法重写的功能,动态绑定,多态
通过类进行的方法的实现
Jdk1.8,接口中可以有普通方法 用default修饰 和静态方法
public interface Shape{
void area();
public default void a(){
}
public static void test(){
}
}
都可以使用匿名内部类进行实现
2.不同点
**接口:**默认被public static final 默认都是抽象方法
**接口:**注重的是功能,功能进行描述
**类和抽象类的关系:**单根继承
接口中可以用lambda表达式实现===>接口中只能有一个抽象方法,但可以有多个普通方法
//无参无返回值方法的实现
void area();
Shape2 s1 = ()->{
System.out.println("表达式进行的实现");
};
s1.area();
//有参无返回值方法的实现
void area(int a,int b);
Shape2 s1 = (a1, b1)->{
System.out.println("表达式进行的实现"+a1+b1);
};
s1.area(10,100);
//无参有返回值的实现
int area();
Shape2 s1 = ()->{
return 100;
};
System.out.println(s1.area());
//有参有返回值的实现
int area(int a,int b);
Shape2 s1 = (a,b)->{
return a*b;
};
System.out.println(s1.area(19,10));
**抽象类:**可以是任意的访问权限修饰符常量,(三个访问权限修饰符)抽象方法
**类:**具有相同特征和行为的一类事物
**类和接口的关系:**多实现
抽象类包含static{} ,构造代码块,构造方法
java入门基础—1.5----上一章节: 跳转
java入门基础—1.7----下一章节: 跳转