Java | 类与对象(updating)

          ____                                                    ___                                                                                                                   
        ,'  , `.                                                ,--.'|_            ,--,                                                     ,--,                                        
     ,-+-,.' _ |                               __  ,-.          |  | :,'         ,--.'|                 ,---,               ,---,         ,--.'|                                        
  ,-+-. ;   , ||                             ,' ,'/ /|          :  : ' :         |  |,              ,-+-. /  |          ,-+-. /  |        |  |,                                         
 ,--.'|'   |  ||           ,--.--.           '  | |' |        .;__,'  /          `--'_             ,--.'|'   |         ,--.'|'   |        `--'_               ,---.             ,---.   
|   |  ,', |  |,          /       \          |  |   ,'        |  |   |           ,' ,'|           |   |  ,"' |        |   |  ,"' |        ,' ,'|             /     \           /     \  
|   | /  | |--'          .--.  .-. |         '  :  /          :__,'| :           '  | |           |   | /  | |        |   | /  | |        '  | |            /    /  |         /    /  | 
|   : |  | ,              \__\/: . .         |  | '             '  : |__         |  | :           |   | |  | |        |   | |  | |        |  | :           .    ' / |        .    ' / | 
|   : |  |/               ," .--.; |         ;  : |             |  | '.'|        '  : |__         |   | |  |/         |   | |  |/         '  : |__         '   ;   /|        '   ;   /| 
|   | |`-'               /  /  ,.  |         |  , ;             ;  :    ;        |  | '.'|        |   | |--'          |   | |--'          |  | '.'|        '   |  / |        '   |  / | 
|   ;/                  ;  :   .'   \         ---'              |  ,   /         ;  :    ;        |   |/              |   |/              ;  :    ;        |   :    |        |   :    | 
'---'                   |  ,     .-./                            ---`-'          |  ,   /         '---'               '---'               |  ,   /          \   \  /          \   \  /  
                         `--`---'                                                 ---`-'                                                   ---`-'            `----'            `----'   
                                                                                                                                                                              

一，【编程语言发展阶段】

1-1-面向机器语言

1-2-面向过程语言

► 过程设计语言
	◊ c , Fortran
	◊ 函数/过程块
		 块目标 : 完成任务
	◊ 局限性 : 能完成功能，但没有『主语』，没有明确『对象』的概念
		 解决 :
			结构体【复合数据类型结构】，但还是具有缺陷

引入面向对象语言

1-3-面向对象语言

1.好处 : 
	► 贴近人类生活
	► 便于人理解【符合人类思维】
	► 易维护，易扩展，易复用
2.理念 : 
		►一切皆对象
		► 完成任务，考虑对象
		► 提到数据，要考虑是属于哪个对象的数据
3.核心 :
	关键词 : 
		► 数据 : 属性 【静态】
		► 对数据的操作 : 行为(带有目的)【动态】
	抽象 :
		► 对实例的抽象，形成类的概念【concept of class】
4.特性(3)
	1)封装 :
		► 可被描述【对象的数据，对象对数据的操作】
	2)继承 :
		► 子类继承，父类的属性，行为
		► 类比，人类与哺乳类
	3)多态 :
		2种多态
			(1)操作名称 :
				◊ 『 同名不同意』
				◊ 针对同一类
				◊  类比，人类活动，分配同任务，结果不同
			(2)继承多态 : 
				► 结合父类和子类看待
				► 类比，动物行为 : 
					◊ 猫的『叫』:喵
					◊ 狗的『叫』:汪

1-4-学习Java具备能力

学习Java编程的学习的能力
	► 类是创建对象的模板
		◊ 要想使用对象，使用对象的属性，行为去完成功能/任务，必须要先学会使用类
	► 用Java语法描述事物的属性，行为
		◊ 属性通过变量刻画
		◊ 行为通过方法体现 : 行为(方法)是属性的组成的一系列算法

二，【类】

2-1-类是什么?

类定义/声明
	class 类名 {
	…类体
	}
	实例:
		class People {
		…类体
		}
	类名 : 首字母大写，采用驼峰命名法[推荐]

类的目的是抽象事物属性和行为
类体就是描述这些属性和行为的

1-Q:如何抽象?

--由若干单一对象实例，分析(局部入手)
--抽象抓住事物两个特征:属性和行为

2-Q:类的目的？

--创对象，为对象模板

3-Q:抽象的目的是什么?

