面向对象和面向过程的理解
感谢尚硅谷免费对视频
面向对象和面向过程都属于思考问题的方式
面向过程：以执行者的角度思考问题，侧重于实现的过程，或侧重于“怎么做”，比较适合解决小型的问题
面向对象：以指挥者的角度思考问题，侧重于“谁来做”，比较适合解决中大型的问题
总结：面向对象和面向过程并不是完全独立的。一般来讲，从宏观上先用面向对象思考方式，然后在细节上又使用了面向过程的思考方式
案例1：
一个人单身：
拖地
洗衣服
做饭
看电影
学习
玩游戏
两个人;
女朋友：拖地
女朋友：洗衣服
女朋友：做饭
我：看电影
我：学习
我：玩游戏
面向对象的实现思路
步骤1、通过问题，抽取对象
名词抽取法
人机大战
步骤2、分析该问题中涉及到了对象的哪些行为或属性，从而将共同的行为后属性抽取成“类”
步骤3、创建类
步骤4、根据类创建对象，并使用
类和对象的理解
类和对象的概念
对象：客观世界中存在的一切可以被描述的事物，都称为对象
如何区分开每一个对象呢？
通过对象的特征（属性和方法）
属性：描述对象的静态、外观的特性，比如 姓名、颜色、身高、价格等
方法：描述对象的行为或功能，比如吃、喝、学习、睡觉、能盛水等
类： 一组具有相同属性和方法的对象的集合，抽取成类（归纳总结出来的）
类和对象的区别
对象：实际存在的，可以直接操作，是一个具体的实例
类：抽象的、模板式的存在，不可以直接操作
类和对象的关系
类：是一组对象的集合，是对象的类型，是通过对象归纳总结出来的产物
对象：在java中，通过类创建出来的具体的实例
类和对象的创建 ★
类的创建
【修饰符】 class 类名{
编写属性
编写方法
}
对象的创建和使用
类名 对象名 = new 类型();
对象名.属性=值;
对象名.方法();
类和对象的内存分配图
特点：
1、每次创建对象时，都需要进行下面操作：
①先去判断需要的类是否已经加载，如果已经加载了，则无需再加载，如果没有加载，则需要通过类加载器加载类信息到方法区
②在堆中创建新对象
2、栈、堆、方法区的存储
栈：对象的引用、局部变量
堆：对象和全局变量（属性）
方法区：类信息
类的成员★
属性
1、属性的类型可以为任意类型，包含基本类型和引用类型
2、每个对象的属性是独立的。其中一个对象对其属性进行更改，不影响另外一个
3、属性的定义语法和使用，同变量，也就是本质上就是变量
变量根据作用域不同，可以分为两类：全局变量和局部变量
变量的作用域：也就是变量的作用范围，根据变量定义的位置决定的，一般是指包含变量定义的最近的大括号
全局变量：作用域为整个类体，也就是属性或成员变量
局部变量：作用域为包含它的方法或代码块中，也就是除了属性，其他的变量都是局部变量
作用域 变量重名 存储位置 生命周期 访问可见性 修饰符
全局变量 较大，整个类体 两个全局不能重名 堆 较长 本类以及其他类 √
局部变量 较小，方法或代码块 两个局部有交集也不能重名， 栈 较短 本类的方法或代码块 ×
但一个全局一个局部可以重名
遵循就近原则
方法
理解
方法 ：定义在类体中，描述了一组对象的行为或功能。又称为函数。
好处
1、对于调用者来讲，不关心具体的实现细节，调用比较方便，只需要关心
“叫什么”和“干什么”。
从一定程度上来讲，提高了安全性和封装性
2、对于设计者来讲，提高代码的重用性和维护性
方法的五要素
1、修饰符
可选
2、返回类型
特点：某个方法执行结束后需要返回给调用方一个结果，则该方法需要设计成带返回值的方法
① 一个方法至多有一个返回值
②返回类型可以为任意数据类型，包含基本类型或引用类型
public int method(){}
public Person method(){}
public int[] method(){}
③如果方法没有返回值，则返回类型写void，方法体中不需要return语句
如果方法有返回值，则返回类型写返回值的类型（一致或兼容），方法体中必须写上return 值;
public void method(){
syso();
}
public int method(){
syso();
return a；
}
④如果方法有返回值，则要保证方法体的执行语句最后一句肯定为return语句
public int method(){
if(){
return 100;
}
}
3、方法名
4、参数列表
特点：有的行为的执行，需要调用方在最开始传入一些值，才能执行，这些值称为参数
①参数可以有0个或多个，具体语法
(参数类型 参数名,参数类型 参数名)
②参数类型 可以为任意类型，包含基本类型或引用类型
public void method(int a,String b,int[] arr,Person per){}
③调用带参数的方法时，必须传入指定类型的参数，否则报错！
5、方法体
特点：描述功能或行为具体实现的步骤，里面可以放任意逻辑语句，输入、输出、变量、循环、方法的调用等，但不能放方法的定义
方法的声明
语法：
修饰符 返回值类型 方法名 ( 参数列表) {
方法体语句；
}
具体形式：
1.无返回无参
2.有返回无参
3.无返回有参
4.有返回有参
方法的调用
语法：
同一个类中：
类型 名 = 方法名(参数列表);
不同类中：
类型 名 = 对象名.方法名(参数列表);
方法的调用机制
每次调用方法，伴随着“方法入栈”操作，也就是栈中为该方法分配了一块空间，用于保存该方法中涉及到的变量
每次方法调用结束，伴随着“方法出栈”操作，也就是栈中分配的空间被释放了
方法的传参
概念：
当调用方法时，将实参传递给形参（参数的赋值）的过程，称为方法的传参。
示例：
public void method(int age){
}
int a=100;
method(a);
特点：★
基本类型做参数，传递的是值，形参的改变不影响实参
引用类型做参数，传递的是地址，形参的改变（成员）影响实参
【面试题】java中方法的参数传递的是什么？
java中，方法参数是按值传递！
如果是基本类型，则值 代表元素内容
如果是引用类型，则值 代表地址号
注意：
当引用类型做参数时，如果形参改变的是地址，则最终不影响实参
方法的重载
概念：
java中允许同一个类中，多个方法的名称相同，但参数列表必须不同
这种现象称为重载！
特点：
①、必须保证参数列表中至少有一样不同（参数类型、参数个数、参数顺序）
②、返回类型无要求
③、修饰符无要求
经典案例：
System.out.println();
可变参数的方法
概念：
jdk5.0出现的新特性。将同一个类中，多个方法名相同、参数类型相同、返回类型相同，仅仅是参数个数不同的方法抽取成一个方法，这种方法称为可变参数的方法
好处：
提高代码的重用性和维护性
语法：
修饰符 返回类型 方法名(参数类型...参数名){
}
注意：使用时，将可变长度的参数当做数组使用
使用特点：
1、可变参数的实参可以为0个或任意多个
2、可变参数的实参可以为一维数组类型
3、可变参数和普通类型参数 一起使用时，只能放在最后
4、一个参数列表中至多有一个可变参数！
包
包的好处
1、类似于文件系统的文件夹，可以实现分类管理类文件，方便查找
2、解决了同一个项目中同名类的冲突问题
包的创建
包的起名
命名规则：
标识符+小圆点
标识符：只能包含数字、字母、下划线和$符号，不能以数字开头，不能是关键字或保留字
写法：标识符.标识符
举例：
demo.int ×
java.demo ×
demo.3a ×
命名规范：
建议小写字母，并且采用域名倒置的写法
域名倒置：com.baidu
www.baidu.com
建议写法：
com.公司名.部门名.项目名.业务模块名;
com.项目名.业务模块名;
包的使用
1、package关键字
①如果某类存在于指定包下，则要求类的最上方必须添加包的声明语句，语法如下：
package 包名;
②包的声明语句在一个类中只可能出现一次
③位置：最上面
2、import关键字
①跨包访问某类，必须要求导入该类所在的包&&该类具有跨包访问权限
语法：
import 包名.类名;或
import 包名.*；
②导入包的语句在一个类中可以出现多次，没有顺序要求
③位置：package——import——class
④如果想访问多个包中的同名类，则要注意不能直接类上方添加import导包语句，否则有歧义
可以使用全类名限定的方式
访问修饰符
理解
访问修饰符用于修饰类和类的成员，放在要修饰的类或类的成员前面，用于限定访问权限
使用特点
修饰类的成员：比如属性和方法
意思 访问范围
private 私有的 仅仅本类中可以访问
缺省 默认的 本包中所有类都可以访问
protected 受保护的 本包中所有类以及其他包的子类可以使用
public 公共的 所有包中的所有类都可以访问
修饰类：只能用public和缺省的修饰类
缺省 只有本包中才能访问该类
public 所有包中都可以访问该类
封装
好处
1、提高数据的安全性，隐藏细节
2、提高代码的重用性，有利于程序的扩展
广义的封装：方法、类、包
狭义的封装：类中的属性的封装
封装的具体体现
1、将属性私有化
2、提供公共的set方法，为属性赋值
3、提供公共的get方法，对外暴露该属性
规范
将所有的属性实现封装，当然如果有特殊要求
比如属性为只读，则仅仅提供get方法
比如属性为只写，则仅仅提供set方法
5、this关键字
一、理解
this关键字可以用来访问本类的属性、方法、构造器，代表的是本类的当前对象
二、好处
this用于区分当前类的成员和局部变量或其他类的成员重名时
三、语法
访问属性：
this.属性名=值;
System.out.println(this.属性名);
访问方法：
this.方法名(参数列表);
6、构造器
理解
构造器又称为构造方法，属于类中的第三大成员，和方法很像，都具有方法体，都需要调用才能执行，但不是通过对象名.调用，而是通过其他方式调用
语法
【修饰符】 方法名(参数列表){
构造器体
}
注意：
1、方法名和类名完全一致
2、没有返回
好处
1、用于创建对象
2、可以在创建对象的同时进行初始化操作，一般用于对属性赋值，提高代码的重用性
特点
1、一个类如果没有显式的提供构造器，则系统默认提供一个无参构造器
2、如果类中显式的声明了构造器，则系统不再提供构造器
3、构造器可以重载
4、构造器对于一个对象来讲，只调用一次
语法：new 构造器名(参数列表);
5、构造器之间也可以互相调用
语法：this(实参列表);
注意：构造器的调用必须放在构造器的第一句！
JavaBean
概念
一种可重用性的组件
要求
类是公共的
有一个无参的公共的构造器
有属性，且有对应的get、set方法
笔记
面向对象相关概念
一、面向对象和面向过程的概念和关系
面向对象和面向过程都属于一种思考方式
面向对象侧重于 “谁来做”，以指挥者的角度思考问题，比较适合解决中大型的项目
面向过程侧重于“怎么做”，以执行者的角度思考问题，比较适合解决较小型的项目
面向对象和面向过程不是完全独立的，而是相辅相成，不可分割
总结面向对象的思路：
1、根据“名词抽取法”抽取问题中涉及到的对象
2、根据问题中的需求，分析对象涉及到的属性和方法，进而根据共同点，往上抽取成“类”
3、创建类，编写属性和方法
4、根据类创建对象，并且使用对象的属性和方法！
二、类和对象的概念、关系和区别
1、概念
对象:客观世界中所有可以被描述的事物都称为对象。
类： 具有相同属性和方法的一组对象的集合
2、关系
对象 是类的一个具体的实例
类 是对象所属的类型
3、区别
对象 是具体的、实际存在的，可以操作的
类 是抽象的，模板式的，不可以直接操作的
类和对象对创建使用
一、类的创建
1、声明类
2、编写里面的属性
3、编写里面的方法
public class A{
属性类型 属性名;
....
public 返回类型 方法名(){
}
}
二、对象的创建和使用
1、对象的创建语法（定义引用类型的变量）
类型 对象名 = new 类型();
int a = 值;
2、对象的使用
①访问属性
对象.属性名=值；
syso(对象.属性名);
if(对象.属性名==值){}
②访问方法
对象.方法名();
三、类和对象的内存分配图
属性
特点：
1、属性的定义语法和变量完全一样。因为本质就是变量
2、属性的定义类型可以为任意类型，包含基本类型和引用类型
3、不同对象的属性都是独立的，互不影响
4、变量根据作用域不同，分为两类
全局变量：定义位置为类成员位置，作用域为整个类体
局部变量：定义位置方法或某个代码块中，作用域为定义它的方法或代码块中
区别：
①全局变量的生命周期较长，伴随着对象的创建而创建，对象的消亡而消亡
局部变量的生命周期较短，伴随着方法或代码块的执行而创建，方法或代码块的结束而消亡
②存放位置不同
全局变量存放在堆中
局部变量存放在栈中(如果是基本类型，变量名和值都在栈中；如果是引用类型，变量名存在栈中，值存在堆中)
③关于重名问题
两个全局不能重名
两个局部，如果作用域有交集，不可以重名；如果没有交集，可以重名
一个全局和一个局部可以重名！默认访问的是遵循就近原则
class A{
int a=10;
public void count1(){
int a=99;
syso(a);
}
public void count1(){
syso(a);
}
}
④默认值的问题
全局变量，可以不赋值，直接使用。因为其有默认值
int 0
double 0.0
char \u0000
boolean false
引用类型 null
局部变量，必须先赋值，才能使用
public void method(int a){
System.out.println(a);
}
方法
一、方法的好处
1、提高代码的重用性和维护性
2、方法从一定程度上实现了封装性，调用方法时，不需要关心具体的实现细节，提高代码的安全性
二、方法的声明和五要素 ★
语法：
修饰符 返回类型 方法名(参数列表){
方法体
}
1、返回类型
①如果方法有返回值，则方法体中必须加return语句，并且return后的值类型必须和返回类型一致或兼容
如果方法没有返回值，则方法体中不用加return语句，返回类型写void。如果非要加return语句，则写成 return;
②一个方法至多有一个返回值
③方法的返回类型可以为任意类型
④如果方法有返回值，则必须保证所有路径下的最后执行语句都是return语句
public int m(){
if(){}
else if(){}
}
2、参数列表
①参数可以0个或多个，中间用 逗号隔开
②参数类型可以为任意类型，包含基本类型和引用类型
③方法定义时，参数列表的参数称为形式参数，简称形参。形参需要有类型，实参不需要有类型。
要求形参和实参的类型、个数、顺序必须一致或兼容，参数名无要求！
public int m(String a,char b){
a.indexOf(b);
}
方法调用时，参数列表的参数称为实际参数，简称实参
String s1 = "john";
char ch ='j';
m(s1,ch);
三、方法的调用
同一个类：
直接调用即可：方法名(实参列表);
不同类中：
通过对象名调用：对象名.方法名(实参列表);
如果有返回值，则最好用变量接收。
四、方法的调用 机制
每次调用方法，都相当于入栈操作
方法调用结束，都相当于出栈操作
五、方法的传参★
理解：
调用方法时 ，将实参传递给（赋值给）形参的过程，称为方法的传参。
【面试题】
java中到底是按什么传递参数的？
答：java中按值传递参数的！
如果参数类型为基本类型，则值代表的是元素内容，所以形参的改变不影响实参！
如果参数类型为引用类型，则值代表的是地址号，所以形参的成员改变影响实参！但如果形参改变的是地址，则不影响实参！
六、方法的重载
概念：java中的一种机制，允许同一个类中，多个方法名相同但参数列表不同的方法存在！
好处：
1、解决了起名麻烦的问题
2、对于调用方，解决了记名麻烦的问题
特点：
①同一个类中
②方法名必须相同
③参数列表必须不同（参数顺序、个数、类型至少一样不同），参数名无要求
④返回类型无要求
⑤修饰符无要求
七、可变参数的方法
概念：jdk5.0出现的新特性。将方法重载涉及到的多个方法，根据以下特点抽取成一个可变参数的方法
①方法名必须相同
②返回类型相同
③参数类型相同
④参数个数不同
好处：
提高方法的重用性
语法：
修饰符 返回类型 方法名(参数类型...参数名){
//可以将参数看做是数组使用
}
注意：
①可变参数的实参允许0个或多个
②可变参数的实参允许一维数组
③可变参数可以和普通类型的参数放一起，但可变参数要求必须在最后
④一个方法中至多有一个可变参数！
对象数组
一、理解：
数组的定义类型为对象类型
二、使用：
动态初始化
1、声明并开辟空间
2、赋值
3、循环遍历数组中的每一个元素
静态初始化
1、声明并初始化
2、循环遍历数组中的每一个元素
对象关联
一、理解
一个对象中又引用了另一个对象，其实就是 一个类中的属性类型为引用类型
包
一、包的创建
方式一：创建类时，同时指定包名
方式二：创建包
方式三：手动添加包的声明
二、包的命名
规则：合法的标识符+小圆点
规范：小写，遵循域名倒置
建议：com.项目名.业务模块名
三、包的使用特点
1、package关键字
声明包的语句：package 包名;
声明包的位置:必须在类的最上面
声明包的个数：至多有一个
2、import关键字
同一个包中的类，可以直接访问（创建对象）
跨包中的类，如果想访问（创建对象），【前提该类使用public修饰符】必须导入所在的包，语法：
import 包名.类名;或import 包名.*;
导入包的位置：package——import——class
导入包语句的个数：任意个，而且没有顺序
访问修饰符
一、理解
访问修饰符可以用于修饰类或类的成员，不能修饰局部变量，作用就是限定类或类的成员的访问权限
二、修饰类的成员
本类 本包 其他包的子类 所有包的所有类
private √ × × ×
缺省 √ √ × ×
protected √ √ √ ×
public √ √ √ √
三、修饰类
只有public和缺省才可以用于修饰类
缺省 √ √ × ×
public √ √ √ √
封装
一、概念：属于面向对象的第一个特征
二、好处：
1、隐藏了实现细节
2、提高数据的安全性
对于狭义的封装，避免了对属性任意赋值的危险！
三、具体的体现步骤：
1、将属性私有化
2、提供公共的set方法和公共的get方法
public void setXX(属性类型 参数名){
this.属性=参数名;
}
public 属性类型 getXX(){
return 属性名;
}
四、javaBean
相当于平时定义的实体类，要求必须具备以下条件
1、该类是public修饰的
2、该类必须有属性，并且进行了合理封装
3、该类必须有无参构造器
this关键字
一、理解
this关键字可以用来访问本类的属性、方法、构造器，代表的是本类的当前对象
二、好处
this用于区分当前类的成员和局部变量或其他类的成员重名时
三、语法
访问属性：
this.属性名=值;
System.out.println(this.属性名);
访问方法：
this.方法名(参数列表);
构造器
一、概念
构造器又称为构造方法，本质就是一个方法，只不过是方法名和类名完全一致，而且不是通过对象调用的，而是在创建对象时隐式调用的！
二、好处
1、用于创建对象
2、可以实现初始化对象信息的操作（一般为属性赋初值）
三、语法
【修饰符】 类名(参数列表){
构造器体;
}
1.没有返回
2.类名和构造器名完全一致！！
四、特点
1、每个类都有构造器，如果没有显式的声明构造器，则系统将默认提供一个无参构造器
2、如果显式的声明构造器，则系统不再提供任何构造器
3、一个类中允许多个构造器存在的，也就是构造器重载！
4、对于同一个对象来讲，构造器的调用只可能一次，就是在创建对象时
5、构造器调用
1.在其他类中，创建对象时！
new 构造器名|类名();
2.在本类中，构造器之间也可以互相调用。或调用父类的构造器！（并没有创建对象）
this(参数列表);
super（参数列表）；
图解java面向对象（上）
面向对象(OOP)与面向过程
二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为。面向对象，将功能封装进对象，强调具备了功能的对象。
面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。
面向对象的三大特征
封装 (Encapsulation)
继承 (Inheritance)
多态 (Polymorphism)
面向对象分析方法分析问题的思路和步骤
根据问题需要，选择问题所针对的现实世界中的实体。
从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。
例子：人把大象装冰箱
类(class)和对象(object)是面向对象的核心概念。
类是对一类事物的描述，是抽象的、概念上的定义
对象是实际存在的该类事物的每个个体，因而也称实例(instance)。
可以理解为：类 = 抽象概念的人；对象 = 实实在在的某个人
面向对象程序设计的重点是类的设计
定义类其实是定义类中的成员(成员变量和成员方法)
属 性：对应类中的成员变量
行 为：对应类中的成员方法
类对语法格式举例：
public class Person{
private int age ; //声明私有变量 age
public void showAge(int i) { //声明方法showAge( )
age = i;
}
}
代码：
class Person{//人类
//1.属性
String name;//姓名
int age = 1;//年龄
boolean isMale;//是否是男性}
class PersonTest{
main(){
Person p = new Person();
Person p1 = new Person();
p1.name = “Tom”;
Person p2 = p1;
}
}
语法格式：
修饰符 类型 属性名 =初值 ;
说明:修饰符private:该属性只能由该类的方法访问。
修饰符public:该属性可以被该类以外的方法访问。
类型：任何基本类型，如int、boolean或任何类。
举例：
public class Person{
private int age; //声明private变量 age
public String name = “Lila”; //声明public变量 name
}
在方法体外，类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。
成员变量：
成员变量定义在类中，在整个类中都可以被访问。
成员变量分为类成员变量和实例成员变量，实例变量存在于对象所在的堆内存中。
成员变量有默认初始化值。
成员变量的权限修饰符可以根据需要，选择任意一个
局部变量：
局部变量只定义在局部范围内，如：方法内，代码块内等。
局部变量存在于栈内存中。
作用的范围结束，变量空间会自动释放。
局部变量没有默认初始化值，每次必须显式初始化。
局部变量声明时不指定权限修饰符
语法格式：
修饰符 返回值类型 方法名 ( 参数列表) {
方法体语句；
}
举例：
public class Person{
private int age;
public int getAge() { return age; } //声明方法getAge
public void setAge(int i) { //声明方法setAge
age = i; //将参数i的值赋给类的成员变量age
}
}
对象的创建和使用
使用new +构造器创建一个新的对象；
使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）；
public class Animal {
public int legs;
public void eat(){
System.out.println(“Eating.”);
}
public viod move(){
System.out.println(“Move.”);
}
}
对象的产生
class Person{
int age;
void shout(){
System.out.println(“oh,my god! I am ” + age);
}
}
Person p1 = new Person();执行完后的内存状态
对象的使用
class PersonTest{
public static void main(String[] args) { //程序运行的内存布局如下图
Person p1 = new Person();
Person p2 =new Person();
p1.age = -30;
p1.shout();
p2.shout();
}
}
判 断：
与void show(int a,char b,double c){}构成重载的有：
void show(int x,char y,double z){} // x
int show(int a,double c,char b){} // ✔
void show(int a,double c,char b){} // ✔
boolean show(int c,char b){} // ✔
void show(double c){} // ✔
double show(int x,char y,double z){} // x
void shows(){double c} // x
Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：
隐藏一个类中不需要对外提供的实现细节；
使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
便于修改，增强代码的可维护性；
对于class的权限修饰只可以用public和default(缺省)。
public类可以在任意地方被访问。
default类只可以被同一个包内部的类访问。
构造器的特征
它具有与类相同的名称
它不声明返回值类型。（与声明为void不同）
不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值
构造器的作用：创建对象；给对象进行初始化
如：Order o = new Order(); Person p = new Person(Peter,15);
语法格式：
修饰符 类名 (参数列表) {
初始化语句；
}
举 例：
public class Animal {
private int legs;
public Animal() {legs = 4; } //构造器
public void setLegs(int i) { legs = i; }
public int getLegs(){return legs;}
}
创建Animal类的实例：Animal a=new Animal();
//调用构造器，将legs初始化为4。
根据参数不同，构造器可以分为如下两类：
隐式无参构造器（系统默认提供）
显式定义一个或多个构造器（无参、有参）
注 意：
Java语言中，每个类都至少有一个构造器
默认构造器的修饰符与所属类的修饰符一致
一旦显式定义了构造器，则系统不再提供默认构造器
一个类可以创建多个重载的构造器
父类的构造器不可被子类继承
JavaBean是一种Java语言写成的可重用组件。
所谓javaBean，是指符合如下标准的Java类：
类是公共的
有一个无参的公共的构造器
有属性，且有对应的get、set方法
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。
在java中，this关键字比较难理解，它的作用和其词义很接近。
它在方法内部使用，即这个方法所属对象的引用；
它在构造器内部使用，表示该构造器正在初始化的对象。
this表示当前对象，可以调用类的属性、方法和构造器
什么时候使用this关键字呢？
当在方法内需要用到调用该方法的对象时，就用this。具体的：我们可以用this来区分局部变量和属性。比如：
this.name = name;
-
java.lang----包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。 -
java.net----包含执行与网络相关的操作的类和接口。 -
java.io ----包含能提供多种输入/输出功能的类。 -
java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。 -
java.text----包含了一些java格式化相关的类 -
java.sql----包含了java进行JDBC数据库编程的相关类/接口 -
java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界 面(GUI)。 B/S C/S Client
277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
