目录
面向对象和面向过程有什么区别
-
从语言方面出发:
对于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 } }