--抽象出类，找到模板，可以创建对象

2-2-【类体中的内容】

1.变量的声明
2.方法的定义

1-【变量的声明】

 --声明部分的变量称为 成员变量/域变量

2-Q:成员变量指定什么?

--声明变量部分的变量

3-Q:成员变量包含那些内容和注意事项?

1.类型: 
	Java语言中
		①基本数据类型
		②引用类型
2.作用范围 :
	全局，整个类中有效
3.命名:
	符合标识符命名规范
	首字母小写[驼峰命名法]，

2-【方法的定义】

1-Q:什么是方法?

--方法就是能完成某个功能/任务的『块』
--就是c语言中的函数，只不过面向对象语言中习惯称『方法』

2-Q:方法的组成是什么?

方法头:
	[访问控制符] 类型  方法名 ([参数列表])
方法体:
	{局部变量语句}
一般格式:
	方法头{
	.
	.
	.
	方法体内容
	}
	-----------------------
	实例:
		int speak() //不带参数
		{
			return 23;
		}
		int speak(int x,int y,int z) //带参数
		{
			return x+y+z;
		}

3-Q:局部变量指的什么?

方法体中声明的变量/方法的参数
	◊ 局部变量仅方法内有效，区别于类的成员变量
	◊ 方法参数整个方法内有效

4-Q:如何区分局部变量和成员变量?

if (成员变量名==局部变量名):
		成员变量被隐藏，在方法中失效，默认使用同名的局部变量
如想使用这个被隐藏的成员变量，使用关键字 this
在方法中的『this.成员变量名』
	this表示访问这个方法的对象

注意 : 局部变量没有默认值.必须初始化

5-Q:注意的问题?

对于成员变量的操作只有两种方式
哪两种?
	1.类中声明成员变量时，赋值操作
	2.类中方法体中操作(赋值)
	且不可，操作(赋值)成员变量在声明后【在非方法中，且在类中】

6-Q:如何理解这个过程?

使用类的基本结构图

2-3-【类的UML图】

1-Q:为什么要使用类的UML图?

	帮助分析类的结构，类与类的关系结构

2-Q:类的UML图是怎样的?

	基本三部分:
		1.名字层(类名)
		2.变量层(属性)
		3.操作层(方法)
		如图

3-Q:类的UML应用有哪些?

①. 类(class)UML图
②. 接口(interface)UML图
③. 泛化关系(Genaralization)UML图
④. 关联关系(Association)UML图
⑤. 依赖关系(Dependency)UML图
⑥. 实现关系(Realization)UML图

三，【构造方法和创建对象】

--类也是数据类型!
--类声明的变量即对象
--类声明对象后必须创建对象
--用某类创建对象，即给出某类的实例
--类是创建对象的模板，没有类就没有对象

3-1-【构造方法】

Q-构造方法是什么?

1.类中特殊方法
2.创建对象用

Q-有什么作用?

创建对象

Q-构造方法有什么特点?

	1.构造方法名===所在类名
	2.无类型
	3.类中允许多构造方法，需保证参数不同
	4.分类
		1)，手动编写
			1.无类型
			2.可带参数
			3.方法体有语句
			
		2)，系统默认
			1.无参+无类型
			2.方法体无语句
	5.注意事项
		if(编写了>=1个构造方法):
			不提供默认构造方法
		else:使用默认【无参数+无类型的】构造方法
	6.实例
		class Point
		{
			int x,y;
			//不带参数构造方法Point
			Point()
			{
				x=1;
				y=1;
			}
			//带参数构造方法Point
			Point(int a,int b)
			{
				x=a;
				y=b;
			
			}
			//不是构造方法(方法类型为void)
			void Point(int a,int b)
			{
			
			
			}
		
		}
		
		public class Examle
		{
			public static void main(String args[])
			{
				/*
				1.使用默认构造方法创建对象
				2. 无返回类型，无参数
				3.常用
				*/
				Point p1 = new Point(); 
				p1.Point(2,3); //对象使用带参数的构造方法Point
				
			}
		}

Q-构造方法怎样用?

1.一般伴随new，创建对象使用
2.一般的默认是系统自带默认构造方法 People p1 = new People();
	--也可以用编写的带参数的构造方法 People p1 = new People("adam",18,'男');
	都是可以创建对象

3-2-【创建对象】

Q-如何创建对象?

1.先声明
	//一般格式:
		类名 对象名;
	//实例:
		People p1;

