小梁同学 の
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 类中定义一个全局的静态变量 判断变量值的情况给他赋值
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 finalstatic 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----上一章节: 跳转
