Java 知识点锦集 2

代码块

final 关键字

抽象类

接口

接口与抽象类区别

结语

代码块代码块的定义：

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

代码块的使用：[修饰符] {代码；}；注意：

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

静态代码块 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 用来修饰变量:此时的"变量"就称为是一个常量

5. 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 类是抽象类的子类，是一个普通类

@Overridepublic 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

这多是一件美逝啊~

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