2.再创建
	使用构造方法创建对象
	作用其实是为对象分配变量

Q-如何理解对象，对象的本质?

从内存原理入手

知道几个概念
1.引用
	本质就是c语言指针，存放地址类型的变量
	new  类名(); //这样就是一个引用，一个值，16进制地址值
	类名 对象名 = new 类名(); //将地址给对象变量
    //相当于
    int * a = 0x1990 ; //把地址赋值给一个变量
2.内存空间
	1.物理，实际，存在的空间
	2.所谓一个对象就是空间(存放数据的集合)，逻辑上认为是对象，人格化了
           内 存 空 间
                 +
                 |
                 |
                 |
                 |
                 |
                 |
                 +------------+
                              |
                              |
                              |
                              v
+--------------------------------------------------------------------------------+
|    +-------+ +------+   +------+   +------+  +------+   +------+   +------+    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    +-------+ +------+   +------+   +------+  +------+   +------+   +------+    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    +-------+ +------+   +------+   +------+  +------+   +------+   +------+    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    +-------+ +------+   +------+   +------+  +------+   +------+   +------+    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    +-------+ +------+   +------+   +------+  +------+   +------+   +------+    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    +-------+ +------+   +------+   +------+  +------+   +------+   +------+    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    +-------+ +------+   +------+   +------+  +------+   +------+   +------+    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    +-------+ +------+   +------+   +------+  +------+   +------+   +------+    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    +-------+ +------+   +------+   +------+  +------+   +------+   +------+    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    |       | |      |   |      |   |      |  |      |   |      |   |      |    |
|    +-------+ +------+   +------+   +------+  +------+   +------+   +------+    |
+--------------------------------------------------------------------------------+

	3.所以对象可以说一直是有的，只不过对内存空间没有权限，没有逻辑化

Q-创建对象的过程完成了什么工作?

	1.赋予内存空间权限
	2.指明了对象，人格化了

扩展小知识
1.对象的引用在栈中
2.对象的实体(分配给对象的变量)在堆中

3-3-【使用对象】

Q-为什么要使用对象?

1---抽象的目的是为了产生类，而产生类的目的是创建对象
2---对象可以操作变量和产生行为，完成功能，这是程序所需要的

Q-如何体现对象能完成功能?

1---对象.变量  //体现对象的属性【通过.访问自己的变量】
2---对象.方法  //体现对象的行为【通过.调用自己的方法，产生行为】
3---体现封装

Q-什么是匿名对象?

---new 构造方法名()  已经是引用值，，指向内存空间有数据
---但没有明显的赋值到一个对象变量

Q-有什么注意事项?

//  new 构造方法名()  将产生新的引用，如果作为匿名对象，则将会产生不同的空间
如
	new Person().weight = 100;
	new Person().weight =200 ;
//100，200不是覆盖，而是存放到不同内存空间
而
	Person ZhangSan = new Person();
	ZhangSan.weight=100;
	ZhangSan.weight=200;
//weight是同一内存位置的weight,200覆盖了100的值

3-4-【对象的引用和实体】

Q-什么对象的实体?

1--类是一种数据类型【体现封装，封装对数据的操作的】
2--类声明的变量即对象，对象负责存放数据的引用(指针，地址)
3--这个对象就可以访问分配给它的变量，调用方法
4--分配给对象的变量称为实体
//注意：空对象不能用(毫无疑问，没有东西用)

                     +--+
                     |--|
                     |--|
                     |--|
+--------+           |--|
|  null  |           |--|
+--------+           |--|
                     |--|
                     |--|
                     |--|
                     |--|
                     |--|
                     +--+

                   内 存 空 间

注意：空对象不能用(毫无疑问，没有东西用)

Q-什么是空对象？

---没有实体的对象，空对象 不能使用
---如使用空对象，可能报错 NullPointerException(空指针异常)

Q-什么是对象的引用?

---引用即地址，指针Point

Q-对于对象实体，引用注意事项?

1---如果类声明的两个对象，具有相同的引用，那么两者具有相同的变量
	Object bject1 = new Object();
	Object bject2 = new Object();
	object2.height= 200;
	object1 = object2;
//那么此时object1,object2具有相同的引用，都是object2的引用
System.out.println("object1的height值的是:"+object1.height);
System.out.println("object3的height值的是:"+object2.height);
//结果将会是一样的

Q-什么是垃圾回收机制?

