Java学习之路（基础二）

最新推荐文章于 2022-12-04 18:12:42 发布

CS_GaoMing

最新推荐文章于 2022-12-04 18:12:42 发布

阅读量200

点赞数

分类专栏： Java基础学习文章标签： Java基础学习

本文链接：https://blog.csdn.net/CS_GaoMing/article/details/83188329

版权

Java基础学习专栏收录该内容

18 篇文章 0 订阅

订阅专栏

Java制作帮助文档

帮助文档制作的基本语法格式：
dos下：javadoc -d document -author -version ArrayTool.java

代码块

用"{}" 包裹起来的代码都叫做代码块。
常见有以下几类：
- 局部代码块
  在类的方法中"{}"包裹的部分，目的是为了及时释放内存。
- 构造代码块
  在类中用"{}"包裹起来的部分，把多个构造方法的相同部分放在此处，加载在对象构造方法之前。
- 静态代码块
  在类中用static修饰，且由"{}"包裹起来的部分，对类进行初始化时候即加载，相对于以上，最早。
- for example：

		class animal{
			{
				构造代码块
			}
			static{
				静态构造代码块			
			}
			public static void main(String[] args){
				{
					局部代码块
				｝
				System.out.println("测试代码块");
			}
			
		}

- 加载顺序：
	可以描述为：静态代码块 > 构造代码块 > 构造方法.

继承(extends)

定义：

将多类中的相同部分抽取出来定义一个类，然后其他的类继承该类。
语法：class SonClass extends FatherClass.
分析：
代码具有良好的复用性，类之间的关系是多态的一个前提，但是耦合性增强导致改变一个类可能会引起其他类的改变。
PS：利于代码的维护？（耦合和方便同时存在,而编程的原则是：低耦合，高内聚。）
基本规则

class FatherClass extends GradpaClass；
class SonClass extends FatherClass；

但是不能：

class a extends b,c;

结构体不能由表示返回数据类型的修饰符修饰，如：void,int,float…否则不会识别成结构体 。
子类继承父类，它是会将父类初始化的，所以必定会加载类似于父类的：静态代码块，结构代码块，构造方法(默认无参构造，若没有则需要子类的带参构造下用：super(VaribleNum1.VaribleNum2))初始化，不然报错，该句之前不能写任何代码，不然也报错。
子类继承

由private修饰，不能继承；父类构造方法不能继承，但是若：

	class FatherClass{
		private DataType VariableNum1;
		private DataType VariableNUm2;
		FatherClass(){
			System.out.println("FatherStructure");
		}
		public void FaTherClass(DataType VaribleNum1,DataType VaribleNum2){
			this.VaribleNum1 = VaribleNum1;
			this.VaribleNUm2 = VaribleNum2;
		}
		
	}
	class SonClass extends FatherClass{
		SonClass(){
			System.out.println("SonStruture");
		}
		SonClass (DataType VaribleNum1,DataType VaribleNum2){
			/*下面这种写法是错误的。
			this.VaribleNum1 = VaribleNum1;
			this.VaribleNUm2 = VaribleNum2;
			*/
			//此处是调用父类的带参初始化父类，不然报错。
			super(VaribleNum1，VaribleNum2);
		}
	}
	class Modle(){
		public static void main(String[] args){
			SonClass Sonfile = new SonClass();
			SonClass Sonfile = new SonClass(VaribleNum1,VaribleNUm2);
		}
	}

则输出结果为：

	FatherStruture；
	SonStructure；
	原理为：访问父类的初始化，所以默认访问父类无参构造，。

若需要保护父类，则需要添加private修饰，再通过父类的公有方法调用，若没有写该方法，只写了父类的构造方法去调用pivate修饰的数据，则：

	//不得写任何代码，不然报错。
	super(VaribleNum1, VaribleNum2)

继承中的变量查找顺序：

	子类方法局部变量 -> 子类成员变量 -> 父类成员变量 -> 报错。

final

重要修饰符，被final修饰符修饰的数据，不能重写。具体表现在：修饰类，类不能被继承;修饰方法，方法不能被重写；修饰变量，常量变为常量。
修饰变量为基本类型，表示的是变量值不能修改。
若是引用类型，则表示是地址不能修改，但是内容可以修改，如:
Animal ani = new Animal();
ani = new Animal(); //报错.
ani.age = 10; //并不会报错.

多态

个人理解：多态的本质是通过近似数据结构类型的数据，在不同需求下表现为不同的具体数据结构类型，它是基于extends/implements关系的建立去实现的。
在extends/implements连接继承与被继承，实现与被实现关系的前提下，由于父类(具体使用中父类一般为抽象类)/接口的抽象性，所以需要对其方法进行重写。
private构造方法禁止创建对象，但使用static修饰后，方法直接通过类名调用。。

多态的编译与运行原理：

由于，是右边往左边的顺序执行的，所以，将右边的数据类型按照左边的数据类型展现，他本质是右边的数据类型。
但是在编译过程中，检查的是语法，和基本的逻辑性，所以在具体的类中，若以左边的数据结构去调用右边子类特有的方法，会报错。

/*for example*/
class FuClass{
	public void printline(){
		Sysotem.out.prinln("FuPrintln");
	}
}
class SonClass extends FuClass{
	public void printline(){
		System.out.println("SonPrintln");
	}
	public void SpecialSon(){
		System.out.println("SonSpecial");
	}
}

...main body...

	FuClass FS = new SonClass();
	FS.printline();	//SonPrintln
	FS.SpecialSon()	//error

多态存在
- 继承父类为具体类.
- 继承父类为抽象类.
- 实现父类为借口。
多态访问规则
由原理有：
- 编译语法检测–都在测试左边的合法性。
- 成员变量，由类的加载顺序可以得到，输出为父类。
- 构造方法，由类的加载顺序可以得到，默认访问父类无参构造。
- 成员方法，输出为子类的成员方法，基于重写，没有则父类成员方法。
- 静态方法,由类的加载顺序可以得到,输出为父类。
利弊分析
- advantage：代码的维护性与复用性明显会有一个提升，这点是毋容置疑的。
- disadvantage：由于它是基于继承的关系建立，所以他可能将相关度不高的东西关联起来了，所以增加了代码之间的耦合性，而增加了维护，且与“低耦合，高内聚”的coding规则违背。
- 争议点(个人认为)：在数据使用过程中一般是严格按照是什么数据类型就遵守分配对应数据类型的空间，但是在有些时候可以利用多态，将不同的数据类型的数据拉成"表"，这对遍历不同数据类型但从属于一个大类非常有利，但是要使用对应的子类特有功能/重新的功能，只能通过强行上转来实现，这增加了实现相同内容的步骤。

abstract类

描述:由abstract修饰的类是抽象类，但是其成员方法可以没有抽象方法；由abstract修饰的方法，若处于类中，则类必须由abstract修饰，成为抽象方法。它需要子类的继承和重写，是相关事物的集合体。
抽象类的构造方法不用abstract修饰。
即：抽象方法是抽象类的充分不必要条件，抽象类是抽象方法的必要而不充分条件，可以数学表达为：抽象方法 -> 抽象类；

但：抽象类 \( \ne > 抽象方法 \)
成员：
- 成员变量：可以是变量，也可以是常量，当作具体类使用.
- 构造方法：有构造方法，做初始化用。
- 成员方法：有抽象方法，非抽象方法；抽象方法必须重写or继承的子类也是抽象方法。
- form:

	abstract class Animal{
		public abstract void basedata();不能有结构体，具体类继承需要重写。
		public  Animal(){} //不能abstract修饰，访问父类数据，进行初始化.
	}

抽象类无抽象方法：目的是不让创建对象，进行实例化,但有构造方法。
多关键字与abstract：
- final：冲突，报错。
- private：冲突，报错。
- static：无意义。

interface

描述：是事物扩展方法的集合体，不是由事物本身所具有的方法，可以多实现implements。
语法格式：interface interfaceName{}.
子类继承格式：class className implements interfaceName{}.
接口不能与抽象方法一样是不能实例化的，继承子类也一样，具体类抽象类/具体类，需要重写所有抽象方法。
由于是功能/方法的扩展，所以是没有构造方法的，所有类默认继承object。
成员规则：
- 成员变量：系统自动修饰符:public static final，只能是常量。
- 构造方法:不属于类，是扩展方法，抽象化的集合，所以无构造方法。
- 成员方法：所有成员方法只能是抽象的，区别于抽象类，系统默认public abstract.