Java知识点锦集2

⭐️大一小何，还在学习当中，欢迎交流指正~

代码块

代码块的定义：

使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块

代码块的使用：

[修饰符] {
代码；
}；
注意：

1. 修饰符可写可不写，要写的话，只能写static
2. 代码块分为两类，使用static修饰的是静态代码块，没有static修饰的是普通代码块。
3. ；号可写可不写

静态代码块
1.内部可以有输出语句
2.随着交的加载而执行,而且只执行一次>作用:初始化类的信息
3.如果一个类中定义了多个静态代码块,则按照声明的先后顺序执行>静态代码块的执行要优先于非静态代码块的执行
4.静态代码块内只能调用静态的压性、静态的方法,不能调用非静态的结构

非静态代码块
1.内部可以有输出语句>随着对象的创建而执行
2.每创建一个对象,就执行一次非静态代码块
3.作用:可以在创建对军时,对对象的乐性等进行初始化
4.如果一个类中定文了多个非静态代码块,则按照声明的先后顺序执行
5.非静态代码块内可以调用静态的属性、静态的方法,或非静态的在性、非静态的方法

对属性可以赋值的位置,
默认初始化
显式初始化

构造器中初始化
有了对象以后,可以通过""对象.属性“或"对象.方法"的方式,进行赋值

在代码块中赋值

举个栗子

class Code {
    static {
        int a = 1000;
        System.out.println(a);
    }

    //构造代码块
    {
        int x = 100;
        System.out.println(x);
    }
    
    //构造方法
    public Code(){
        System.out.println("code");
    }
    
    //构造方法
    public Code(int a){
        System.out.println("code");
    }
    
    //构造代码块
    {
        int y = 200;
        System.out.println(y);
    }
    
    //静态代码块
    static {
        int b = 2000;
        System.out.println(b);
    }
}

class CodeDemo {
    public static void main(String[] args) {
        //局部代码块
        {
            int x = 10;
            System.out.println(x);
        }
        //找不到符号
        //System.out.println(x);
        {
            int y = 20;
            System.out.println(y);
        }
        System.out.println("---------------");
        
        Code c = new Code();    
        System.out.println("---------------");
        Code c2 = new Code();
        System.out.println("---------------");
        Code c3 = new Code(1);
    }
}

class Fu {
    static {
        System.out.println("静态代码块Fu");
    }

    {
        System.out.println("构造代码块Fu");
    }

    public Fu() {
        System.out.println("构造方法Fu");
    }
}

class Zi extends Fu {
    static {
        System.out.println("静态代码块Zi");
    }

    {
        System.out.println("构造代码块Zi");
    }

    public Zi() {
        System.out.println("构造方法Zi");
    }
}

class ExtendsTest {
    public static void main(String[] args) {
        Zi z = new Zi();
    }
}

final关键字

final:最终的

1.final可以用来修饰的结构:类、方法、变量

2.final用来修饰一个类:此类不能被其他类所继承。
比如:String类、System类、StringBuffer类

3.final用来修饰方法:表明此方法不可以被重写
比如:Object类中getclass();

4．final用来修饰变量:此时的"变量"就称为是一个常量

1. final修饰属性:可以考虑赋值的位置有:显式初始化、代码块中初始化、构造器中初始化

6.final修饰的方法不能被重写。但是可以重载。要注意的是：父类中private的方法，在子类中不能访问该方法，但是子类与父类private方法相同的方法名、形参列表和返回值的方法，不属于方法重写，只是定义了一个新的方法。

中国古代，什么人不能有后代，就可以被final声明，称为“太监类”! //emmm

//final修饰类
final class A{

}
class B extends A{

}//错误，不能被继承。

//中国古代，什么人不能有后代，就可以被final声明，称为“太监类”!

public class Something {
    public int addone(final int x) {
        //return ++X;哒咩
        return x+1;
}
}