1---类声明的两个对象如果具有相同的引用，那么两者具有相同的实体，则另一个对象原有的实体可能不被拥有了
2---如果某个实体(变量)不被其它任何对象拥有，则这个实体可称为"垃圾"，就会释放实体占有的空间

如果希望Java虚拟机立刻执行"垃圾回收机制",可用System类调用gc()方法

四，【类与程序的基本结构】

Q-Java程序的结构构成是怎样的?

---程序(工程)由若干类组成
---这些类可以在一个源文件中，也分布于多个源文件

Q-执行java程序的过程?

Java应用程序中有主类(含man方法的类)，从主类开始执行

1---将Java源文件保存相同目录，编辑得到Java字节码文件
2---运行主类

Q-详细细节是什么?

1---解释器运行Java应用程序
2---Java虚拟机将字节码文件加载到内存
3---再由Java虚拟机解释执行
//也就是真正执行的是字节码文件，而非源文件

Q-为什么说Java程序以"类"为基本单位?

---类是真正实现功能的基本单位，采用面向对象的好处，就是类可复用
---类存放在源文件中，一源文件可以放一个类，也可多个类
---因此源文件可被编译器视为独立编译单位，具有隔离性
---当程序须修改某类，只需重新编译所在源文件即可，无需编译其它源文件

尽管一个源文件可写多个类，但建议一个源文件只编写一个类

五，【参数传值】

Q-参数是什么?

---方法中的变量

Q-方法的参数传值是怎样的?

---值传递
---类比原件和复印件的关系

5-1-【基本数据类型的传值】

Q-基本数据类型的参数传值注意事项?

---不能让精度缺失,float变量不能传递给int类型参数

5-2-【引用类型参数传值】

Q-引用型数据是什么?

---数组，对象，接口

Q-引用类型特点是什么?

---当参数是引用类型时，向参数传递的"值"，是引用型变量存放的"引用"，而不是变量的实体
---同样的，对于两个相同类型的引用型变量，如存有相同的"引用"，则两者具有相同的实体

—如果改变参数变量引用的实体，则会导致原变量的实体改变
—如果只是改变参数的值，即"引用值"，则不会改变向其传值的原变量的值(引用值)

5-3-【可变参数】

基本概念 : 可变参数，参数代表，增强fot语句

Q-为什么要使用可变参数?

—无法确保要传递参数的个数的时候可使用可变参数

Q-什么是可变参数?

1---方法参数列表中的参数无需全部写，包括参数名，参数类型
2---但要确保这些参数类型的是相同的
3---可变参数中的"变的参数"用 …表示
public void f(int … x)

Q-什么是参数代表?

---上述的x就是参数代表
---参数代表必须写在参数列表的最后位置
如 public void g(double a, int … x)
第一个参数是double 类型的a
后半部分的参数 x是参数代表，表示参数列表都是int类型

//注意:参数代表必须在参数列表的最后一个位置
如 public void method(int …x ,int y)
则x不是参数代表，y也不是可变参数列表的参数变量

Q-可变参数如何使用完成功能呢?

---可变参数，参数代表的使用，就像数组一样
---虽不知道具体想传参个数，但可以计算参数个数，通过X这个参数代表计算
---表示参数列表中的具体参数【通过下标运算】，x[0],x[1],…
---x.length就是可变参数的个数

Q-如何理解可变参数的应用需求?

---可变参数的使用灵活多样，如计算若干数的和，但是不知道有多少个数，不好事先声明参数个数
如 203+178+56+2525+621+...,参数变换，且无规律，可以使用参数列表方式完成


public int getSum(int …x) //x就是可变参数代表
{
	int sum = 0;
	for(int i=0;i<x.length;i++)
	{
		sum = sum +x[i];
	}
	return sum;
}

这样，即可可以适用固定参数个数的情况，可以适用变换参数个数的情况

Q-什么是增强型for循环?

for(声明循环变量: 参数代表)
{
	…

}
//表示对于循环变量，依次取"参数代表"表示的每一个参数
对于上述的 getSum(int …x)更改为增强型for循环就是

for (int param:x) 
{
  sum = sum + param;
}

六，【对象组合】

Q-什么是Has-A?

--Java中的对象也是某种数据类型变量(类是数据类型)
--类的成员变量可以是任何一种数据类型，所以对象也可以是成员变量类型
--也就是说，某个类可以把其它类的对象作为自己的成员属性(变量)


                                              +-+
                                              | |
                                              | |
                                              | |
