Java_基础(二)

思想

面向过程的思想: 怎么按步骤把问题解决, 并将步骤编程方法, 一步一步事项, 适合简单不需要协作的任务

面向对象的思想: 怎么设计这个事务

区别与联系

• 都是解决问题的思维方式, 都是代码组织的方式
• 解决简单问题可以使用面向过程的思维方式
• 解决复杂问题时, 宏观上使用面向对象的思想来把握, 微观处理时使用面向过程的思想

类: 可以看作是一个模板, 或者图纸, 系统根据类的定义来创造对象

对象: 依据类创造出来的实体

面向对象的内存分析

Java虚拟机的内存可分为三个区域: 栈(stack), 堆(heap), 方法区(method area)

方法区实际也在堆里

栈的特点:

• 描述的是方法执行的内存模型; 每个方法被调用都会创建一个栈帧(存储局部变量, 操作数, 方法, 出口等)
• JVM为每个线程创建一个栈, 用于存放该线程执行方法的信息(实际参数, 局部变量等)
• 栈属于线程私有, 不能实现线程间的共享
• 栈的存储特性: 先进后出, 后进先出
• 栈由系统自动分配, 熟读块, 栈是一个连续的内存空间内存模型

堆的特点

• 用于存储创建好的对象和数组(数组也是对象)
• JVM只有一个堆, 被所有线程共享
• 堆是一个不连续的内存看空间, 分配灵活, 速度慢

方法区(又叫静态区)的特点:

• JVM只有一个方法区, 被所有线程共享
• 方法区实际也是堆, 只是用于存储类, 常量等相关的信息
• 用来存放程序中永远不变或者唯一的内容(类信息[class对象], 静态变量, 字符串常量等)

内存管理:Java的内存管理很大程度指的是对象的管理, 其中包括对象空间的分配和释放

对象空间的分配: 使用new关键字创建对象

对象空间的释放: 将对象赋值null即可, 垃圾回收器将负责回收所有"不可达"对象的内存空间

构造方法

构造器也叫构造方式, 用于对象的初始化

使用要点

• 通过关键字new来调用
• 虽有返回值, 但不能定义返回值类型(返回值的类型肯定是本类), 不能再构造器里使用return返回某个值
• 如果没有定义构造器, 则编译器会自动定义一个无参的构造函数, 如果已定义则编译器不会自动添加
• 构造器的方法名必须和类名一致
• 和普通方法一样, 构造器可以重载

误区:对象的创建完全是构造方法实现的

其实并不是, 构造方法创建Java对象的重要途径, 通过new关键字调用构造器时, 构造器已确定了返回该类对象, 但这个对象并不是完全由构造器负责创建的

对象创建过程与this用法

创建一个对象分如下4骤(静态初始化块在构造方法之前执行):

1.分配对象空间, 并将对象成员变量初始化为0或空

2.执行属性的显式初始化,包括静态初始化块

3.执行构造方法

4.返回对象的地址给相关变量

构造方法的重载: 构造方法也是方法, 只不过有特殊作用而已, 与普通方法一样, 构造方法也可以重载

误区: 如果构造方法中形参名与属性名相同时, 需要使用this关键字区分属性与形参

public class Test {
	public static void main(String[] args){
		Test1 test = new Test1(2);
	}
}

class Test1{
	int i = 1;
	Test1(int i) {
		System.out.println(i); 		// 输出的是形参
		System.out.println(this.i);	// 输出的是累属性
	}
}

this的本质就是"创建好的对象的地址", 就是对当前对象的引用, 由于在构造方法调用之前, 对象已经创建. 因此, 在构造方法中可以使用this代表"当前对象"

this常见用法

1.在程序中产生歧义之处, 应使用this来指明当前对象

　　普通方法中, this总是指向调用该方法的对象

　　构造方法中, this总是指向正要初始化的对象

2.使用this关键字调用重载的构造方法时, 避免相同的初始化代码. 但只能在构造方法中, 并且必须位于构造方法的第句(之前可以有注释)

3.this不能用于static方法中

static关键字

在类中, 用static声明的成员变量为静态成员变量, 也称为类变量. 类变量的生命周期和类相同, 在整个应用程序执行期间都有效

static修饰的成员变量和方法 ---------> 类

普通变量和方法 --------->对象

特点:

1.生命的变量为该类的公用变量, 从属于类, 被该类的所有实例共享, 在类被载入时被显式初始化

2.对于该类的所有对象来说, static成员变量只有一份, 被该类的所有对象共享

3.一般使用"类名.类属性/类方法"来调用(也可以通过对象引用或类名(不需要实例化)访问静态成员)

4.static方法中不能直接访问非static成员方和法

用static声明的方法为静态方法

• 不需要对象就可以调用
• 在调用该方法是, 不会将对象的引用传递给它, 所以在static方法中不可访问非static成员
• 静态方法中不能以任何方式引用this和super关键字

public class ThisMethod {
	public static void main(String[] args)
	{
		TestMethod.print();
		System.out.println(TestMethod.i);
	}
}
class TestMethod{
	static String i = "哈哈";
	static void print() {
		System.out.println("haha");
	}
}

/* 执行结果
haha
哈哈
*/

静态初始化块

构造方法用于对象的初始化操作

静态初始化块用于类的初始化操作, 在静态初始化块中不能直接访问非static成员

静态初始化块执行顺序

