JAVA---＞类和对象详解(2)

JAVA—>类和对象详解(2)

1.封装

1.1封装的概念

将对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节.即套壳屏蔽细节

1.2访问修饰限定符

java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：

说明:

1.protected主要是用在继承中，继承部分详细介绍

2.default权限指：什么都不写时的默认权限

3.一般情况下成员变量设置为private，成员方法设置为public。

1.3 封装扩展之包

1.3.1包的概念: 为了更好的管理类，把多个类收集在一起成为一组，称为软件包。(可以理解为文件夹)

说明:

1.包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。

2.在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

1.3.2导入包中的类

不导包使用方法使用方法,十分麻烦,如下:

public class Test {
	public static void main(String[] args) {
		java.util.Date date = new java.util.Date();
		// 得到一个毫秒级别的时间戳
		System.out.println(date.getTime());
	}
}

所以一般采用import导包

import java.util.Date;
public class Test {
	public static void main(String[] args) {
		Date date = new Date();
		// 得到一个毫秒级别的时间戳
		System.out.println(date.getTime());
	}
}

导包方式有多种:

1.使用import依次导包,如上

2.如果同一个类内要使用多个方法,则可以使用"*“(通配符),不过并不建议,因为可能有些方法,在不同包中也有,如果都使用”*",则无法区分是使用哪个包的方法

import java.util.*;
import java.sql.*;
public class Test {
	public static void main(String[] args) {
		// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
		Date date = new Date();
		System.out.println(date.getTime());
	}
}
/* 编译出错
Error:(5, 9) java: 对Date的引用不明确
java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配
*/

3.使用import static导入包中静态的方法和字段

即使用时,就不需要通过类对象进行调用,直接方法名调用接口

import static java.lang.Math.*;
public class Test {
	public static void main(String[] args) {
		double x = 30;
		double y = 40;
		// 静态导入的方式写起来更方便一些.
		// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));//使用import导包代码
		double result = sqrt(pow(x, 2) + pow(y, 2));
		System.out.println(result);
	}
}

1.3.3自定义包

基本规则

1.在文件的最上方加上一个 package 语句指定该代码在哪个包中.

2.包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).

3.包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.

如果一个类没有 package 语句, 则该类被放到一个默认包中

操作步骤

1. 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包

2. 在弹出的对话框中输入包名, 例如 com.bit.demo1

3. 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可.

4. 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句(代表类路径)

1.3.4常见的包

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
2. java.lang.reflect:java 反射编程包;
3. java.net:进行网络编程开发包。
4. java.sql:进行数据库开发的支持包。
5. java.util:是java提供的工具程序包。(集合类等) 非常重要
6. java.io:I/O编程开发包。

2.static成员

2.1 static修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3. 类变量存储在方法区当中

4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

public class Student{
	public String name;
	public String gender;
	public int age;
	public double score;
	public static String classRoom = "2306";
	
	public static void main(String[] args) {
	// 静态成员变量可以直接通过类名访问
		System.out.println(Student.classRoom);
		Student s1 = new Student("zhangsan", "男", 18, 3.8);
		Student s2 = new Student("lisi", "女", 19, 4.0);
		Student s3 = new Student("wangwu", "男", 18, 2.6);
		// 也可以通过对象访问：但是classRoom是三个对象共享的
		System.out.println(s1.classRoom);
		System.out.println(s2.classRoom);
		System.out.println(s3.classRoom);
	}
}

2.2static修饰成员方法

Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。

class Student{
	private static String classRoom = "Bit306";
	public static String getClassRoom(){
		return classRoom;
	}
}
public class TestStudent {
	public static void main(String[] args) {
		System.out.println(Student.getClassRoom());
	}
}

【静态方法特性】

1. 不属于某个具体的对象，是类方法

2. 可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者

3. 不能在静态方法中访问任何非静态成员变量

4.静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

static成员变量初始化:静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化。

1.就地初始化：在定义时直接给出初始值

public class Student{
	private String name;
	private String gender;
	private int age;
	private double score;
	private static String classRoom = "Bit306"; 
}

2.静态代码块初始化->见下

3.代码块

3.1 代码块概念以及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

1.普通代码块

2.构造块

3.静态块

4.同步代码块（多线程板块,暂时不谈）

3.2普通代码块：定义在方法中的代码块.

public class Main{
	public static void main(String[] args) {
	{ //直接使用{}定义，普通方法块
		int x = 10 ;
		System.out.println("x1 = " +x);
		}
		int x = 100 ;
		System.out.println("x2 = " +x);
	}
}
/*执行结果
x1 = 10
x2 = 100*/

3.3构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

class Student{
	//实例成员变量
	private String name;
	private String gender;
	private int age;
	private double score;
	public Student() {
		System.out.println("I am Student init()!");
	}
	//实例代码块
	{
		this.name = "bit";
		this.age = 12;
		this.sex = "man";
		System.out.println("I am instance init()!");
	}
	public void show(){
		System.out.println("name: "+name+" age: "+age+" sex: "+sex);
	}
	}
	public class Main {
		public static void main(String[] args) {
			Student stu = new Student();
			stu.show();
	}
}
/* 运行结果
I am instance init()!
I am Student init()!
name: bit age: 12 sex: man
*/

3.4使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

public class Student{
	private String name;
	private String gender;
	private int age;
	private double score;
	private static String classRoom;
		//实例代码块
	{
		this.name = "bit";
		this.age = 12;
		this.gender = "man";
		System.out.println("I am instance init()!");
	}
	// 静态代码块
	static {
		classRoom = "bit306";
		System.out.println("I am static init()!");
	}
	public Student(){
		System.out.println("I am Student init()!");
	}
	public static void main(String[] args) {
		Student s1 = new Student();
		Student s2 = new Student();
	}
}

注意事项

1.静态代码块不管生成多少个对象，其只会执行一次

2.静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的

3. 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)

4.实例代码块只有在创建对象时才会执行

4.对象的打印

重写toString方法

public class Person {
	String name;
	String gender;
	int age;
	public Person(String name, String gender, int age) {
		this.name = name;
		this.gender = gender;
		this.age = age;
	}
	@Override
	public String toString() {
		return "[" + name + "," + gender + "," + age + "]";
	}
	public static void main(String[] args) {
		Person person = new Person("Jim","男", 18);
		System.out.println(person);
		// 输出结果：[Jim,男,18]
	}
}