+-------+                    +-----+          | |
|       +--------------------+     +----------+ |
|       |                    +-----+          | |
|       +----------+          对 象 B         | |
+-------+          |                          | |
                   |                          | |
 对 象 A           |                          +-+
                   |
                   |          +----+          +-+
                   +--------->+    |          | |
                              +----+----------+ |
                               对 象 C        | |
                                              | |
                                              | |
                                              | |
                                              | |
                                              +-+

6-1-【组合复用】

Q-组合,复用指的什么?

--对象a组合了对象b(包含关系,a包含b)，对象a可委托b调用其方法（即调用b的方法）
--即对象a通过组合b的方式复用了b的方法

Q-通过组合对象来复用方法 有什么特点?

1---黑盒复用，a不知包含b的对象的方法的具体细节(算法实现等)
2---弱耦合，当前a可以包含其它的对象，即可更换对象，实现弱耦合关系

Q-如何理解这种复用的作用?

在这种事物关系中，圆锥Circular的底面积就是圆Circle的面积
Cirlular对象就需要包含Circle对象
//注意这里的 
void setBottom(Circle c)
{
	bottom = c;
}
//就是将Circle类的对象c作为Circular类的成员变量

6-2-【类的关联关系和依赖关系UML图】

Q-什么是关联关系?

b是a类的成员

Q-什么是依赖关系?

b是a类方法的参数(括号里面的变量)

七，【实例成员和类成员】

7-1-【变量】

Q-什么是实例变量？什么是类变量?

从形式上

--声明变量是用static关键字是类变量，否则是实例变量
--类变量也称static变量，静态变量
如 
class Dog 
{
	float x; //实例变量
	static int y; //类变量

}

7-2【实例变量和类变量的区别】

Q-实例变量和类变量有那些区别？

1—不同对象的实例变量是不同的 (也即实例变量是局限于对象而言的)

why?
--从内存角度，对象的实例变量是通过new运算符创建的，开辟的一段内存空间
--每new一个对象，对象的实例变量新增内存空间，即不同对象的实例变量的内存空间是不同的

2—所有对象共享类变量

why?
同样，内存角度，使用new运算符，创建对象，实例变量，分配类变量给对象
一图胜千言

可以理解为new的时候，对象，实例变量是增加的，而类变量只是分配给对象而已

3—通过类名可以直接访问类变量

why?
可以从变量的诞生"日期"说起
类变量是创建类时就有的，准确说，Java程序执行时，字节码加载到内存中，如果类无对象，则无实例变量，也不会被分配内存，但是类变量，当类加载到内存时，就分配了内存
--当创建对象时，实例变量才会被分配空间，不同对象，实例变量也是不同的空间
--而类变量则不会再创建空间，即所有对象，共享类变量，直至程序结束，类变量释放占用的内存
--*因为类变量是和类有关的变量，肯定是和创建的对象的(实例)变量不同的，同类，同类变量
--实例变量是和对象有关的，对象不同，实例变量也不同

7-3-【方法】

实例方法和类方法 类似 实例变量和类变量的关系
实例方法定义 static修饰符

7-4-【实例方法和类方法的区别】

方法可视为"块"，方法有入口地址，进入的是对象

1—对象调用实例方法

1---地址被所有对象共享
对于实例方法来说，当字节码文件加载到内存中，实例方法不会被分配入口地址，只有创建对象，地址才会分配，这个地址也是共享的被类的所有对象，可把方法当动物园，对象就是人，有人，动物园的入口才会被打开,若所有对象不存在，则方法的入口地址被取消
可以理解 方法就是不同对象用"它的"的各种变量"搞事情"的地方


2---实例方法可以操控实例变量，也可以操控类变量(因为是静态的内存)
用房间或动物园的例子，很容易理解，各对象在方法中，用它的变量"搞事情"，那么对象有那些变量呢?
①类变量。是被分配给对象的，被所有对象共享的类变量
②实例变量。是创建对象时，同时分配给对的内存空间

2—类名调用类方法

注意*
--类名不能调用实例方法，实例方法只能被对象调用(决定性*)
--类方法不能操作实例变量(因为实例变量是对象创建时分配的，权限*)

Q-方法如何决定是类方法，还是实例方法?

也就是有什么需求会把一个方法设计为类方法(static method)

