标签：基础 show 类实例化 如何 就是 override super 模板 buffer
本博客随笔主要记录本人学习过程中的知识，欢迎大家一同学习，有不对的地方很高兴读者能详细指出，感激不尽！
饿汉式
class Bank{
// 1.私有化类的构造器
private Bank(){}
// 2.内部创建类的对象
private static Bank instance = new Bank();
// 3.提供公共的静态的方法，返回类的对象
public static Bank getInstance(){
return instance;
}
}
懒汉式
class Order{
// 1.私有化类的构造器
private Order(){}
// 2.声明当前类对象，没初始化
private static Order instance = null;
// 3.声明public、static的返回当前类对象的方法
public static Order getInstance(){
if(instance == null){
instance = new Order();
}
return instance;
}
}
饿汉式：
坏处：对象加载时间过长。
好处：饿汉式是线程安全的。
懒汉式：好处：延迟对象的创建。
目前的写法坏处：线程不安全。
可以用来修饰：类、方法、变量。
具体情况：
可以用来修饰：类、方法。
具体情况：
abstract 修饰类：抽象类
① 此类不能实例化；
② 抽象类中一定有构造器，便于子类实例化时调用；
③ 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作。
abstract 修饰方法：抽象方法
① 抽象方法只有方法的声明，没方法体；
② 包含抽象方法的类，一定是一个抽象类；反之，抽象类中可以没有抽象方法；
③ 若子类重写了父类中的所有的抽象方法后，此子类方法可实例化；
④ 若子类没重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰。
abstract class Template{
//计算某段代码执行所需要花费的时间
public void spendTime(){
long start = System.currentTimeMillis();
this.code();//不确定的部分、易变的部分
long end = System.currentTimeMillis();
System.out.println("花费的时间为：" + (end - start));
}
public abstract void code();
}
class SubTemplate extends Template{
@Override
public void code() {
for(int i = 2;i <= 1000;i++){
boolean isFlag = true;
for(int j = 2;j <= Math.sqrt(i);j++){
if(i % j == 0){
isFlag = false;
break;
}
}
if(isFlag){
System.out.println(i);
}
}
}
}
应用场景:
使用说明：
接口使用interface来定义。
Java中，接口和类是并列的两个结构。
如何定义接口：定义接口中的成员。
3.1 JDK7及以前：只能定义全局常量和抽象方法。
全局常量：public static final的.但是书写时，可以省略不写。
抽象方法：public abstract的 。
3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法。
接口中不能定义构造器的！意味着接口不可以实例化。
Java开发中，接口通过让类去实现(implements)的方式来使用。
如果实现类覆盖了接口中的所抽象方法，则此实现类就可以实例化。
如果实现类没覆盖接口中所的抽象方法，则此实现类仍为一个抽象类。
Java类可以实现多个接口 --->弥补了Java单继承性的局限性
格式：class AA extends BB implements CC,DD,EE
接口与接口之间可以继承，而且可以多继承。
接口的具体使用，体现多态性。
接口，实际上可以看做是一种规范。
开发中，体会面向接口编程！
Java8中关于接口的新规范
知识点1：接口中定义的静态方法，只能通过接口来调用。
知识点2：通过实现类的对象，可以调用接口中的默认方法。
如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则
知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
那么在实现类没重写此方法的情况下，报错。-->接口冲突。
这就需要我们必须在实现类中重写此方法
知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
调用自己定义的重写的方法:
method()
调用的是父类中声明的方法:super.method()
调用接口中的默认方法:接口名.super.method()
具体代码实现：
interface NetWork{
void browse();
}
// 被代理的类
class Server implements Network{
public void browse(){
System.out.println("真实服务器访问网络");
}
}
// 代理类
class ProxyServer implements Network{
private Network network;
public ProxyServer(Network network){
this.network = network;
}
public void check(){
System.out.println("联网之前的检查工作");
}
public void browse(){
check();
network.browse();
}
}
一方面，作为外部类的成员：
调用外部类的结构；
可以被static修饰；
可以被4种不同的权限修饰。
另一方面，作为一个类：
类内可以定义属性、方法、构造器等；
可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承；
可以被abstract修饰。
//创建静态的Dog内部类的实例(静态的成员内部类):
Person.Dog dog = new Person.Dog();
//创建非静态的Bird内部类的实例(非静态的成员内部类):
//Person.Bird bird = new Person.Bird();//错误的
Person p = new Person();
Person.Bird bird = p.new Bird();
public class Person{
String name = "小明";
public void eat(){
}
//非静态成员内部类
class Bird{
String name = "杜鹃";
public void display(String name){
System.out.println(name);//方法的形参
System.out.println(this.name);//内部类的属性
System.out.println(Person.this.name);//外部类的属性
Person.this.eat();
}
}
}
//返回一个实现了Comparable接口的类的对象
public Comparable getComparable(){
//创建一个实现了Comparable接口的类:局部内部类
//方式一：
// class MyComparable implements Comparable{
//
// @Override
// public int compareTo(Object o) {
// return 0;
// }
//
// }
//
// return new MyComparable();
//方式二：
return new Comparable(){
@Override
public int compareTo(Object o) {
return 0;
}
};
}
注意点：
在局部内部类的方法中（比如：show如果调用局部内部类所声明的方法(比如：method)中的局部变量(比如：num)的话,要求此局部变量声明为final的。
jdk 7及之前版本：要求此局部变量显式的声明为final的。
jdk 8及之后的版本：可以省略final的声明。
总结：
成员内部类和局部内部类，在编译以后，都会生成字节码文件。
格式：
标签：基础 show 类实例化 如何 就是 override super 模板 buffer
原文地址：https://www.cnblogs.com/mango-peel527/p/13084185.html