1. 上溯到Object类, 先执行Object类的静态初始化块, 再向下执行子类的静态初始化块, 直到要创建的类的静态初始化块为止

2. 把静态初始化块全部(包括父类中)执行完后, 执行构造方法, 构造方法的执行顺序和上面顺序一样

   public class Test {
   
   public static void main(String[] args){
   
   Test2 test = new Test2();
   
   System.out.println("****************");
   
   Test2 test_1 = new Test2();
   
   }
   
   }

   class Test1{
   
   Test1 (){
   
   System.out.println("父类的构造方法初始化操作");
   
   }
   
   static {
   
   System.out.println("父类的静态初始化块初始化操作");
   
   }
   
   }

   class Test2 extends Test1{
   
   Test2 (){
   
   System.out.println("子类的构造方法初始化操作");
   
   }
   
   static {
   
   System.out.println("子类的静态初始化块初始化操作");
   
   }
   
   }
   
   /* 静态初始化块只执行了一次
   
   父类的静态初始化块初始化操作
   
   子类的静态初始化块初始化操作
   
   父类的构造方法初始化操作
   
   子类的构造方法初始化操作

   ---

   父类的构造方法初始化操作
   
   子类的构造方法初始化操作
   
   */

final关键字

1. 修饰变量: 改变量不可改变, 一旦被赋予初始, 就不能被重写赋值
2. 方法: 不可被子类重写, 可以被重载
3. 类: 该类不能被继承

参数的值传递

Java中,方法中所有参数都是"值传递", 也就是传递值的副本.

数组

数组是相同类型数据的有序集合, 数组描述的是相同类型的若干数据, 按照一定的先后次序排列组合而成. 其中, 每一个数据称作一个元素, 每个元素可以通过一个索引(下标)来访问它们

三个基本特点:

• 长度确定, 一旦被创建, 它的大小不可改变
• 元素必须是相同的数据类型
• 数组类型可以是任何数据类型, 包括基本类型和引用类型

数组变量属于引用类型, 数组也可以看成是对象, 数组中的每个元素相当于该对象的成员变量. 数组本身就是对象, 在Java中, 对象是在堆中, 因此数组无论保存原始类型还是其他对象类型, 数组对象本身是在堆中存储

数值的初始化方式共三种: 静态初始化, 动态初始化, 默认初始化

静态初始化: 除用new关键字来产生数组外, 还可以直接在定义数组的同时为数组元素分配空间并赋值

动态初始化: 数组定义与为数组元素分配空间并赋值操作分开进行

数组默认初始化: 它的元素相当于类的实例变量, 因此数组一经分配空间, 其中的每个元素也被安装实例变量同样的方式被隐式初始化

int[] a = {1, 2, 3};	// 静态初始化基本类型数组
Animal[] animal = {new Animal(1), new Animal(2)};	//静态初始化引用类型数组

int[] a1 = new int[2]; 	// 动态初始化数组, 先分配空间
a1[0] = 1;	// 给数组元素赋值
a1[1] = 2; 	// 给数组元素赋值

int[] a2 = new int[2];	// 默认值: 0, 0
boolean[] b = new boolean[2]	// 默认值: false, false
String[] s = new String[2]; 	//默认值: null, null

增强for循环: for-each是JDK1.5新增加的功能, 专用于读取数组或集合中所有的元素

public class Test {
	public static void main(String[] args) {
		String[] ss = {"aa", "bb", "cc", "dd"};
		for(String tmp : ss) {
			System.out.println(tmp);
		}
	}
}

/*输出结果
aa
bb
cc
dd
*/

Java中包机制与导入

包机制是Java中管理类的重要手段. 开发中会遇到大量同名的类, 通过包可以很容易解决类名重名的问题, 也可以实现对类的有效管理. 包对于类, 相当于文件夹对于文件的作用

使用要点

通常是类的第一句非注释型语句(前面可以有注释行, 空行)

包名: 域名倒着写, 再加上模块名, 便于内部管理类

写项目时都要加包, 不要使用默认包

con.zpy和com.zpy.model这两个包没有包含关系, 是两个完全独立的包, 只是逻辑上看起来后者是前者的一部分

JDK中主要包

java.lang: 包含一些Java语音的核心类, 如String, Math, Integer, System和Thread, 提供常用功能

java.awt: 包含构成抽象窗口工具集(abstract window toolkits)的多个类, 这些类被用来构建和管理应用程序的图形用户界面(GUI)

java.net: 包含执行与网络相关的类

java.io: 包含能提供多输入/输出功能的类

java.util: 包含一些实用工具类, 如定义系统特性, 使用与日期日历相关的函数

使用其他包的类需要使用import导入, 从而可以在本类中直接通过类名来调用, 否则需要书写类的完整包名和类名

使用:

import java.util.Date;

import java.util.*; // 导入该包下所有的类. 会降低编译速度, 但不会降低运行速度

注意:

Java默认导入java.lang包下所有的类

如果导入两个同名的类, 智能用包名+类名来显示调用相关包

静态导入: 是在JDK1.5新增加的功能, 其作用是用于导入指定类的静态属性, 这样可以直接使用类的静态属性

import static java.lang.System.out;
import static java.lang.Math.PI;

public class User4{
	public static void main(String[] args) {
		System.out.println("ha");	// 使用静态导入时
		out.println("ha");			// 使用静态导入后
		out.println(PI);
	}
}
/* 输出结果
ha
ha
3.141592653589793
*/