static方法特点 ： 不用创建对象用类名就可以调用它
如果一个方法不需要操控类中的实例变量，就可以满足程序需求，则可考虑设计为static方法
Java类库中的
	Array类
	Math类

八，【方法重载】

Q-重载是什么?

--属于Java中的多态
Java中的多态有什么?
--重载(overload)，重写(override)
--重载就是功能的多态性

8-1-【方法重载的语法规则】

Q-重载语法上的定义是怎样的?

一类中的有多个方法，方法可同名，但是方法的参数需要不同

Q-参数不同值的什么?

1---参数个数不同
2---参数个数同，但是类型须不同

如 有这么一个类，有若干同名方法
class People
{
	float hello(int a ,int b)
	{
		return a+b;
	}
	
	float hello(long a ,int b)
	{
		return a-b;
	}
	double hello (double a ,int b)
	{
		return a*b;
	}
}
可以理解为 "同名不同样"
如同同名的人，但是是不同的人

九，【this关键字】

Q-this的使用场景?

1—构造方法中
2—实例方法中

this可表示调用方法或变量的普遍意义上的 "对象"
注意*实例方法仅对象可调用
对于方法来说，方法中的this代表操作此方法中变量的"对象"，即对象(类的实例)

this.成员变量 ;//当实例成员变量在实例方法中出现
类名.成员变量 ;//当类变量在实例方法中出现

例如
class A
{

