java基础相关3（staic，类，修饰控制符）

Java基础相关

方法

在某些语言中叫函数，它是完成特定任务的独立代码单元。

方法的作用

• 让代码易于复用，避免编写重复的代码，提高编程的效率；
• 让程序更加模块化，减少代码重复，从而提高程序的可读性，便于后期的维护；
• 封装一段特定的业务逻辑功能；
• 方法尽可能独立，一个方法只干一件事；

方法的定义

修饰词  返回值类型  方法名(参数列表){
    方法体
}

//示例
public static int sum(int m, int n) {
return m + n;
}

• 若方法没有参数，则参数列表为空即可；
• return代表方法结束，并返回数据给调用者；
• 若没有返回值，则声明类型为void，此时无需return。

方法签名

方法名和参数表共同构成方法签名。

方法的调用

• 无返回值: 方法名(有参传参);
• 有返回值: 数据类型 变量 = 方法名(有参传参);

return：

• return 值; —>结束方法的执行 1.2)返回结果给调用方------写在有返回值的方法中
• return; —>结束方法的执行-------------------------写在无返回值的方法中

方法重载： --简化方法的调用

重载：方法名相同且参数列表不同，与返回值类型无关。

• 在同一个类里，定义多个名称相同、参数列表不同的方法，叫做方法重载。
• 方法重载的作用：对于调用者而言，多个重载的方法就像是一个方法，便于记忆、便于调用。
• 编译器在编译时会根据方法的签名自动绑定调用的方法

class类

了解Java类先大概了解一下面向对对象

Java是一门面向对象的语言。

面向过程编程：Procedure Oriented Programming，流行于60年代；

​ 分析出解决问题的步骤，然后用函数逐一实现每一步，再依次调用这些函数。

******面向对象编程：Object Oriented Programming，从70年代流行至今；

​ 分析出系统中应包含哪些对象**，以及它们之间的关系，再用特定语法描述这些对象和关系。

类和对象的关系：

类：对事物的抽象，把一类物体的共同特性进行封装，形成一个Java文件

​ 对事物组成的抽象，叫做属性

​ 对事物行为的抽象，叫做方法

对象：是类的具体实例

• 类是“设计图”，用于描述一批对象的信息，它是抽象的，不是具体的实例；
• 对象是具体的，是根据类的描述，由JVM创建出来的一个实例，这个过程叫实例化；
• 类是自定义的数据类型，通过这个类创建对象，实际上就是初始化这种类型的变量。

**可以总结为：**类是对象的模板，对象是类的具体的实例

类中可以包含:

• 对象所共有的属性/特征------------成员变量
• 对象所共有的行为/动作------------方法

一个类可以创建多个对象

class类：java程序的基本组成单元是类

如何定义类：

修饰符 class 类名 {
成员变量...
成员方法...
}

• 成员变量：
  • 属性 对象的静态特征； 用变量来描述，这样的变量叫成员变量。
• 成员方法：
  • 行为 对象的动态特征； 用方法来描述，这样的方法叫成员方法。

类中的变量

1.成员变量(全局变量)

在类体中定义的，在函数和静态语句块之外的变量称为成员变量，成员变量在整个类体中有效。

成员变量又可分为 静态变量（类变量） 和 实例变量。

class var{
static int y = 90;
int x = 45;
}

其中x为实例变量，y为静态变量（也称为类变量）。

• 实例变量总是通过对象来访问，因为它们的值在对象和对象之间有所不同。

• 静态变量（类变量）用static修饰，作用域是可以跨类的，甚至可以达到整个程序之内，对于静态变量（类变量），除了可以在定义它的类内存取，还能直接以 “类名.静态变量” 的方式在其他类内使用。它可以直接用类名调用 也可以用对象调用 而且所有对象的同一个类变量都是共享同一块内存空间的.

2.局部变量

在类的方法体内定义的变量（在方法内部定义，大括号{}之间的代码中声明的变量）。称为局部变量，局部变量只在当前代码块中有效。因为只能在方法内部使用，固不可以用private，public，protect来修饰。

