7封装_构造函数
导语:
想到在写
- 介绍匿名对象。1,简化书写,2,使用场景
- 对象调用的封装提高复用性,匿名对象作为实参传递
- 基本数据类型参数传递和引用数据类型参数传递
- 封装的表现和好处,以及私有的使用
- 构造函数的定义,调用,作用,默认构造函数的体系,构造函数细节。和一般函数的区别
- 构造函数间的调用,this(),this到底代表哪个对象
- this的另一个用法,区分成员变量和局部变量同名的情况,以及this关键字的应用
- 静态关键字static的特点。以及应用。两个问题。需要大家自己找答案解决
1. 介绍匿名对象。1,简化书写,2,使用场景
class Car
{
//描述属性。颜色,轮胎数。
String color;
int number;
//描述行为。
void run()
{
System.out.println(color+":"+number);
}
}
class CarDemo
{
//定义主函数。为了让程序运行起来。
public static void main(String[] args)
{
/*
//创建Car.class类的对象。
Car c = new Car();//类类型变量一定指向对象。
//调用对象的成员。
c.color = "red";
c.number = 4;
c.run();
*/
// Car c = new Car();
// c.run();
//简化成这样的写法。所以匿名对象就是为了简化书写。
// new Car().run();//这个对象有名字吗?没有,是的。这就是传说中的匿名对象。
/*
记住:凡是简化的,通常都有局限。
匿名对象有局限吗?
*/
new Car().color = "red";//执行完对象就变成了垃圾。
new Car().number = 4;
new Car().run();
/*
那匿名对象有什么用呢?为了简化书写。
使用场景:当对象对方法进行调用时,而且只调用一次时,可以简化成匿名对象来书写。
Car c = new Car();c.run(); ---> new Car().run();
Car c = new Car();
c.color = "blue";
c.run();
c.run();
c.run();
是不可以简化成一下书写的。因为对象不同。
new Car().color = "blue";
new Car().run();
new Car().run();
new Car().run();
记住:当对象需要调用多次成员时,不可以简化成匿名对象调用。
*/
}
}
2. 对象调用的封装提高复用性,匿名对象作为实参传递
class Car
{
//描述属性。颜色,轮胎数。
String color;
int number;
//描述行为。
void run()
{
System.out.println(color+":"+number);
}
}
class CarDemo2
{
public static void main(String[] args)
{
/*
Car c = new Car();
c.color = "red";
c.number = 4;
c.run();
Car c1 = new Car();
c1.color = "red";
c1.number = 4;
c1.run();
*/
//以上代码的复用性有点差。只有对象不同,而调用的成员和赋值都相同。
//可以进行抽取。定义一个功能。将重复代码封装。
/*
封装功能后,在使用,就简单了。
*/
Car c = new Car();
Car c1 = new Car();
show(new Car());//简化成 show(new Car());//把匿名对象作为实际参数进行传递。
}
//功能结果是什么呢?没有具体值。所以是void。
//功能的未知部分是什么呢?对象不明确。可以将其定义成参数。
public static void show(Car cc)
{
cc.color = "red";
cc.number = 4;
cc.run();
}
}
3. 基本数据类型参数传递和引用数据类型参数传递
//课上练习:不要编译运行,求图,求真相!
class Demo
{
public static void main(String[] args)
{
int x = 4;
show(x);
System.out.println("x="+x);
}
public static void/*int*/ show(int x)
{
x = 5;
//return x;
}
}
class Demo
{
int x ;
public static void main(String[] args)
{
Demo d = new Demo();
d.x = 5;
show(d);//show(new Demo());
System.out.println("x="+d.x);
}
public static void show(Demo d)
{
d.x = 6;
}
}
4. 封装的表现和好处,以及私有的使用
/*
封装:
表现:
1,函数就是一个最基本封装体。
2,类其实也是一个封装体。
从以上两点得出结论:
好处:
1,提高了代码的复用性。
2,隐藏了实现细节,还要对外提供可以访问的方式。便于调用者的使用。这是核心之一,也可以理解为就是封装的概念。
3,提高了安全性。
它也是面向对象思想的特征之一。
共有三个特征:封装,继承,多态。
举例:机箱。隐藏了办卡设备的细节,对外提供了插口以及开关等访问内部细节的方式。
*/
//描述人。Person
//属性:年龄。
//行为:说话:说出自己的年龄。
/*
总结:
类中不需要对外提供的内容都私有化,包括属性和行为。
selectSort(int[] arr)
{
swap(
}
bubbleSort(int[] arr)
{
swap(
}
private swap(int[] arr,int a,int b)
{
}
重点:以后再描述事物,属性都私有化,并提供setXxx getXxx方法对其进行访问。
*/
class Person
{
//属性:
private int age;//age就是被修饰为了private私有。也就是被隐藏了。这就是封装的一种体现。
//行为:
void speak()
{
System.out.println("age="+age);
}
/*
年龄已被私有,错误的值无法赋值,可是正确的值也赋值不了,不行。
咋办,按照之前所学习的封装的原理,隐藏后,还需要提供访问方式。
通过方法的方式,让其他程序访问到,就可以了。更重要的是可以在方法中加入逻辑判断。
记住:对变量的访问操作有两个动作:赋值(设置 set),取值(获取 get)
所以,对私有的变量访问的方式就是 set变量 get变量--> setAge getAge
*/
//定义对age赋值的方法。
void setAge(int a)
{
//加入逻辑判断。
if(a>0 && a<130)
age = a;
else
// System.out.println("对不起,您的年龄数值 "+a+" 是非法的。");
// throw new RuntimeException("对不起,您的年龄数值 "+a+" 是非法的。");//异常!一旦出现,程序结束。需要修正代码。
}
//定义一个获取age值的方法。
int getAge()
{
return age;
}
}
class PersonDemo
{
public static void main(String[] args)
{
//测试Person.class。
//创建对象。
Person p = new Person();
/*
赋值-20是可以的,因为age属性是int类型,但是确不符合现实生活中的事物。
怎么解决这个问题呢?
不让它访问就哦了。怎么在代码上实现呢?需要使用一个Java中的关键字也是一个修饰符 private(私有,权限修饰符)
记住:私有仅仅是封装的体现形式而已。
*/
// p.age = -20;//age不能在person类以外的程序中直接访问了。
//演示对age设置和获取方法的体现。
p.setAge(-20);
int a = p.getAge();
System.out.println("a="+a);
// p.speak();
}
}
5. 构造函数的定义,调用,作用,默认构造函数的体系,构造函数细节。和一般函数的区别
/*
需求:为了描述事物更准确,发现事物对应的很多对象一创建时,
就有了,一些初始化的数据。在类中该如何完成的。
通过Java中的另一个小技术完成:就是构造函数。对象本身就是构造出来,
构造时,需要做一些动作这些应该定义在函数内。
构造函数(Constructor)有什么用?可以对对象创建进行初始化。
构造函数怎么在代码中体现呢?
1,没有返回值类型。因为构造对象,创建完就结束,需要结果。void也不要写,因为要有区别与一般函数。
2,构造函数名称和类名一致。
3,没有具体的返回值。
接下来,按照以上三点,在Person类中定义一个构造函数。
对象一创建就具备了姓名。
发现了问题?
没有学习构造函数时,对象也创建出来了。那么该对象是否有被构造呢?或者说是否有调用构造函数呢?
是的。必须调用!
那么类中那个构造函数是什么呢?
class Person
{
//Person(){}//默认的空参数构造函数。
}
main()
{
Person p = new Person();//这就已经调用了Person类中的空参数的构造函数。
//类中有定义该构造函数吗?有的。只要定义一个类,
//该类中默认就有一个空参数的构造函数,是编译器编译时添加到class文件中。
//注意:如果在类中自定义了构造函数,那么默认的空参数构造函数编译器就不添加了。
//原理:没有定义对象的初始化过程,编译器会添加一个默认的初始化过程。
// 如果定义了指定的对象初始化过程,默认的就不添加了。
}
构造函数的细节:
1,一个类中可以有多个构造函数,它们的存在是以重载的形式体现的。
2,构造函数中也是有return语句的,用于结束初始化动作的。
3,构造函数是否能被private修饰呢?能,作用:其他程序无法创建该类的对象。
class Person
{
private Person(){}
}
main()
{
Person p = new Person();//创建对象无法初始化。
}
构造函数和一般函数的区别?
1,写法不一样。不重要。
2,运行上有差别,对象一创建就会调用对应的构造函数。
一般方法是对象创建后,才会调用所需的一般函数。
问:有了构造函数初始化姓名,那么还需要setName方法吗?
需要,因为对象创建后,如果需要对数据进行修改,可以通过set完成。
3,构造函数在对象创建时,仅调用一次(初始化动作只做一次,而且先执行)。一般方法可以被对象调用多次。
class Person
{
//Person(){}
void Person(){}//这是一般函数。但不要这些书写,因为一般函数名称有规范。
}
main()
{
Person p = new Person();
}
*/
class Person
{
//属性:姓名,年龄。
private String name;
private int age;
//一初始化,既没有姓名,又没有年龄。
Person()
{
}
// Person(int a)
// {
// if(a<0)
// return;
// age = a;
// }
//定义构造函数,对象一创建就具备姓名。
Person(String n)
{
//将接收到的值赋值给对象的name
name = n;
}
//一初始化既有姓名,又有年龄。
Person(String n,int a)
{
name = n;
age = a;
}
//行为。
public void speak()
{
System.out.println("name="+name+",age="+age);
}
}
class PersonDemo2
{
public static void main(String[] args)
{
Person p1 = new Person();
// Person p = new Person("lisi");//对象创建时,必须会调用对应的构造函数,因为对象需要初始化。
// Person p2 = new Person("wangwu",23);
}
}
6. 构造函数间的调用,this("/>,this到底代表哪个对象
/*
当构造函数之间进行互相调用时,该如何解决呢?
构造函数是对象初始化时调用的。
给哪个对象初始化呢?通过this关键字来记录住对象的地址。并通过this来明确被初始化的对象。
在构造函数中调用其他构造函数的格式: this(实参列表);就会调用对应的构造函数。
小节:
this到底代表什么呢?★★★★★
this就代表对象,代表哪个对象呢?哪个对象调用了this所在函数,this就代表哪个对象。
*/
class Person
{
private String name;
private int age;
Person()
{
}
//初始化姓名。
private Person(String n)
{
name = n;
}
//初始化姓名和年龄。既然有初始化姓名的动作。直接调用就可以了。
Person(String n,int a)
{
this(n);//调用一个字符串参数的构造函数。注意:调用其他构造函数的语句,
//必须定义在构造函数的第一行。原因:初始化动作要先执行。
// name = n;
age = a;
}
}
class PersonDemo3
{
public static void main(String[] args)
{
Person p = new Person("lisi",20);
Person p1 = new Person("lisi1",21);
}
}
7. this的另一个用法,区分成员变量和局部变量同名的情况,以及this关键字的应用
/*
this关键字的另一个作用:
可以用this标识哪个变量是成员变量。这个标识可以省略不写。
但是,当局部变量和成员变量同名时,必须用this.来标识成员变量。
*/
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public void speak()
{
String name = "haha";
System.out.println("name="+this.name+",age="+this.age);
}
public void method()
{
this.speak();//this可以省略。
}
//课上练习,定义功能,判断两个人是否是同龄人。
//1,明确结果,boolean 2,明确未知内容,1个,Person类型。
public boolean equalsAge(Person pp)
{
/*
if(pp.age == this.age)//当函数中使用到了调用该函数的对象时,用this表示这个对象。
return true;
return false;
*/
// return (pp.age == this.age)?true:false;
return pp.age == this.age;
}
}
class PersonDemo4
{
public static void main(String[] args)
{
Person p = new Person("lisi",20);
p.speak();
Person p1 = new Person("xiaoming",24);
p1.speak();
}
}
8. 静态关键字static的特点。以及应用。两个问题。需要大家自己找答案解决
/*
静态关键字的特点:
1,静态成员优先于对象存在,被对象共享。
2,静态成员可以直接类名调用,多一个调用方式。
3,静态成员所属于类,所以它是随着类的加载而加载,随着类的消失而消失。
*/
class Person
{
//属性:国籍。如果这个程序只限中国人使用,国籍都是中国。
//如果每一个对象中都存储一份中国,不是不行,只是内存浪费。能不能实现这个中国数据的对象共享呢?
//可以的,通过Java中的一个关键字就可以完成。static。这是一个成员修饰符。
static String country = "中国";//显示初始化。这个country的值就不在对象存储了。被对象共享了。
String name;
public static void show()
{
System.out.println(Person.country);
// System.out.println(name);
}
}
/*
静态变量和成员变量的区别?
什么时候定义静态变量。什么时候函数需要用静态修饰?
*/
class PersonDemo5
{
public static void main(String[] args)
{
// Person p1 = new Person();
// Person p2 = new Person();
// System.out.println(p1.country);
System.out.println(Person.country);//共享数据在对象之前就已经存在了。可以有另一种调用方式。可以直接被类名调用。
// 静态的成员所属的是类。
Person.show();
}
}