	int x;
	static int y;
	void f() 
	{
		this .x = 100;
		A.y = 200;
	{

}
此时的 this 和 A可以省略(因为可以被区分)

this的常用的应用?

	当方法中的成员变量名和局部变量名重名时，使用  『this.成员变量名』 表示 成员变量
	
	类的实例方法可以调用其它方法，实例方法调用默认格式
	this.方法
	类名.方法

如

class B 
{
	int x = 2 ;
	
	void y(int n)
	{
		int x = n;
		this.x = n;
	}
	
	void f()
	{
		this.g(); //某对象.实例方法
		B.h(); //类名.类方法
	}
	void g()
	{
		System.out.pintln("OK");
	}
	static void h()
	{
		System.out.println("Hello");
	}
}

此时 方法y中的x就有歧义的，如不加区分，则无法判断，加this表示非局部变量

*是否使用this的条件就是 调用的逻辑关系是否明确

*注意 this不能出现在类方法中，因为对象"是否存在的原因"

十，包语句

Q-包是什么？有什么用?

简而言之，包的作用就是便于管理
--包是一个机制，管理类的机制
--因为不同源文件可能会出现同名类，需要区分，就加一个"限定词"，就是包名，通过隶属关系来确定类的不同

Q-包如何使用?

1---关键字 package声明包，如   package 包名 ;
--表示类声明包【for源文件】，包语句一般是源文件的第一条语句
--如果省略包，则源文件定义的类被隐含认为是无包名的一部分
--只要这些字节码文件放在同一个目录下，可认为是同属于一个包
2---包可以是合法标识符，也可是若干标识符+.分隔而成
	如 package sunrise;
	    package sun.com.cn;

10-1-【有包名类的储存路径】

Q-如果一个类定义了包名该如何处理？

以包名为准

如有一源文件定义包名
 package tom.jiafei ;
--则储存此文件目录必需包含这样结构 …\tom\jiafei，如C:\1000\tom\jiafei
--并且将源文件编译的字节码文件放置到C:\1000\tom\jiafei目录路径下
--源文件可以任意存放，但要保证，最后的字节码文件须在…\tom\jiafei路径下
可以这样，将源文件放置C:\1000\tom\jiafei中，然后到C:\1000下，编译
javac tom/jiafei/源文件
//格式  
javac 编译的源文件文件路径
//编译在哪里，字节码文件就在哪里

Q-为什么要以包名为主?

–因为定义了包是用于限定类的，即限定类所在的源文件，最后的源文件生成的字节码文件必须在"包"下

10-2-【运行有包名的主类】

注意运行有包名主类时，须在包的上一层目录运行主类所在的字节码文件

why?
如主类包名就是 tom.jiafei，那最后的字节码文件必定储存在…\tom\jiafei目录下
程序执行的是主类，不能在所在目录运行，所以须到上层目录运行，假设是1000，格式如下
C:\1000> java tom.jiafei.主类名  //注意此时是java ，不是javac

注意*

编译时，编译路径无所谓
运行时，必须到包的上级目录下运行

Java程序不允许将Java作为包名第一部分，如Java.bird是非法的

十一，【import语句】

Q-import语句是干什么的?

解决某类想使用与其不在同包中的另外一个类的问题

对于某类A想使用类B中的对象

情况1，如果位于同包名下，则可以使用

情况2，如果位于同路径下，则可以使用

情况3，如果是不同包，则不可以使用

11-1-【引入类库中的类】

毫无疑问，用户编写的类和类库的类肯定不在同一个包中!

Q-如何使用与自己不同包的中的类?

--使用import语句
--必须写在package和源文件定义之间，即第二的位置

Q-Java类库常用包有哪些?

java.lang // 包含所有的基本语言类
java.swing //包含抽象窗口工具集中的图形，文本，窗口GUI类
java.io //包含所有的输入/输出类
java.util //包含实用类
java.sql //包含操作数据库的类
java.net //包含所有实现网络功能的类

如想引入包中全部类，使用通配符*

import java.lang.* ;

import java.lang.Date; //只是引入Date类

案例-使用java.utl中的Date类创建对象，显示本地时间

import java.lang.util.Date; //导入要使用到的类所在的包

public class showTime
{
	Date date = new Date();
	System.out.println("本地机器当前时间: ");
	System.out.println(date.toString());
}

知识小课堂-java.lang包是什么?，有什么作用?

1---Java语言核心类库，包含运行Java必须系统类
--系统自动为程序引入包中类，无需再使用import

2---如使用import引入全部类，会增加编译时间，但不会影响运行时间，因真正使用所需的字节码文件

3---如没使用import引入包中类，也可直接带包名使用，如
java.lang.Date date = new java.lang.Date();        //java.lang.Date的java.lang作用是定位Date类是java.lang包中的

11-2-【引入自定义包中的类】

Q-程序如何使用import语句引入非类库中有包名的的类?

如import tom.jiafei.* ;

1—如果想在任意位置使用非类库，自定义包的类，就设置classpath

1—如想程序使用tom.jiafei中类，classpath中指定位置
–假设tom.jiafei包位于 C:\1000\tom\jiafei中
–即包名为tom.jiafei的类储存在C:\1000\tom\jiafei目录下
2—用户可以更新classpath设置如下
set classpath=E:\jdk1.8\jre\lib\rt.jar;.;C:\1000
rt.jar是类库类
.;表示加载应用程序当前目录无名包类
C:\1000是新加classpath取值，表示加载C:\1000目录下无名包

也就表示，如果程序使用到了某一个包名下的类，可以通过环境变量下提供的路径查找是否存在该类

2—如用户不想更新classpath，可把程序使用的自定义包名形成的目录放置同文件夹下

案例-创建一个Triangle.java文件，包含triangle类，可创建"三角形"

trianlge类设置包名 sohu.com
如有需要使用三角形的程序，可使用import引入此类
将Triangle.java文件保存到C:\ch4\sohu\com目录下,编译如下

C:\ch4> javac sohu\com\Triangle.java  //编译指定包下的文件

如有一主类Example.java想使用triangle类，可import引入
假设Example.java主类所在包为hello.nihao,使用import程序代码如下

package hello.nihao;    //表示为类设置包
import sohu.com.Triangle;   //引入其他包的类
public class Example
{
	public static void main (String args[])
	{
		Triangle tri = new Triangle();
		tri.setsides(30,40,50);
		System.out.println(tri.getArea());
	}
}

将Example.java保存在C:\ch4\hello\nihao目录下，编译如下

C:ch4> javac hello\nihao\Example.java //编译
C:ch4> java hello.nihao.Example //执行

分析程序文件包路径和引入包类的路径

如果 (主类文件无包名): //这个主类是想import其他包类的类
	将主类文件保存到同文件夹下，这个文件夹下有"定义包名的类"所在的包
	C:\ch4> javac Example.java //编译
	C:\ch4> jav Example.java //运行
如果 (都是无名包 && 在同文件夹下):  //注意是同文件夹下的类，也就是默认的"同文件夹下主类使用其他类的情况"
	可以互相使用
	

无名包可使用import引入有名包，但是有名包无论如何不能使用无名包

Q-为什么这样可以?

因为有一个条件,如果想使用其他包中类，须确保都在同文件夹下
程序是这样操作的 "先编译主类，发现import了一个有名包的类，就在主类(可设置包名)所在上级目录下找这个包，再找同名的类"

核心在于逻辑上是否能找到

Q-如果一个有名包的类想import一个无名包的类是不行的,为什么?

可以这样理解,在上级目录往下找，没有指定包名，就无从入手(也不可能遍历整个目录)

十二，【访问权限】

Q-访问权限是什么?

–当 类创建对象，对象使用 "."运算符操控成员或方法
–但是 ，访问是有权限的，是有限制的

Q-访问权限修饰符有哪些?

–private ,protected,public
–都是java关键字

Q-各种访问权限修饰符有什么功能和区别?

private私有变量，私有方法

--当设置类A的变量(成员变量，类变量)，方法(实例方法，类方法)权限为private
--则在其他类B中的类A中的对象不能操作/使用，类A中的变量，方法 
//即不能在外部访问

共有变量和共有方法

–和private相反

友好变量和友好方法

不用private,public,protected修饰符修饰的变量，即友好变量或有好方法(也就是默认的权限状态)

–同包，可访问友好变量和友好方法

受保护的成员变量和成员方法

类A中用类B创建对象，若类B中有protected变量或方法
--同包内，该类B对象可访问其protected变量，方法
--任何一个与类B同包的类，可以用类B类名，访问类B中的protected变量，方法
//这个保护指的是 同包名下的权限

public类和友好类

–不能使用protected和private修饰类
–访问控制符权限高到低
public》protected》友好》private

十三，【基本类型的类封装】

十四，【对象数组】

Q-数组是什么?

相同类型变量的集合

Q-如何正确使用数组?

若Student类有10个对象，常规办法声明
stu0,stu1,stu2,stu3…这样显然是不行的
使用对象数组(就是元素是对象)

/*
数组是相同类型数据变量的集合
对象也是数据类型的变量
即对象数组，就是数组的元素是对象

但是根据之前的基本类型类封装
数组也是一个对象
*/
Student [] stu; 
/*
Student 是数据类型，类
[] stu 是一个变量，且是数组
即声明的对象是一个数组，显然数组中元素的类型就是 类，那么元素就是对象
*/
stu = new Student[10] ; 
/*
仅仅是创建一个数组，包含10个元素的，此时是空对象
因此使用stu对象数组之前，需要创建对象,这个对象就是数组对象
*/
//如 
stu[0] = new Student(); //表示给数组对象赋值，这个值就是对象

案例-使用对象数组，依次为对象赋值

class Student
{
	int number;
}

public class Example
{
	public static void main(String args[])
	{
		/*
Student stu[] = new Student[10] 
表示用Student类创建一个对象，这个对象是数组，且数组元素又是对象
即 创建一个有10个对象元素的数组，数组变量名为 stu[]
		*/
		Student stu[] = new Student[10];
		for(int i = 0;i<stu.length;i++)
		{
			stu[i] = new Student(); //为数组对象stu[]添加对象元素
			stu[i].number = 101+i;
			
		}
		for(int i = 0 ;i<stu.length;i++)
		{
			System.out.println(stu[i].number);
		}
	
	}
}

十五，【JER扩展和jar包】

Q-JRE扩展是什么?

--Java类(能实现某功能的类)
--扩展只是从属性上的区分，低位是不一样的，功能是一样的

Q-为什么要用JRE扩展 ?

--JRE是(Java runtime Eviroment)的扩展
--Java运行环境提供的类库只是核心库，满足不了变化的需求，满足不了用户的需求，所以需要扩展实现功能的最大化

Q-Jar文件是什么?

--Java运行环境提供扩展(\jre\lib\ext)
--将类打包为 jar文件，放入扩展，程序就可用import使用扩展中的类

Q-如何打包为jar文件?

1---使用jar.exe命令，可将字节码文件压缩成jar文件
2---将jar文件存放java运行环境(jre)扩展中，即JDK安装路径jre\lib\ext文件夹下
3---这样Java程序可使用Jar中类创建对象
许多数据库厂商提供数据库驱动就是这样

案例

十六，【doc文档生成器】

Q-Java文档生成器是什么?

–制作源文件类结构的html文件
–使用javadoc.exe程序

Q-Java文档生成器怎么用?

1---进入有Java源文件(xxx.java)的目录
2---输入命令 javadoc xxx.java
3---这时将在本目录生成html文件，查看类的结构(类中方法，变量)
也可指定存放html路径使用 -d target_path
如 javadoc -d F:\test xxx.java

案例