面向对象
1.基本要素
属性:用于描述事物的信息 ==》 成员变量:用于描述事物的信息
行为:用来描述事物能够做什么的 ==》 成员方法:用来描述事物能够做什么的
类:是一组成员变量和成员方法的集合,可以把类看作一个抽象的概念 。
对象:是该类的具体的表现,具体到一个个体 。
举例:事物:人
属性:姓名,性别,年龄…
行为:吃饭,睡觉,学习…
类:Person
成员变量:name,gender,age
成员方法:eat(),sleep(),study()
对象:是该类的具体的表现,具体到一个个体
学生,老师,医生,律师,程序员
如何定义一个成员变量?
1、定义的位置:在类中,方法外
2、定义的格式:
数据类型 变量名;
如何定义一个成员方法?
1、定义的位置:在类中
2、定义的格式:
修饰符 返回值类型 方法名(参数列表){
方法体;
}
2.类与对象的关系
类相当于抽象的概念
对象是类的具体表现
(1)创建一个对象的内存图
(1)class文件中有两个class文件,phone1.class中有如图三个方法地址为0x001,Phonetest里有一个main方法,地址为0x002.
(2)在栈中执行main方法持行Phone p1=new phone;在堆中开辟空间其地址值为0x001,它有默认值,整体上也会有一个地址为0x0001赋给p1.p1通过地址对其变量进行修改p1.brand等命令。
(3)然后再执行p1.call,p1通过地址去找到方法区如果有call方法,就将该方法加载到栈中执行。当方法执行后就结束了,该方法就会被释放,以此类推其他方法一样。
(2)创建两个对象的内存图
与创建一个变量类似。两个堆内存中的区域都指向同一个方法区
(3)创建三个对象的内存图
与创建两个对象的内存图类似,不同点在于Phone p3=p1;就是将p1的地址0x0001赋给p3,这样p1和p3指得是同一块区域,因此通过p3.brand,p3.price,进而就可以改变该区域的值,最终你输出p1.brand,p1.price,也就和p3的一样同一块区域,因p1的指的值也会改变。
3.定义一个类:
注意事项:一个java文件中只能有一个类被public修饰只需要记住被public修饰的类规范是要与java文件名一致
在一个java文件可以定义多个类,我们这里,就先定义基本的类,和测试类
将来编译的时候,JVM会读取java文件,有多少个class类,就编译生成多少个.class文件
如何创建对象:
类名 对象名 = new 类名()
通过对象访问成员变量:对象名.非私有的成员变量名
通过对象访问成员变量:对象名.非私有的成员方法
4.封装
我们在定义一个学生类并使用的时候,发现了一个问题:
通过对象给成员变量赋值的时候,可以赋值一些非法的数据。 这样是不合理不符合现实生活的。 我们应该在赋值之前,做一次判断,数据校验,也就是对即将要赋值的数据做判断。
问题又来了,我们应该在哪里定义这个判断逻辑呢?
测试类负责创建对象并使用对象的地方,在这里定义判断逻辑是不合适的。 所以我们这里应该定义在Student3类中。又因为,我们在定义成员变量的时候无法加入逻辑判断。所以,我们在成员方法中定义。因为做数据判断的时候,加的是一些逻辑判断语句,肯定不是只有一条。我们应该在Student3类中提供一个方法来数据校验。
按照我们的想法,在类中提供了一个数值校验的方法,如果符合就成功赋值,反之则不赋值。
但是,谁规定了我定义了方法就一定会被使用呢,如果我还是用之前的获取成员变量的方式进行赋值,问题依旧存在那么我们给出的方法意义就不是很大了。
实际上,我们应该定义了一个方法后,让调用必须使用我们的方法进行赋值,并且不能让调用者直接获取到我们成员变量。
怎么去强制要求不直接获取成员变量呢?
针对这样的情况,java就提供了一个关键字:private
private: 私有的。
其实说到现在,就是为了引出一个思想:封装
封装:其实就是隐藏对象的属性和相关的实现细节,仅仅对外提供公共的访问方式
举例:
class Student3 {
//定义成员变量
String name;
private int age;
public void setAge(int a){
if(a<0 || a>200){
System.out.println("您要传入的年龄数据有误,请重新赋值");
}else{
age = a;
}
}
//定义一个输出所有的成员变量
public void show() {
System.out.println("姓名:" + name);
System.out.println("年龄:" + age);
}
}
public class StudentDemo2 {
public static void main(String[] args) {
//创建一个学生对象
Student3 s = new Student3();
//给对象的成员变量赋值
s.name = "马鞍山学院";
// s.age = 10000; 由于我们在Student3类中name前面加了
//一个private关键字,不可以直接使用获取到成员变量,要想赋值,
//就必须使用我们提供的数据校验赋值方法
s.setAge(10000);
s.show();
}
}
5.private关键字:
-
私有的。它可以修饰成员变量和成员方法 被private修饰的成员只能在本类中进行访问。
-
获取成员变量值的方法:
1、提供一个公共的方法,打印所有的成员变量值
2、单个使用公共的获取方法,一个一个获取打印(开发)
原因:单个使用比一起使用的灵活度要高。 -
private : 私有的。
1、它可以修饰成员(成员变量和成员方法)
2、被private修饰的成员只能在本类中访问使用。其他类中使用不了
举例:
class Person {
//private修饰成员变量
private String name;
private int age;
//提供一个公共set方法
public void setName(String s) {
name = s;
}
public void setAge(int a) {
age = a;
}
//提供一个公共的get方法,让外界获取到成员变量值
public String getName() {
return name;
}
public int getAge() {
return age;
}
//打印所有的成员变量值
private void show() {
System.out.println("姓名:" + name + ",年龄:" + age);
}
public void show2(){
show();
}
}
public class PrivateDemo1 {
public static void main(String[] args) {
Person p = new Person();
// System.out.println();
//调用公共的方法为成员变量进行赋值
p.setName("小明");
p.setAge(18);
// p.show();
p.show2();
//调用公共的方法获取成员变量的值
String name = p.getName();
System.out.println(name);
int age = p.getAge();
System.out.println(age);
}
}
举例: 练习:请把手机类写成一个标准类的格式,然后创建对象并测试
手机类:
成员变量:
品牌:String brand;
价格:int price;
颜色:String color;
成员方法:
提供公共的getXxx()和setXxx()
提供一个方法查看手机详情
测试类:
创建手机对象并测试(给成员变量赋值,取值)
class Phone2 {
//定义成员变量
private String brand;
private int price;
private String color;
//提供公共的getXxx()和setXxx()方法
public void setBrand(String s) {
brand = s;
}
public String getBrand() {
return brand;
}
public void setPrice(int p) {
price = p;
}
public int getPrice() {
return price;
}
public void setColor(String s) {
color = s;
}
public String getColor() {
return color;
}
//提供一个公共的方法打印手机详情
public void show() {
System.out.println("品牌:" + brand + ",价格:" + price + ",颜色:" + color);
}
}
public class PrivateTest {
public static void main(String[] args) {
//创建一个手机对象
Phone2 p = new Phone2();
//给成员变量进行赋值
p.setBrand("小米");
p.setPrice(2999);
p.setColor("黑色");
//获取成员变量并打印
//获取手机品牌
String brand = p.getBrand();
//获取手机对象p的价格
int price = p.getPrice();
//获取手机对象p的颜色
String color = p.getColor();
System.out.println("品牌:" + brand + ",价格:" + price
+ ",颜色:" + color);
//调用方法打印所有的成员变量值
p.show();
}
}
6.成员变量与局部变量的区别
(1)区别
-
在类中定义的位置不同
成员变量:类中,但是在方法外
局部变量:定义在方法内部 -
在内存中的位置也不同
成员变量:在堆内存中
局部变量:在栈内存中 -
初始化值也不同
成员变量:系统会给予默认值
局部变量:没有系统给的默认值,必须在定义的时候赋值,亦
或者在方法中使用之前赋值,然后才能使用。 -
生命周期不同
成员变量的生命周期:随着对象的创建而创建,随着对象的消失而消失
局部变量的生命周期:随着方法的调用而创建,随着方法的调用完毕而消失
(2) 注意事项:
-
局部变量的名字可以和成员变量的名字一样,在方法中使用的时候,采用就近原则
方法中使用的变量,会先在方法内部查找,如果方法内部没有,去成员变量中查找。 -
方法与方法之间里面的局部变量变量,不能互相调用。
举例:
class BianLiang{
String name;
int age;
public void show(int n){//n就是一个局部变量
n = 10;
int a = 20;
// int b;
// System.out.println(b);
System.out.println(n);
System.out.println(a);
String name = "马原";
System.out.println(name);
}
// public void show2(){
// System.out.println(a);
// }
}
public class BianLiangDemo {
public static void main(String[] args) {
//成员变量的使用,需要创建对象(最起码这里是要创建对象才能使用的)
BianLiang b1 = new BianLiang();
b1.name = "思修";
System.out.println(b1.name);
b1.show(100);
}
}
7.形式参数的问题:分别是基本数据类型和引用数据类型的时候的区别。
(1)当形式参数是基本数据类型的时候,将来调用方法的时候传入的是常量值,或者是该类型的变量
(2)当形式参数是引用数据类型的时候,将来调用方法的时候传入的是该类对象的地址值
(3)当形式参数是基本数据类型的时候,在方法中对变量做修改,不会影响到外部实际的栈内存中的值。因为在方法调用完成后方法会在栈中消失,因此无论你怎么在方法中对变量进行修改也不回影响到外部的参数。
(4)当形式参数是引用数据类型的时候,在方法中对变量做修改,会影响到外部实际的堆内存中的值。
举例:
class Demo2 {
public int getSum(int a,int b) {
a=100;
b=200;
return a + b;
}
}
class Student2{
String name;
public void speak(){
System.out.println("我热爱学习");
}
}
class StudentTest2{
/* 如果将来你看到一个方法的形式参数是一个类的类型,说明他是一个引用
数据类型
这里其实需要的是该类的对象
调用的时候,把main方法中创建好的对象名传过来,实际上传的就是对象
的地址值
* @param s
*/
public void function(Student2 s){ //Student2 s = new Student2();
s.name = "小王";
s.speak();
}
}
public class XingShiCanShuDemo {
public static void main(String[] args) {
Demo2 d = new Demo2();
int a = 10;
int b = 20;
System.out.println(d.getSum(a,b));
System.out.println("a:"+a+",b:"+b);
//要想调用function(),就必须创建StudentTest2对象
StudentTest2 st2 = new StudentTest2();
Student2 student2 = new Student2();
System.out.println(student2.name);
st2.function(student2);/*当你调用function的时候实际
上就是传递了student2的地址,当你在function中对name的值做出
改变时,虽然function随着调用完成而消失,但事实上两者的地址值相
同指得时同一个name,最终name会发生变化。还得注意这里调用
function时传入参数是student2所创建的一个对象,也相当于将
student2的地址上传*/
System.out.println(student2.name);
}
}
(5)基本数据类型当作参数传递时的内存图
(6)引用数据类型当作参数传递时的内存图
8.匿名对象
(1).匿名对象:就是没有名字对象
(2) 匿名对象的使用场景:
- 调用方法的时候,仅仅调用一次的时候,可以使用匿名对象
注意:当调用多次的时候,不适合,每次new的时候都是一个新的匿名对象,会频繁的在堆内存中开辟空间
当匿名对象使用完毕之后,无法再使用第二次,就变成了一个垃圾(当栈中没有变量引用它的时候,判定是一个垃圾),等待被垃圾回收器回收。 - 当方法的参数类型是一个类的时候,可以使用匿名对象调用方法。
举例:
class Phone4{
public void show(){
System.out.println("手机可以打电话");
}
}
class PhoneDemo{
public void function(Phone4 p){
p.show();
}
}
public class AnonymousDemo {
public static void main(String[] args) {
//创建一个PhoneDemo对象
PhoneDemo pd = new PhoneDemo();
Phone4 phone = new Phone4();
pd.function(phone);
System.out.println("=============================");
//当new完对象之后直接使用,没有用变量名接收的对象,称之为匿名对象
new PhoneDemo().function(new Phone4());
new PhoneDemo().function(new Phone4());
}
}
9.this关键字
(1)this代表的是将来调用该方法的对象。进而得到标准类写法2.0版本
(2) 定义一个医生类:
class Doctor {
private String name;
private int age;
private String gender;
public void setName(String name) {
/*我们还说过,局部变量的使用原则:就近原则我们这里的name
采用就近原则后发现,使用的都是形参的变量名name,没有使用成员变量中
name.我们理想上应该是将传进来的name赋值给调用该方法对象中的成员变
量name
Doctor.name = name;直接通过类名.成员变量的方式目前是不行,我们
还没有说过类似的用法,所以这个是有问题的
如果这个Doctor对象存在的话,它是不是就表示了一个医生对象
如果有一个东西可以代表是当前调用该方法的对象就好了
java提供了一个关键字:this
this在方法中使用的时候,就代表着调用该方法的对象
既然都是一个对象了,我们学过对象.成员变量*/
//此种方法不行 Doctor.name = name;
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int i) {
age = i;//此种类型并不能达到我们前面所说的见名知意的效果,但如果我们把它改为age=age的话运行后发现结果不对,值没有赋上。
}
public int getAge() {
return age;
}
public void setGender(String s) {
gender = s;
}
public String getGender() {
return gender;
}
//提供一个公共的方法
public void show() {
System.out.println("姓名:" + name + ",年龄:" + age + ",性别:" + gender);
}
}
public class DoctorDemo {
public static void main(String[] args) {
//创建一个医生对象
Doctor d = new Doctor();
d.setName("王宇");
d.setAge(18);
d.setGender("男");
d.show();
}
}
(3)下面说说this在内存中的位置
(1)首先方法区中class文件区有两个class一个是DoctorDemo2.class这个class中包含着main方法即地址为0x001.另一个为Doctor2.class即地址为0x002这其中包含getx()/setxxx()/show()
方法
(2)再将main方法加载到栈中执行,然后在main中开辟一个Doctor2 d空间,再在堆中new一个Doctor2(),其中包含name,age,gender其地址是0x002,堆内存中会有默认值
而这个new Doctor2()本身也有一个地址值假设为0x0001,然后将这个地址赋给d,d就可以通过这个地址找到其区域。
(3)this在对象创建之前this就已经指向堆内存中的那块区域,this就代表它所指区域的对象。这样就可以通过this去找到方法区从而去可以调方法。