3具体说明：

• 局部变量：方法声明时形参、语句块中声明中的形参
• 全局变量：可以将成员变量视为全局变量，
• 变量的作用域：局部变量作用于当前的语句块，全局变量作用于整个类。

实例变量和类变量的区别

两个变量的生命周期不同

• 实例变量随着对象的创建而存在，随着对象的回收而释放。
• 静态变量随着类的加载而存在，随着类的消失而消失。

调用方式不同

• 实例变量只能被对象调用。
• 静态变量可以被对象调用，还可以被类名调用。

数据存储位置不同

• 实例变量存储在堆内存的对象中，所以也叫对象的特有数据。
• 静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

在现代的面向对象语言如Java，C++，C#，Ruby中，由于变量都是封装在类里面的，对别的类不可见，所以已经几乎完全抛弃了全局变量的概念。然而，可以通过把一个类定义为public static，把类成员变量也定义为public static，使该变量在内存中占用固定、唯一的一块空间，来实现全局变量的功能。

成员方法

语法

修饰符 返回类型 方法名(参数列表) { ... }

注意

• 成员方法不能被static关键字修饰；
• 若成员方法没有返回值，则返回类型声明为void，此时方法体内无需return；
• 访问成员方法
  • 一个成员方法，可以直接访问当前类中所有的成员方法；
• 成员方法参数
  • 可以是基本数据类型，也可以是引用数据类型，包括自定义的类型。
• 访问成员变量
  • 一个成员方法，可以直接访问当前类中所有的成员变量；

构造器：构造函数、构造方法、构建器

Java中的构造方法，是用来初始化成员变量和创建对象的。构造方法的语法要求如下：

构造方法可以有参数，可以根据传参的方式，初始化对象的成员变量

构造方法方法名必须与类名相同

构造方法的定义不能有返回值类型，即使void也不可以使用

若自己不写构造方法，则编译器默认提供一个无参的构造方法，若自己写了构造方法，则不再默认提供

一个类可以定义多个构造方法，方法名都与类名相同，参数不同，即为重载

在创建(new)对象时被自动调用

初始化块

代码初始化块是类的成员之一，每次类的创建会隐式的调用它。本质上是一个代码块，或方法体。

初始化块分为静态初始化块和普通初始化块。其好处是减少多个构造器内重用的代码；

语法

静态初始化块
[static] { ... }
普通初始化块
{ ... }

初始化块的区别：

普通初始化块：创建对象时隐式调用

静态初始化块：类加载时隐式调用

静态初始化块只调用一次（类加载时），而普通初始化块可以调用多次，随着对象的创建而加载