public class Fina1Test {
    //子类无法维承
class InnerSon extends  InnerFathexi{
    //父类被final修饰
finai  c1ass InnerFather{
    }
}
//这是哒咩的！

这里重点讲一下final修饰变量

修饰局部变量

系统不会为局部变量进行初始化，局部变量必须由程序员显示初始化。因此使用final修饰局部变量时，即可以在定义时指定默认值（后面的代码不能对变量再赋值），也可以不指定默认值，而在后面的代码中对final变量赋初值（仅一次）。

代码说明：

public class FinalVar {
    final static int a = 0;//再声明的时候就需要赋值
    public static void main(String[] args) {
        final int localA;   //局部变量只声明没有初始化，不会报错,与final无关。
        localA = 0;//在使用之前一定要赋值
        //localA = 1;  但是不允许第二次赋值
    }
}

修饰成员变量

如果final修饰的是类变量，只能在静态初始化块中指定初始值或者声明该类变量时指定初始值。

如果final修饰的是成员变量，可以在非静态初始化块、声明该变量或者构造器中执行初始值。

修饰基本类型数据和引用类型数据

如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；

如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。但是引用的值是可变的。

抽象类

博主在网上找了个通俗易懂的例子

我们定义若干个类

class BMW

、

class Benz

、

class Audi

，分别对客观事物“宝马”、“奔驰”、“奥迪”三种汽车进行抽象，包含相关属性和行为（即方法）。但是我们知道，汽车都有通用的属性和行为，比如品牌、发动机、方向盘、轮胎等属性，前进、后退、转弯等行为，所以我们可以在宝马、奔驰等汽车之上，进一步抽象出“汽车”类

abstract class Car

，包含通用的特性（属性和方法）。让 BMW、Benz、Audi 等继承抽象类

extends Car

，便拥有了汽车的通用特性，然后在抽象类基础上定义各自的特殊属性及方法。

这里的

abstract class Car

即抽象类，可以看出，抽象类是用来捕捉子类的通用特性的，包括属性及行为

abstract关键字的使用

1.abstract:抽象的
2.abstract可以用来修饰的结构:类、方法
3. abstract修饰类:抽象类
此类不能实例化

抽象类中一定有构造器，便于子类实例化时调用（涉及:子类对象实例化的全过程)

开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

abstract修饰方法:抽象方法
抽象方法只有方法的声明，没有方法体

包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。

若子类重写了父类中的所有的抽象方法后，此子类方可实例化

若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

注意：
1.abstract不能用来修饰:属性、构造器等结构
2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类

实际上抽象类除了被继承没有任何意义！！！

package com.abc.demo;

abstract class A{//定义一个抽象类
    
    public void fun(){//普通方法
        System.out.println("存在方法体的方法");
    }
    
    public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
    
}
//单继承
class B extends A{//B类是抽象类的子类，是一个普通类

    @Override
    public void print() {//强制要求覆写
        System.out.println("Hello World !");
    }
    
}
public class TestDemo {

    public static void main(String[] args) {
        A a = new B();//向上转型
        
        a.print();//被子类所覆写的过的方法
    }
}

接口

接口用interface来定义

定义Java类的语法格式:先写extends，后写implements（实现）

class SubClass extends SuperClass implements InterfaceA{ }

一个类可以实现多个接口，接口也可以继承其它接口。
实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
接口的主要用途就是被实现类实现。(面向接口编程)

与继承关系类似，接口与实现类之间存在多态性

接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲,接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

接口不能定义构造器，意味着接口不可以实例化

如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化

如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

JDK7及以前:只能定义全局常量和抽象方法
全局常量:public static final的.但是书写时，可以省略不写

抽象方法:public abstract的

JDK8:除了定义全局常量和抽象方法之外，还可以定义静态方法

一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。

public interface Electronic {
    // 常量
    String LED = "LED";

    // 抽象方法
    int getElectricityUse();

    // 静态方法
    static boolean isEnergyEfficient(String electtronicType) {
        return electtronicType.equals(LED);
    }

    // 默认方法
    default void printDescription() {
        System.out.println("电子");
    }
}

接口与抽象类区别

抽象类是对类本质的抽象，表达的是 is a 的关系，比如：

BMW

is a

Car

。抽象类包含并实现子类的通用特性，将子类存在差异化的特性进行抽象，交由子类去实现。

而接口是对行为的抽象，表达的是 like a 的关系。比如：

Bote-Royce

like a

Aircraft

（像飞行器一样可以飞），但其本质上 is a

Car

。接口的核心是定义行为，即实现类可以做什么，至于实现类主体是谁、是如何实现的，接口并不关心。

简化版理解：

抽象类：对一类事物的抽象。

接口：对某一行为抽象。

个人觉得，两者最核心的区别是：使用动机

结语

刚接触抽象类和接口，对于我来说有些混淆，在反复分析下，他俩还是可以区分的（抱头痛哭）

真够抽象的hhh

这多是一件美逝啊~

马上新年了哈，提前祝大家虎年快乐，虎年大吉~~~