Java知识点锦集2

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

Java知识点锦集2_第1张图片

 

目录

代码块

final关键字

抽象类

接口

 接口与抽象类区别

结语


代码块

代码块的定义:

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

代码块的使用:

[修饰符] {
代码;
};
注意

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


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 BMWclass Benzclass 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

这多是一件美逝啊~

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

Java知识点锦集2_第2张图片 

 

你可能感兴趣的:(javase,java,开发语言,后端)