public class TestInit2 {
	public static void main(String[] args) {
		new InitDemo2();
		new InitDemo2();
		new InitDemo2();
		new InitDemo2();
		new InitDemo2();
	}
}
class InitDemo2{
	static int a =100;
	{
		System.out.println("我是普通初始化块");
	}
	static{
		System.out.println("我是静态初始化块");
	}

一个类中可以有多个静态初始化块和多个普通初始化块；静态初始化块的执行要早于普通初始化块；同一个类型的初始化块的执行顺序取决于定义的先后顺序！

在一个类中如果有多个不同的初始化块，初始化属性，构造器，

执行顺序是：

静态初始化块|静态属性初始化   ------>   普通初始化块|普通属性初始化   ------>   构造器

在父子类中，不同属性代码块和属性的执行顺序是：

爷爷类的静态初始化块|静态属性初始化 ------>
父类静态初始化块|静态属性初始化 ------>

子类静态初始化块|静态属性初始化 ------>

爷爷类普通初始化块|普通属性初始化  --->  构造器 ------>
父类普通初始化块|普通属性初始化 --->  构造器 ------>
子类普通初始化块|普通属性初始化 --->  构造器

静态初始化块中遵循静态成员的特点，只能直接访问静态成员！也就是在静态初始化块只能修改静态成员。

普通初始化块只能初始化普通的变量，普通的构造器也只能初始化普通的变量。

作用

初始化块是对构造方法的补充, 可用于处理那些与参数无关的、固定的初始化逻辑。

执行顺序

• 初始化块总是在构造方法之前执行；
• 多个初始化块之间按书写顺序执行；
• 初始化块与成员变量的初始化, 按照代码书写顺序执行。

​

访问修饰控制符，static，final

(包）package

为什么需要包

包提供了类的多层命名空间，可以解决类的命名冲突、类文件管理等问题。

包的命名规范

包名满足标识符规范即可，建议全用小写字母，以公司域名倒写作为包名。

访问其他包下的类

1. 包名.类名

2. import 包名.类名; import 包名.*;

3. 默认针对所有源文件 import java.lang.*;

import

同包中的类可以直接访问，

不同包中的类不能直接访问，若想访问:

• 先import声明类再访问类-------建议
• 类的全称--------------------太繁琐、不建议

访问控制修饰符

访问控制符:private, protected, public,默认(什么也不写)

成员访问权限：

• public 公开的，任何类
• private 私有的，本类
  • private修饰的变量说明变量为私有访问。只能被该类自己访问或调用，是对成员变量的高级保护。
• protected：受保护的，本类、派生类、同包类
• 默认的：什么也不写，本类、同包类-----------------------------java不建议默认权限

1) 类的访问权限只能是public或默认的

2) 类中成员的访问权限如上四种都可以

final

final：最终的、不可改变的--------------单独应用几率低

• 修饰变量：变量不能被改变
• 修饰方法：方法不能被重写
• 修饰类：类不能被继承
• final不能和abstract同时修饰方法，因为abstract方法必须由子类重写， 而final修饰的方法不能被重写
• final也可以修饰静态方法

final修饰成员变量

类的变量：可在声明变量时指定初始值，也可在静态初始化块中指定初始值；

实例变量：可在声明变量时指定初始值，也可在普通初始化块或构造方法中指定初始值；

final修饰局部变量

可在声明变量时指定初始值，也可在后面的代码中指定初始值。

static

静态变量

1. 由static修饰
2. 属于类的，存储在方法区中，只有一份
3. 常常通过类名点来访问
4. 何时用:所有对象所共享的数据(图片、音频、视频等)

静态方法

• 由static修饰
• 属于类，存储在方法区中，只有一份
• 常常通过类名点来访问
• 静态方法中没有隐式this传递，所以静态方法中不能直接访问示例成员
• 何时用:方法的操作与对象无关
• 静态方法可以被继承和隐藏 而不能够被重写，因此不能实现多态，不能实现父类的引用可以指向不同子类的对象进行多态调用。

静态块

1. 由static修饰
2. 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次
3. 何时用:加载/初始化静态资源(图片、音频、视频等)

static final常量

• 常常通过类名点来访问，不能被改变
• 建议:常量名所有字母都大写，多个单词用_分隔
• 编译器在编译时会将常量直接替换为具体的值，效率高
• 何时用:数据永远不变，并且经常使用

中，只有一份
3. 常常通过类名点来访问
4. 何时用:所有对象所共享的数据(图片、音频、视频等)

静态方法

• 由static修饰
• 属于类，存储在方法区中，只有一份
• 常常通过类名点来访问
• 静态方法中没有隐式this传递，所以静态方法中不能直接访问示例成员
• 何时用:方法的操作与对象无关
• 静态方法可以被继承和隐藏 而不能够被重写，因此不能实现多态，不能实现父类的引用可以指向不同子类的对象进行多态调用。

静态块

1. 由static修饰
2. 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次
3. 何时用:加载/初始化静态资源(图片、音频、视频等)

static final常量

• 常常通过类名点来访问，不能被改变
• 建议:常量名所有字母都大写，多个单词用_分隔
• 编译器在编译时会将常量直接替换为具体的值，效率高
• 何时用:数据永远不变，并且经常使用