类和对象（java）

类和对象
1.什么是类（自行车的设计图）
2.什么是对象（一辆辆的自行车）
3.为什么要设计对象的机制（面向对象编程）
状态 + 行为
属性 方法

4.面向对象的三大特性：封装，继承，多态；

5.语法：
1）定义类的：
修饰符（modifier） class 类名称{
1.属性
2.方法
3.构造方法
}
2）定义属性：
修饰符 变量类型 变量名称= ；
默认值：如果变量没有赋初值，所有数据都是对应类型的0
3）定义方法：
修饰符 返回值类型 方法名称（形参列表）{
}
4）构造方法：
修饰符 类名称（形参列表）{
}
构造方法和方法的区别：
1.无返回值
2.名称和类名一样

构造对象的方法|对象实例化的语法：

类名称 变量名称=new 类名称（实参列表）

（引用类型-类应用）
注意：
1.一个文件中只能有一个public 的类
2.实例对象化的语法
1） New：计算对象需要的内存大小，开辟空间 初始化为0x0。
2）调用构造方法，对属性初始化。
3）构造方法调用结束，返回一个指向新对象的引用。
对象的生命周期：

1.刚刚申请好空间
2.对象正在执行构造方法对对象初始化
3.对象的可使用生命周期
4.对象已经被标记为垃圾，但可能还没有被立即回收的时期

对象存储中最重要的就是属性，也可以找到方法区中对象对应的类

语法：
如何访问对象的属性
在类的内部：通过属性名称访问
1.大名 this.属性
2.如果没有出现命名的遮挡问题直接使用属性。

在类的外部：引用.属性名称

如何让调用对象的方法
在类的内部：直接通过方法名称调用
1.this.name
2.name
在类的外部：引用.方法名称（实参列表）

This关键字的使用：
1.在构造方法中调用其他构造方法，调用语句必须出现在第一行。
2.通过this访问属性或方法（一般出现在发生了命名遮挡的时候）（name shadowing）
3.this代表的当前对象的引用。

重点：普通属性和普通方法都绑定着一个隐含的的对象。

注意：1.一个源文件中只能有一个public类，该类名称和文件名一致
2.一个类会生成一个class字节码文件
理解类和对象的内存模型：
类信息存在 方法区
属性存在 堆区

访问限定符
1.限定符
2.访问权限（1.修饰顶级类（Top-Level）2.修饰成员级（Member-level））
3.四种访问限定符

这里第一个和最后一个可以修饰顶级类，这四个都可以修饰成员级

包 （import java.util.Arrays;）

定义包：
1.新建目录，目录名称就是包名称（全小写，单词之间用_分割）
2.使用包
Import 包名称.类名称

静态方法 静态属性
1）普通方法和静态方法（类方法）
2）普通属性和静态属性（类属性）
关键字：static
语法：
被static修饰的是静态属性/方法。

如何访问静态属性，调用静态方法
内部：
属性名称
类名称.属性名称
This.属性名称 //保证当前属性不是静态属性

方法名称（实参列表）
类名称.方法名称（实参列表）
This.方法名称（实参列表） //保证当前方法不是静态方法
外部

类名称.属性
对象的引用.属性名称

类名称.方法名称（参数列表）
对象的引用.方法名称（参数列表）

注意：在静态方法中无法使用this关键字，无隐式对象与该方法绑定
1）不能访问普通属性
2）不能调用普通方法

一个类的所有对象，可以共享静态属性的

理解：
普通属性或普通方法，都绑定着一个隐含着的对象

Static的含义就是和对象解绑，静态属性不再保存在对象中（堆区），而是保存在类中（方法区）

静态方法调用时没有隐含着的对象，所以也就无法使用this关键字

public class HelloA {
//构造⽅法
public HelloA(){
System.out.println("Hello A!构造⽅法");
}
//⾮静态代码块
{
System.out.println("i'm A class.⾮静态代码块");
}
//静态代码块
static{
System.out.println("static A 静态代码块");
} }

这个代码首先打印的是静态代码块，它发生在类被加载的时候，接下来是非静态，然后是构造方法。

属性的初始化：
1.定义时初始化
2.构造代码块
{a=0} //构造代码块
Int a=10；//定义
3.在构造方法中初始化

静态属性初始化：（发生在类被加载的时候）类加载一定是在对象实例化之前的
1）定义时初始化
2）静态构造代码块
Static{
a=20；
}

这两个按照定义顺序依次执行

public class A {
		A() {
			System.out.println("构造方法中，a = 30");
			a = 30;
		}
		
		{ System.out.println("构造代码块 1时，a = 0"); a = 0; }
		int a = init();
		{ System.out.println("构造代码块 2时，a = 20"); a = 20; }
		
		
		int init() {
			System.out.println("定义时  a = 10");
			return 10;
		}
		
		static {
			System.out.println("静态代码块 1时，staticA = 100");
			staticA = 100;
		}
		static int staticA = staticInit();
		static {
			System.out.println("静态代码块 2时，staticA = 300");
			staticA = 300;
		}
		
		static int staticInit() {
			System.out.println("静态定义时  staticA = 200");
			return 200;
		}
		
		
		public static void main(String[] args) {
			A p = new A();
			A q = new A();
		}
	}

程序运行截图如下

以上结果可以看出

1. 静态块优先于构造块执⾏。
2. ⽆论产⽣多少实例化对象，静态块都只执⾏⼀次。

类的信息一开始是以字节码形式形式保存在磁盘上的
类的加载过程就是类加载器在对象的目录上找到指定类的字节码文件，并且进行解析，然后放到内存的方法区的过程
类只有在被使用到的时候才会进行加载（一般不会加载）
1）用类去实例化对象
2）调用静态方法
3）访问静态属性