目录
面向对象和面向过程有什么区别
类和对象的概念
程序在什么情况下会出现空指针异常呢？
方法调用时参数的传递问题
构造方法
封装
面向对象和面向过程有什么区别
- 从语言方面出发：
对于C语言来说，是完全面向过程的。
对于C++语言来说，是一半面向过程，一半面向对象。（C++是半面向对象的）
对于java语言来说，是完全面向对象的。 - 什么是面向过程的开发方式？
面向过程的开发方式主要的特点是：
注重步骤，注重的是实现这个功能的步骤。
第一步干什么
第二步干什么
. . . . . .
另外也注重实现功能的因果关系
因为A所以B
因为B所以C
因为C所以D
. . . . . .
面向过程中没有对象的概念。只是实现这个功能的步骤以及因果关系。 - 面向过程有什么缺点？（耦合度高，扩展力差）
面向过程最主要的是每一步一每一步的因果关系，其中A步骤因果关系到B步骤，A和B联合起来形成一个子模块，子模块和子模块之间又因为因果关系结合在一起，假设其中任何一个因果关系出现问题（错误），此时整个系统的运转都会出现问题。（代码和代码之间的耦合度太高，扩展力太差。）
螺丝螺母拧在一起：耦合度低。 因为螺丝螺母可以再拧开（他们之间是有接口的）
螺丝螺母拧在一起，再焊住：耦合度高。 焊住了，不能再拧开。
耦合度就是粘连程度。往往耦合度高的扩展力就差
耦合度高导致扩展力差（集成显卡：计算机显卡不是独立的，是集成到主板上的）
耦合度低导致扩展力强（灯泡和灯口关系，螺丝螺母关系）
采用面向过程的方式开发一台计算机：
没有任何一个部件，都集成在一起，只要一个“部位出问题”，整个计算机都不能用了
采用面向对象的方式开发一台计算机：
内存条是一个对象，主板是一个对象，CPU是一个对象。这些对象组装成一台计算机
假设CPU坏了，可以将CPU拆下来，换一个新的。 - 面向过程有什么优点？（快速开发）
对于小型项目，采用面向过程的方式进行开发，效率较高。前期不需要进行对象的提取、模型的建立，采用面向过程方式可以直接开始干活。一上来直接写代码，编写因果关系，从而实现功能。 - 什么是面向对象的开发方式？
采用面向对象的方式进行开发，更符合人的思维方式（面向对象成为主流的原因）。人就是以“对象”的方式认识世界的。所以对象更容易让我们接受
面向对象就是将现实世界分割成不同的单元，然后每一个单元都实现成对象，然后给一个环境驱动一下，让各个对象之间协作起来形成一个系统。
对象：“张三”、“香烟”、“打火机”、“吸烟场所”
将以上四个对象组合在一起，就可以模拟一个人的抽烟场景。
其中：“张三”可改为”李四“、香烟可以更换品牌. . . . . .
采用面向对象的方式进行开发：耦合度低，扩展力强。 - 区别：
蛋炒饭：鸡蛋和米饭完全混合在一起，没有独立对象的概念。
假设新需求：只吃蛋炒饭中的米，怎么满足这个需求？
开始扩展，这个扩展是个噩梦。（很难扩展，耦合度太高。要一粒一粒挑出来）
盖饭：
一份鱼香肉丝盖饭
鱼香肉丝是一道菜，可以看成一个独立的对象。米饭和菜都是独立的对象
两个对象准备好后，只要有一个动作：”盖“，这样两个对象就组合在一起了。
新需求：不吃这个盖饭，要吃西红柿鸡蛋盖饭了
扩展（轻松）：直接把”鱼香肉丝“对象 换成 ”西红柿鸡蛋“对象。
面向过程要关注的是：实现步骤以及整个过程。
面向对象要关注的是：对象A，对象B，对象C，对象ABC组合，或对象CBA组合. . . . . . - 当我们采用面向对象的方式贯穿整个系统时，涉及到三个术语：
OOA：面向对象分析
OOD：面向对象设计
OOP：面向对象编程
整个软件的开发过程，都是采用OO进行贯穿的。
实现一个软件的过程：
分析(A)——>设计(D)——>编程（P）
leader 领导/经理/组长 team 团队
PM 项目经理（整个项目的监管人） Project Manager - 面向对象包括三大特征：
封装
继承
多态
任何一个面向对象的编程语言都包括这三个特征。
如：python和java都有。（注意：java只是面向对象编程语言的一种）
类和对象的概念
面向对象当中最主要”一词“：对象。
- 什么是类？
类实际上在现实世界中是不存在的，是一个抽象的概念、是一个模板。是我们人类大脑进行思考、总结、抽象的一个结果。（类就是 对象 特征的一个总结）
类本质上是现实世界当中某些事物具有共同特征，将这些共同特征提取出来形成的概念就是一个“类”。如：明星是一个类 - 什么是对象？
对象是实际存在的个体（真实存在的个体）
宋小宝是一个对象、姚明是一个对象、刘德华也是一个对象
宋小宝、姚明、刘德华这3个对象都属于”明星“这个类。 - 在java语言中，要想得到”对象“，必须先定义”类“，”对象“是通过”类“这个模板创造出来的。
类 就是一个模板：类中描述的是所有对象的“共同特征信息”，对象就是通过类创造出的个体
术语：
- 类：不存在的，人思考总结出来的一个模板（这个模板当中描述了共同特征）、
- 对象：实际存在的个体
- 实例：对象的另一个名字
- 实例化：通过“类“这个模板创建对象的过程，叫做：实例化。
- 抽象：多个对象具有共同特征，进行思考总结抽取共同特征的过程
类——>【实例化】——>对象（实例）
对象——>【抽象】——>类
- 类是一个模板，是描述共同特征的一个模板，那么共同特征包括什么呢？
潘长江对象：
名字：潘长江
身高：165cm
打篮球：非专业的，自己玩，无所谓
学习：考试80分
姚明对象：
名字：姚明
身高：226cm
打篮球：NBA专业球员，打篮球非常棒
学习：考试100分
共同特征有哪些？
名字、身高 属于名词（状态特征）
打篮球、学习都属于动词（动作特征）
类=属性+方法
属性来源于：状态
方法来源于：动作
public class 明星类{
//属性——>状态，多见于名词
名字属性；
身高属性；
//方法——>动作，多见于动词
打篮球方法(){
}
学习方法(){
}
}张三同学、李四同学，他们两有没有共同特征呢？
有共同特征，就可以抽象一个类模板出来。可以定义一个学生类（Student）
public class Student{
//属性
姓名
性别
身高
//方法
public ... sing(){
}
public ... dance(){
}
public ... study(){
}
......
}- 思考：”java软件工程师“在开发中起到的作用
为什么做软件开发？
说大：为人民服务，解决现实生活中的问题。首先软件就必须能够模拟现实世界
其实软件是一个虚拟的世界。这个世界需要和现实世界一一对应，这才叫模拟。 - 类的定义
- 怎么定义一个类，语法格式是什么?
[修饰符列表] class 类名{
类体=属性+方法
//属性在代码上以“变量”形式存在(描述状态)
//方法描述动作/行为
}
注意：修饰符列表可以省略- 为什么属性是以“变量”的形式存在的？
假设我们要描述一个学生：
学生包括哪些属性：
学号：110
姓名：“张三”
性别：“男”（true/false）
住址：“深圳宝安区”
答：因为属性对应的是“数据”，数据在程序中只能放在变量中。
结论：属性其实就是变量变量的分类：
方法体中声明的变量：局部变量
方法体外声明的变量：成员变量。（这里的成员变量就是“属性”）
- 请观察“学生对象1”和“学生对象2”的共同特征，然后再利用java语言将改“学生类”表达/表述出来。（只表达属性，不表达方法）
类的定义
/*
1、观察学生对象的共同特征（只观察属性）
有哪些共同特征：
学号：采用int类型
姓名：采用String类型
年龄：采用int类型
性别：采用char或boolean类型
住址：采用String类型
注意：属性是成员变量。
2、以上是分析总结的结果，可以开始写代码了：
定义Student类，编写成员变量作为属性。
3、变量有一个特点：
必须先声明再赋值，才能访问
成员变量可以不手动赋值？
*/
public class Student {//这个程序编译之后，会生成Student.class字节码文件。
//属性
//学号
int xueHao;
//姓名
String xingMing;
//年龄
int nianLing;
//性别
boolean xingBie;
//住址
String zhuZhi;
public static void main(String[] args){
}
}对象的创建
//对象的创建和使用
public class StudentText {
public static void main(String[] args){
//在这里可以访问Student类吗
//当然可以
/*
创建对象的语法是什么？
目前死记硬背，先记住，后面就理解了
new 类名();
类是模板，通过一个类，是可以创建N多个对象的。
new是一个运算符，专门负责对象的创建。
类型 变量名 = new Student();
Student s1 = new Student();
和
int i =100; 一样
i：变量名 int:变量的数据类型 100： 具体的数据
s1：变量名 Student：变量s1的数据类型 new Student() 这是一个对象(学生类创造出来的学生类型)
s1只是一个变量名字
数据类型包括两种：
基本数据类型：byte、short、int、long、float、double、boolean、char
引用数据类型：String、Student......
java中所有的“类”都属于引用数据类型
Student既是一个类名，同时又是一个“类型名”，属于引用数据类型
*/
Student s1 = new Student();//和int i=10; 一个道理
//再通过该类创建一个全新的对象
Student s2 = new Student();
//再创建一个呢？
Student s3 = new Student();
//以上的这个程序就相当于通过Student类实例化了3个Student对象
//创建对象的个数没有限制，可以随意，只要有模板类就行。
//三个对象都属于学生类型。
}
}- 关于编译的过程
按说应该先编译Student.java，然后再编译StudentText.java，但是对于编译器来说，编译StudentText.java文件的时候，会自动编译Student.java文件，生成Student.class文件。
第一种方式：
javac Student.java
javac StudentText.java
第二种方式：
javac StudentText.java
第三种方式：
javac *.java- 在语法级别上是怎么完成对象创建的呢？
类名 变量名 = new 类名();
这样就完成了对象的创建。 - 什么是“实例变量”？
对象又被称为实例。实例变量实际上就是：对象级别的变量。
public class 明星类{
double height;
}
//身高这个属性，所有的明星对象都有，但每一个对象都有“自己的身高值”。
//假设创建10个明星对象，height变量应该有10份。
//所以这种变量被称为对象级别的变量，属于实例变量实例变量在访问时，必须先创建对象
/*
变量必须先声明，再赋值才能访问
注意：对于成员变量来说，没有手动赋值时，系统默认赋值
赋的值都是默认值，那么默认值是什么？
类型 默认值
------------------------------------------
byte 0
short 0
int 0
long 0L
float 0.0F
double 0.0
boolean false
char \u0000
引用数据类型 null
null是一个java关键字，全部小写，表示空，是引用类型的默认值
分析：对于成员变量来说，是不是应该一个对象有一份。
李四有李四的学号、张三有张三的学号。
他们的学号不一样，所以应该有两块不同的内存空间
*/
public class Student1 {
//访问学生姓名可以直接通过类名吗？
//学生姓名是一个实例变量，实例变量是对象级别的变量。是不是应该先有对象才能说姓名的事儿？
//System.out.println(Student1.name); 错误
//不能通过“类名”来直接访问“实例变量”
//原因：Student类中的每个对象都有name的值，直接用类名做引用，无法访问，只能一个一个访问
//属性(描述状态) ，在java程序中以“成员变量”的形式存在
//学号 一个对象都需要有一份
int no; //这种成员变量又被称为实例变量
//姓名
String name;
//年龄
int age;
//性别
boolean sex;
//住址
String addr;
public static void main(String[] args){
}
}对象的创建和使用
public class StudentText1 {
public static void main(String[] args){
//s1、s2都是局部变量，存储在栈内存中
//创建学生对象1
//s1这个局部变量又被叫做：引用
Student1 s1 = new Student1();
//怎么访问实例变量？
//语法：引用.实例变量名 （每个对象的变量名.类中定义的变量名）
System.out.println(s1.no);
System.out.println(s1.name);
System.out.println(s1.age);
System.out.println(s1.sex);
System.out.println(s1.addr);
System.out.println("--------------------------------------------------");
//创建学生对象2
//s2也是：引用。
Student1 s2 = new Student1();
//访问
System.out.println(s2.no);
System.out.println(s2.name);
System.out.println(s2.age);
System.out.println(s2.sex);
System.out.println(s2.addr);
//程序执行到这里，可以修改s1的学号吗？
//可以 通过“=”赋值的方式将内存中实例变量的值修改一下。
s1.no = 110;
s1.name = "张三";
s1.age = 20;
s1.sex = true;
s1.addr = "深圳宝安区";
System.out.println("学号="+s1.no);
System.out.println("姓名="+s1.name);
System.out.println("年龄="+s1.age);
System.out.println("性别="+s1.sex);
System.out.println("住址="+s1.addr);
//再次赋值
s1.addr = "北京大兴区";
System.out.println("地址："+s1.addr);
}
}对象和引用图
- 实例变量为自定义的类
public class User {
//用户id int是一种基本数据类型
int id; //实例变量
//用户名 String是一种引用数据类型
String userName; //实例变量
//家庭住址 Address是一种引用数据类型
Address addr; //实例变量
}
//实例变量都存储在堆内存的对象内部住址类
public class Address {
//一个家庭住址有三个属性
//城市
String city;
//街道
String street;
//邮编
String zipCode;
}原理
/*
第一步：类加载
第二步：调用UserAddressText类的main方法（方法调用要压栈）
所有的实例变量（属性）都是通过“引用.”来访问的。
User u = new User();
u是引用
对象和引用怎么区分？
对象：堆里new出来的
引用；是存储对象内存地址的一个变量。
只要这个变量中保存的是一个对象的内存地址，那么这个变量就叫做:引用。
思考：引用一定是局部变量吗？
不一定
Address addr = 一个对象的内存地址
//这也是一个引用，而Address addr; 是在类体当中的，是一个成员变量
*/
public class UserAddressText {
public static void main(String[] args){
//家庭住址对象
Address a = new Address();
a.city= "北京";
a.street= "大兴街";
a.zipCode= "121221";
//用户对象
User u = new User();
u.id = 1111;
u.userName = "张三";
u.addr = a;
/*
int i = 100;
int j = i;
原理：会将i中保存的100复制一份，传给j变量。
*/
System.out.println(u.id);
System.out.println(u.userName);
System.out.println(u.addr.city+u.addr.street+u.addr.zipCode);
//u.addr.city可以拆分吗？ 可以 u.addr.city节省变量
//拆分成以下代码，效果跟上面完全相同，原理也相同，只是以下代码变量更多
//int i = u.id; u.id 是int类型的
Address ad = u.addr; // u.addr 属于引用类型：Address
String zhuZhi=ad.city; //ad.city 是String类型的，所以可以通过这种方式赋值
//想知道张三是哪个城市的，代码应该怎么写？
System.out.println(u.userName+"是"+u.addr.city+"的");
}
}
- 编写代码，通过t访问D中的i
public class TT {
A a;//a是成员变量的同时是实例变量，必须先创建对象，通过“引用”来访问。
public static void main(String[] args){
//对象的创建，创建了之后才可以访问实例变量（成员变量）
//不能通过(类名.实例变量名)访问，必须先创建对象
D d = new D();
C c = new C();
B b = new B();
A a = new A();
TT t = new TT();
//赋值 这里不赋值的话会出现：NullPointerException异常(空指针异常)
c.d = d; //把d引用的（D类当中的int i） 复制一份，赋值给（c引用的C类当中的d）;
b.c = c; //把c引用的（C类当中的d）复制一份，赋值给（b引用的B类当中的c）;
a.b = b; //把b引用的（B类当中的c）复制一份，赋值给（a引用的A类当中的b）;
t.a = a; //把a引用的（A类当中的b）复制一份，赋值给（t引用的TT类当中的a）;
//.前面的都是“引用” .后面的是引用的类中的实例变量
// 其中的c.d、b.c、a.b、t.a 是 (引用.实例变量名) 的形式
//编写代码，通过t访问D中的i
System.out.println(t.a.b.c.d.i);
}
}
class A{
B b; //这里的 B 是引用数据类型
}
class B{
C c; //这里的 C 是引用数据类型
}
class C{
D d; //这里的 D 是引用数据类型
}
class D{
int i;
}程序在什么情况下会出现空指针异常呢？
空引用 访问 “对象相关” 的数据时，会出现空指针异常。
/*
空指针异常 NullPointerException
关于垃圾回收器：GC
在java语言中，垃圾回收器主要针对的是堆内存。
当一个对象没有任何“引用”指向该指针时，GC会考虑将该垃圾数据释放回收掉
出现空指针异常的前提条件是：
“空引用”访问实例相关【对象相关】的数据时，都会出现空指针异常。
*/
public class NullPointerText {
public static void main(String[] args){
//创建客户对象
Customer c = new Customer();
//访问这个客户的id
System.out.println(c.id);
//重新给id赋值
c.id = 9521; //终身代号
System.out.println("客户的id是："+c.id);
c = null;
System.out.println(c.id);//要想访问实例变量，对象必须要存在
// 编译器不报错，因为编译器只检查语法，编译器发现c是Customer类型，Customer类型中有id属性，所以语法没问题
//但运行时，c为“null”，则c中存储的“对象地址”被“null”覆盖掉了，对象没了，就出现空指针异常。
}
}
class Customer{
//客户ID
int id; //成员变量中的实例变量，应该先创建对象，然后通过“引用.”的方式访问
}
方法调用时参数的传递问题
实际上，在java语言中，方法调用时参数传递，和类型无关，都是将变量中保存的那个“值”传递过去，这个“值”可能是一个数字“100”，也可能是一个java对象的内存地址：0x1234
/*
分析程序输出结果
java中规定：参数传递的时候，与类型无关，不管是基本数据类型还是引用数据类型，统一是将盒子中保存的那个“值”复制一份传递下去。
java中只有一个规定：参数传递的时候，一定是将“盒子”中的东西复制一份传递过去
内存地址也是值，也是盒子中保存的一个东西
*/
public class Text1 {
public static void main(String[] args){
/*
int x = 100;
int y = x; // 把x赋给y，是将变量x中保存的100这个值复制一份传给y
*/
//局部变量，域：main
int i = 10;
//将i变量中保存的值：10，复制一份，传给add方法。
add(i);
System.out.println("main------"+i);//10
}
public static void add(int i){//这里的i也是局部变量，域：add。
i++;
System.out.println("add----"+i);//11
}
}
方法调用时，对象作为参数传递。
/*
java中关于方法调用时参数传递时实际上只有一个规则：
不管是基本数据类型，还是引用数据类型，传递时实际上都是将变量中保存的那个“值”复制一份，传递进去
int x = 1;
int y = x;
Person p1 = 0x1234;
Person p2 = p1;
实际上是把p1中保存的对象地址(0x1234)复制一份，传给p2
虽然p1、p2都是(引用)局部变量，他们虽然保存一样的地址，但p1和p2占用了两个位置
p1保存的0x1234占用栈内存的一个空间，p2保存的0x1234也占用栈内存的一个空间
但他们指向的是堆内存中的同一个对象(0x1234)
门上的锁只有一把钥匙可以打开，配了一把给你的室友
你和你室友都有门上的钥匙，钥匙是两把，但是都可以打开大门
*/
public class Text2 {
public static void main(String[] args){
Person p = new Person();//对象的创建
p.age = 10; //赋值
add(p);
System.out.println("main-----"+p.age);//11
}
//方法的参数可以是基本数据类型，也可以是引用数据类型。
public static void add(Person p){//p是add方法的局部变量
p.age++;
System.out.println("add-----"+p.age);//11
}
}
class Person{
//年龄属性，成员变量中的实例变量。
int age;
}
构造方法
- 当一个类中没有提供任何构造方法时，系统会默认提供一个无参数的构造方法，这个无参数的构造方法叫做：缺省构造器。
- 当一个类中手动提供了构造方法，那么系统将不再提供无参数的构造方法
如果手动创建的是一个有参数的构造方法，那么也要创建一个无参数的创建方法，否则调用无参数构造方法时会报错，建议将无参的直接写出来 - 无参数的构造方法和有参数的构造方法都可以调用：
Student x = new Student();
Student y = new Student(123);- 构造方法支持方法重载
在一个类中，构造方法可以有多个，并且所有的构造方法名字都是一样的
public class Student {//这个程序编译之后，会生成Student.class字节码文件。
//属性
//学号
int xueHao;
//姓名
String xingMing;
//年龄
int nianLing;
//性别
boolean xingBie;
//住址
String zhuZhi;
public static void main(String[] args){
}
//当前的Student这个类中并没有定义任何构造方法。
//但是系统实际上会自动给Student类提供一个无参数的构造方法。
//将无参数的构造方法(缺省构造器)写出来
public Student(){
System.out.println("无参数的构造方法执行了！");
}
//定义一个有参数的构造方法
public Student(int i){
}
//没有返回值类型，编译器会自动判定该方法是构造方法
//编译器会检测方法名与类名是否一致，如果不一致，编译报错。
//错误：方法声明无效，需要返回类型（发现方法名与类型不一致，认为该方法为普通方法，应该有返回值）
/*
public Studen(String name){}
*/
}- 构造方法详解
/*
构造方法：
1、什么是构造方法？有什么用？
构造方法也是一个比较特殊的方法，通过构造方法可以完成对对象的创建，以及实例变量的初始化。
换句话说：构造方法是用创建对象，并同时给对象的属性赋值。
注意：实例变量没有手动赋值时，系统会默认为它赋默认值
2、重点：当一个类没有提供任何构造方法，系统会默认提供一个无参数的构造方法。（被称为：缺省构造器）
3、调用构造方法怎么调用呢?
使用 new 运算符来调用构造方法
语法格式：
new 构造方法名(实际参数列表)
4、构造方法的语法结构是？
[修饰符列表] 构造方法名(形式参数列表){
构造方法体;
通常在构造方法体中给属性赋值，完成属性的初始化。
}
注意：
1、修饰符列表统一写：public
2、构造方法名和类名必须一致
3、构造方法不需要指定返回值类型，也不能写void，写了表示普通方法，就不是构造方法了
普通方法的语法结构是？
[修饰符列表] 返回值类型 方法名(形式参数列表){
方法体;
}
*/
public class ConstructorText01 {
public static void main(String[] args){
//调用构造方法
new Student();
//调用普通方法
ConstructorText01.doSome();
doSome();
//创建Student类型的对象
Student s1 = new Student();
//输出“引用”，只要输出结果不是null，说明这个对象一定是创建完成了
System.out.println(s1); //Student@1b6d3586
//调用另一个有参数的构造方法
Student s3 = new Student(100);
System.out.println(s3);
}
public static void doSome(){
System.out.println("do some!!!!");
}
}- 对于实例变量来说，只要你在构造方法中没有手动给他赋值，统一会赋默认值。
每个构造方法中都有为实例变量赋默认值的语句
/*
1、id、age、name都有默认值对吗
对
2、id的默认值：0
name的默认值：null
age的默认值：0
3、思考：实例变量没有手动赋值的时候，实际上系统会默认赋值
那么这个默认赋值操作是在什么时候进行的？
*/
public class User1 {
//三个属性，三个实例变量【对象变量】
//用户id
int id;
//用户名
String name;
//年龄
int age;
//手动定义有参数的构造方法，无参数的构造方法将消失，再次调用无参数构造方法时会报错。
//调用此构造方法时，也自动赋默认值
public User1(int a){}
public User1(){
//这里实际上有三行代码你看不见
//无参数构造体中虽然什么代码都没写
//但实际上，在这个方法里面进行了实例变量默认值初始化
/*
id = 0;
name = null;
age = 0;
*/
//这就表示不再采用系统默认值，手动赋值了
id=11;
name="lisi";
age= 18;
}
}/*
1、构造方法对应的英文单词：Construcor【构造器】
2、构造方法作用：
创建对象，并且创建对象的过程中给属性赋值(初始化)
*/
public class ConstructorText02 {
public static void main(String[] args){
User1 u =new User1();
System.out.println(u.id);//11
System.out.println(u.name);//lisi
System.out.println(u.age);//18
User1 u2 =new User1(11);
System.out.println(u2.id); //0
System.out.println(u2.name); //null
System.out.println(u2.age); //0
}
}- 实例变量在构造方法执行的时候进行初始化
public class Vip {
//会员号
long no;
//会员姓名
String name;
//生日
String birth;
//性别
boolean sex;
//无参数的构造方法
public Vip(){
}
//有参数的构造方法
public Vip(long huiYuanHao,String xingMing){
//给实例变量赋值【初始化实例变量，初始化属性】
no = huiYuanHao;
name = xingMing;
//实际上这里还有两行代码初始化实例变量
//birth = null;
//sex = false;
}
//有参数的构造方法
public Vip(long huiYuanHao,String xingMing,String shengRi){
no = huiYuanHao;
name = xingMing;
birth = shengRi;
//实际上这里还有一行代码初始化实例变量
//sex = false;
}
//有参数的构造方法
public Vip(long huiYuanHao,String xingMing,String shengRi,boolean xingBie){
no = huiYuanHao;
name = xingMing;
birth = shengRi;
sex = xingBie;
}
}public class ConstructorText03 {
public static void main(String[] args){
//调用不同的构造方法创建对象
Vip v1 = new Vip();
System.out.println(v1.no); //0
System.out.println(v1.name); //null
System.out.println(v1.birth); //null
System.out.println(v1.sex); //false
Vip v2 = new Vip(111L,"男1号");
System.out.println(v2.no); //111
System.out.println(v2.name); //男1号
System.out.println(v2.birth); //null
System.out.println(v2.sex); //false
Vip v3 = new Vip(222L,"男2号","2000-01-12");
System.out.println(v3.no); //222
System.out.println(v3.name); //男2号
System.out.println(v3.birth); //2000-01-12
System.out.println(v3.sex); //false
Vip v4 = new Vip(333L,"男3号","1998-12-26",true);
System.out.println(v4.no); //333
System.out.println(v4.name); //男2号
System.out.println(v4.birth); //1998-12-26
System.out.println(v4.sex); //true
}
}封装
- 面向对象的三大特征：
封装
继承
多态
有了封装，才能继承，有了继承，才能说多态 - 面向对象的首要特征：封装
- 什么是封装？封装有什么用？
- 手机、电视机、笔记本、照相机，都是外面有一个壳包他们封装起来，保护内部零件安全，另外封起来之后，使用者看不见内部的复杂结构，也不需要关心为什么复杂，只需要操作外部按钮就可以完成操作。
- 封装的作用有两个：
- 保证内部结构安全。
- 屏蔽复杂，只暴露简单的部分。
- 在代码级别中封装有什么用？
一个类体当中的数据，假设封装之后，对于代码的调用人员来说，不需要关心代码的复杂实现，只需要通过一个简单的入口就可以访问了。另外，类体中安全级别数据高的代码封装起来，外部人员不能随意访问，来保证数据的安全性。
- 没有使用封装的缺点
/*
Person 表示人类：
每一个人都有年龄这样的属性
年龄age ，int属性
我们这里先不使用封装机制，分析程序存在什么缺点？
Person0类的属性对外暴露，可以在外部程序中随意访问，导致了不安全。
怎么解决这个问题？
封装
*/
public class Person0 {
//实例变量（属性）
int age;
}//在程序中访问Person0这个类型中的数据
public class PersonText0 {
public static void main(String[] args){
//创建Person0对象
Person0 p1 = new Person0();
//访问人的年龄
//访问一个对象的属性通常包括两种操作：读数据 改数据
//读数据(get表示获取)
System.out.println(p1.age);
//修改数据(set表示修改/设置)
p1.age = 40;
//再次读取
System.out.println(p1.age);
//在PersonText0这个外部程序中目前是可以随意对age属性进行操作的
//一个人的年龄值不应该为负数
//程序中给年龄赋值了一个负数，按说是不符合实际的，但是程序还是让他通过了
//其实这就是一个程序的bug
p1.age = -100; //改(随意在这里对Person0内部的数据进行访问，导致了不安全。)
System.out.println("您的年龄值是"+p1.age); //读
}
}- 怎么进行封装，代码怎么实现？
第一步：属性私有化(使用private关键字进行修饰)
第二步：对外提供简单的操作入口
- 带有static和没有static的方法调用时的区别：
//带有static的方法和没有static的方法怎么调用？
//带有static的方法的调用：通过“类名.”的方式访问
public class MethodText00 {
public static void main(String[] args){
MethodText00.doSome();
//在同一个类中，类名.可以省略
doSome();
//尝试使用“类名.”的方式访问实例方法。
//MethodText00.doOther();
//报错：无法从静态上下文中引用非静态方法doOther()
//创建对象
MethodText00 mt = new MethodText00();
//通过“引用.”的方式访问实例方法。
mt.doOther();
}
//带有static
public static void doSome(){
System.out.println("do some!!");
}
/*
对象被称为实例
实例相关的有：实例变量、实例方法
实例变量是对象变量，实例方法是对象方法
实例相关的都需要先new对象，通过“引用.”的方式去访问
*/
//这个方法没有static ，这样的方法被称为：实例方法。(对象方法，对象级别的方法)
public void doOther(){
System.out.println("do Other!!!!!!!");
}
}- 实例方法的调用时，如果对象为null，也会出现空指针异常。
//public class Person0 {
//
// //实例变量（属性）
// int age;
//}
//尝试封装一下，不再对外暴露复杂数据，封装起来。对外只提供操作入口
//优点：第一数据安全了，第二调用方便了。
public class Person2 {
//private表示私有的，被这个关键字修饰之后，该数据只能在本类中访问
//出了这个类，age属性就无法访问了(私有)
private int age;
//对外提供简单的访问入口(电视机的遥控器就相当于是电视机的访问入口，简单明了)
//外部程序只能通过调用以下的代码来完成访问
//思考：应该提供几个访问入口？这些入口是否应该是方法呢？
//写一个方法专门完成读（get）写一个方法专门来完成写/改（set）
}- 封装的实现有两步：
第一步：属性私有化
第二步：1个属性对外提供1个get和1个set方法。外部程序只能通过get方法访问，只能通过set方法修改。可以在set方法中设立关卡来保证数据的安全性。
强调：
set方法和get 方法都是实例方法，不能带static
不带static的方法成为实例方法，实例方法的调用必须先new 对象。get方法和set 方法写的时候都有严格的要求：
get方法：
public 返回值类型 get +属性名称首字母要大写(){
return xxx;
}
set方法：
public void set +属性名称首字母要大写(参数){
xxx = 参数;
}设置set与get方法
//public class Person0 {
//
// //实例变量（属性）
// int age;
//}
//尝试封装一下，不再对外暴露复杂数据，封装起来。对外只提供操作入口
//优点：数据安全、调用方便
public class Person2 {
//private表示私有的，被这个关键字修饰之后，该数据只能在本类中访问
//出了这个类，age属性就无法访问了(私有)
private int age;
/*
对外提供简单的访问入口(电视机的遥控器就相当于是电视机的访问入口，简单明了)
外部程序只能通过调用以下的代码来完成访问
思考：应该提供几个访问入口？这些入口是否应该是方法呢？
写一个方法专门完成读（get）写一个方法专门来完成写/改（set）
get 和set 方法应该带有static，还是不带有？get 和 set 方法应该定义为实例方法吗？
get 读年龄 ，set 改年龄，这个读和改都是操作一个对象的年龄。(没有对象就不会有年龄)
*/
//封装第二步：对外提供公开的get和set方法作为操作入口，并且都不带有static。都是实例方法。
/*
[修饰符列表] 返回值类型 方法名(形式参数列表){}
注意：
java开发规范中有要求，set方法和get方法要满足以下格式：
get方法的要求：
public 返回值类型 get+属性[的名称] 名称的首字母要大写 (){
return 属性[名称];
}
set方法的要求：
public void set+属性[的名称] 首字母要大写 (参数 参数的类型为属性的类型){
属性 = 参数;
}
*/
//读age
public int getAge(){
return age;
}
//改age
public void setAge(int nianLing){
//在这里设置关卡，年龄不符实际的不让改
if(nianLing <0 || nianLing >150 ){
System.out.println("您输入的年龄不合实际，请重新输入！");
return; //终止当前方法。
}
//程序执行到这里，说明年龄一定是符合实际的。
age = nianLing;
}
}public class PersonText02 {
public static void main(String[] args){
//创建对象
Person2 p1 = new Person2();
//person2的age，在外部彻底不能访问了，但这太安全了
//age不能访问，这个程序意义就不大了。
/*
//读age属性
System.out.println(p1.age);
//修改age属性的值
p1.age= 20;
//读age
System.out.println(p1.age);
*/
/*
通过“类名.”的方式不可以调用set和get方法
只有方法修饰符列表中有static的时候，才能使用“类名.”的方式访问
Person2.getAge() 这种方式是错误的
*/
//设置接口以后
//读：调用getAge方法
System.out.println(p1.getAge());//0
//改：调用setAge方法
p1.setAge(20);
System.out.println(p1.getAge());//20
//再改
p1.setAge(-50);
System.out.println(p1.getAge());//您输入的年龄不合实际，请重新输入！
//20
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
