第6章总结

最新推荐文章于 2024-06-30 20:23:11 发布

肖知云

最新推荐文章于 2024-06-30 20:23:11 发布

阅读量61

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/xy164914506/article/details/129862398

版权

一.面向对象概述
1.对象

在计算机的世界中，面向对象程序设计的思想要以对象来思考问题，首先要将现实世界的实体抽象为对象，然后考虑这个对象具备的属性和行为。例如，现在面临一只大雁要从北方飞往南方这样一个实际问题，试着以面向对象的思想来解决这一实际问题。步骤如下:

(1)从这一问题中抽象出对象，这里抽象出的对象为大雁

(2) 识别这个对象的属性。对象具备的属性都是静态属性，如大雁有一对翅膀、黑色的羽毛等。这些属性

(3)识别这个对象的动态行为，即这只大雁可以进行的动作，如飞行、觅食等，这些行为都是这个对象基于其属性而具有的动作。

(4)识别出这个对象的属性和行为后，这个对象就被定义完成了。然后可以根据这只大雁具有的特性制定这只大雁从北方飞向南方的具体方案，以解决问题。

究其本质，所有的大雁都具有以上属性和行为，可以将这些属性和行为封装起来，构成一个类，以描述大雁这类动物。由此可见，类实质上就是封装对象属性和行为的载体，而对象则是类抽象出来的一个实例。

2.类

不能将一个事物描述成一类事物，如一只鸟不能称为鸟类。但如果要给某一类事物一个统称就需要用到类这个概念。
类就是同一类事物的统称，如果将现实世界中的一个事物抽象成对象，类就是这类对象的统称，如鸟类、家禽类、人类等。类是构造对象时所依赖的规范，如一只鸟有一对翅膀，它可以用这对翅膀飞行，而基本上所有的鸟都具有“有翅膀”这个特性和飞行的技能，这样具有相同特性和行为的一类事物就称为类，类的思想就是这样产生的。在图 6.3 中已经描述过类与对象之间的关系，对象就是符合某个类的定义所产生出来的实例。更为恰当的描述是，类是世间事物的抽象称呼，而对象则是这个事物对应的实体。如果面临实际问题，通常需要实例化类对象来解决。例如，解决大雁南飞的问题，这里只能拿这只大雁来处理这个问题，而不能拿大雁类或鸟类来解决。
类是封装对象的属性和行为的载体，反过来说，具有相同属性和行为的一类实体被称为类。例如，鸟类封装了所有鸟的共同属性和应具有的行为。
定义完鸟类之后，可以根据这个类抽象出一个实体对象，最后通过实体对象来解决相关的实际问题。
在 Java 语言中，类对象的行为是以方法的形式定义的，对象的属性是以成员变量的形式定义的，所以类包括对象的属性和方法。

3.封装

面向对象程序设计具有以下特点:封装性、继承性和多态性。封装是面向对象编程的核心思想。将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想。例如，用户使用计算机时，只需要使用手指敲击键盘就可以实现一些功能，无须知道计算机内部是如何工作的。即使知道计算机的工作原理，但在使用计算机时也并不完全依赖于计算机工作原理等细节。采用封装的思想保证了类内部数据结构的完整性，使用类的用户不能轻易地直接操作类的数据结构，只能执行类允许公开的数据。这样就避免了外部操作对内部数据的影响，提高了程序的可维护性。

4继承

类与类之间同样具有关系，这种关系被称为关联。关联主要描述两个类之间的一般二元关系。例一个百货公司类与销售员类就是一个关联，学生类与教师类也是一个关联。两个类之间的关系有如，
很多种，继承是关联中的一种。当处理一个问题时，可以将一些有用的类保留下来，在遇到同样的问题时拿来复用。假如这时需要解决信鸽送信的问题，我们很自然就会想到图 6.4 所示的鸟类。由于鸽子属于鸟类，具有与鸟类相同的属性和行为，便可以在创建信鸽类时将鸟类拿来复用，并且保留鸟类具有的属性和行为。不过，并不是所有的鸟都有送信的习惯，因此还需要再添加一些信鸽具有的独特属性及行为。鸽子类保留了鸟类的属性和行为，这样就节省了定义鸟和鸽子共同具有的属性和行为的时间，这就是继承的基本思想设计软件时，使用继承思想可以缩短软件开发的周期，复用那些已经定义好的类可以提高系统性能，
减少系统在使用过程中出现错误的概率。继承性主要利用特定对象之间的共有属性。例如，平行四边形是四边形，正方形、矩形也都是四边形，平行四边形举与四边形举具有共同特性，就是拥有 4 个边，可以将平行四边形举看作四边形类的延伸，平行四边形类复用了四边形类的属性和行为，同时添加了平行四边形独有的属性和行为，如平行四边形的对边平行且相等。这里可以将平行四边形类看作是从四边形类中继承的。在 Java 语言中,将类似于平行四边形类的类称为子类，将类似于四边形类的类称为父类或超类。值得注意的是，可以说平行四边形是特殊的四边形，但不能说四边形是平行四边形，也就是说子类的实例都是父类的实例,但不能说父类的实例是子类的实例。

5 多态

将父类对象应用于子类的特征就是多态。依然以图形类来说明多态，每个图形都拥有绘制自己的能力，这个能力可以看作是该类具有的行为，如果将子类的对象统一看作是父类的实例对象，这样当绘制图形时，简单地调用父类也就是图形类绘制图形的方法即可绘制任何图形，这就是多态最基本的思想。
多态性允许以统一的风格编写程序，以处理种类繁多的已存在的类及相关类。该统一风格可以由父类来实现，根据父类统一风格的处理，可以实例化子类的对象。由于整个事件的处理都只依赖于父类的方法，所以日后只要维护和调整父类的方法即可，这样就降低了维护的难度，节省了时间。

大框假设是个文件，那么我们知道了成员变量和成员方法就是静态属性和动态属性，就用代码进行封装

public class b 
/静态属性private/*修饰符决定了它能不能被用*Stringname;//名字String wing;//翅膀private
private String head;//头
CSDN

/动态属性String/xvoid*eat(String food){
//return"";返回值
return name+"在吃"+food;
]
String fly() {
return name+"在飞";

}

我们定义了成员变量和成员方法，有{ }的就是方法

在定义成员变量时我们会涉及到修饰符，修饰符有四种。

二.类

1.成员变量

在Java中，对象的属性也称为成员变量，成员变量可以是任意类型，整个类中均是成员变量作用范围。下面通过一个实例来演示成员变量在类中所处的位置。

为书添加书名属性：

2.成员方法

在Java语言中,使用成员方法对应于类对象的行为。以Book类为例,它包含 getName0和 setName0两个方法，这两个成员方法分别为获取图书名称和设置图书名称的方法定义成员方法的语法格式如下:

一个成员方法可以有参数，这个参数可以是对象，也可以是基本数据类型的变量，同时成员方法有返回值和不返回任何值的选择，如果方法需要返回值，可以在方法体中使用 return 关键字，使用这个关键字后，方法的执行将被终止。

3.权限修饰符

Java 中的权限修饰符主要包括 private、public和 protected,这些修饰符控制着对类和类的成员变量以及成员方法的访问。如果一个类的成员变量或成员方法被修饰为 private，则该成员量只能在本类中被使用，在子类中是不可见的，并且对其他包的类也是不可见的。如果将类的成员变量和成员方法的访问权限设置为 public，那么除了可以在本类使用这些数据，还可以在子类和其他包的类中使用。如果一个类的访问权限被设置为 private，这个类将隐藏其内的所有数据，以免用户直接访问它。如果要使类中的数据被子类或其他包中的类使用，可以将这个类设置为 public 访问权限。如果一个类使用protected 修饰符，那么只有本包内的该类的子类或其他类可以访问此类中的成员变量和成员方法。这么看来，public 和 protected 修饰的类可以由子类访问，如果子类和父类不在同一包中，那么只有修饰符为 public 的类可以被子类进行访问。如果父类不允许通过继承产生的子类访问它的成员变量那么必须使用 private 声明父类的这个成员变量。

我们通过这些可以知道我们刚刚定义的修饰符是私有的，不能被其他文件和其他文件中的类使用，那么我们可以使用getter（获取）和setter（设置）方法，可以让变量除本类外也可以使用

4.局部变量

如果在成员方法内定义一个变量，那么这个变量被称为局部变量

局部变量是在方法被执行时创建，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误。

交换两个整数的值：

结果

5.局部变量的有效范围

可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止。

在相互不嵌套的作用域中可以同时声明两个名称和类型相同的局部变量

但是在相互套的区域中不可以这样声明，如果将局部变量 id 在方法体的 for 循环中再次定义，编译器将会报错

6.this关键字

this 关键字用于表示本类当前的对象，当前对象不是某个 new 出来的实体对象，而是当前正在编辑的类。this 关键字只能在本类中使用。

三.类的构造方法
在类中，除成员方法外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，类都会自动调用构造方法。

构造方法的特点如下:

构造方法没有返回值。

构造方法的名称要与本类的名称相同。

构造方法的定义语法格式如下:

例题6.1

package b;
 
public class s {
	public static int[] exchange(int []arr) {
		int tmp=arr[0];//创建局部变量tmp，保存数组第一个元素的值
		arr[0]=arr[1];//第二个元素值赋值给第一个元素
		arr[1]=tmp;//第二个元素的值赋给tmp
		return arr;
		
	}
	public static void main(String[]args) {
		int arr[]= {17,29};
		System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
		arr=exchange(arr);
		System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
	
	}
}

例题6.2

package b;
 
public class s {//类
	private String name;//String类型的成员变量
	public String getName() {//namedeGeteer方法
		return name;
	}
	public void setName(String name ) {//name的Seteer方法
		this.name=name;//将参数赋予类中的成员变量
	}
}

例题6.3

package a;
 
public class b {
 
	int egg;//鸡蛋灌饼里蛋的个数
	public b(int egg) {//参数为鸡蛋灌饼里蛋的个数的构造方法
		this.egg=egg;//将参数依据egg的值赋给属性egg
	}
	public 	b() {//无参数构造方法默认给饼加一个蛋
		this(1);//调用参数为鸡蛋灌饼里蛋的个数的构造方法，并设置鸡蛋灌饼里蛋的个数为1
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		b cake1=new b();
		System.out.println("顾客不要求加蛋的数量，饼里会有"+cake1.egg+"蛋");
		b cake2=new b(2);
		System.out.println("顾客要求加2个蛋的数量，饼里会有"+cake2.egg+"蛋");
		}
 
}

四.静态变量和静态方法
在介绍静态变量和静态方法之前，首先需要介绍 static 关键字，因为由 static 修饰的变量和方法被称为静态变量和静态方法。

有时，在处理问题时会需要两个类在同一个内存区域共享一个数据。例如，在球类中使用圆周率 PI 这个值，可能除了本类需要这个值，在另外一个圆类中也需要使用。这时一有必要在两个类中同时创建 P，因为这样系统会将这两个不在同一个类中定义的静态值分配到不同的内存空间中。为解决这个问题，可以将 PI 设置为静态的。

被声明为 static 的交量和方法被称为静态成员。静态成员属于类所有，区别于个别对象，可以在本类或其他类使用类名和“.”运算符调用静态成员。语法如下:

创建并调用静态属性和静态变量:

例题6.5

package b;
 
public class s {//类
	
	static  int i=0;//共享的属性，人数
	String name;//名称属性
	public s(String name ) {
		this.name=name;//记录名称
		i++;//人数递增
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		s c1=new s("tom");
		System.out.println("我是第"+s.i+++"名顾客，我叫"+c1.name);
		s c2=new s("张三");
		System.out.println("我是第"+s.i+++"名顾客，我叫"+c2.name);
		s c3=new s("狗蛋儿");
		System.out.print("我是第"+s.i+++"名顾客，我叫"+c3.name);
				
	}
 
}

(String [] args)有什么用，怎么用

package b;
 
public class s {
	public static void main(String [] args) {//主方法
		for(int i=0;i<args.length;i++) {//根据参数个数做循环操作
			System.out.println(args[i]);//打印结果
		}
	}
}

在代码运行前要先设置参数，右击界面

点击，然后以下操作

五.类的主方法

主方法是类的入口点，它定义了程序从何处开始。主方法提供对程序流向的控制，Java 编译器通过主方法来执行程序。主方法的语法如下:

对象

设置值	描述	设置值	描述
Test	类名	new	创建对象操作符
test	创建Test类对象	”a“	构造方法的参数

test对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了存储空间

例题6.7

package a;
 
public class b {		
	String name;
	int age;
	String sex;
	public b() {
		
	}
	public b(String name,int age,String sex) {
		this.name=name;
		this.age=age;
		this.sex=sex;
		
	}
	public static void main(String []args) {
		b p1=new  b("tom",23,"男");
		b p2=new b("lily",19,"女");
		
	}
 
}

2.访问对象的属性和行为

用户使用 new 操作符创建一个对象后，可以使用“对象.类成员”来获取对象的属性和行为。对象的属性和行为在类中是通过类的成员变量和成员方法的形式来表示的，所以当对像获取类成员时，也相应地获取了对象的属性和行为。

描述狗的特征：

package a;
 
public class b {		
	String name;//名字
	String color;//颜色
	String vioce;//叫声
	
	public b(String name,String color,String vioce) {
		this.name=name;
		this.color=color;
		this.vioce=vioce;
		
	}
	public void call() {//叫
		System.out.println(vioce);
	}
	public static void main(String []args) {
		b d1=new  b("毛毛","白色","汪汪汪");
		System.out.print(d1.name+"的颜色是"+d1.color);//访问对象的属性
		System.out.print("叫起来的声音：");
		d1.call();//访问对象的行为
		b d2=new b("灰灰","灰色","嗷呜~");
		System.out.print(d2.name+"的颜色是"+d2.color);
		System.out.print("叫起来的声音：");
		d2.call();
		
	}
 
}

引用

真正的操作标识符实质上是一个引用，引用的语法

类名对象的引用变量

b d1 =new b();

b是类名，d1是引用名，new b对象的实体；

为什么要销毁对象

每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收

垃圾回收器

在其他语言中，需要用户手动回收废弃的对象，JAVA拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器会自动回收无用却占用内存的资源

怎么判断对象会被JAVA虚拟机视为垃圾？主要包括两种情况

对象引用超过其作用范围，这个对象将被视为垃圾

2.这个对象被赋值为null

不足
虽然JAVA的垃圾回收机制已经很完善，但垃圾回收只能回收那些由new操作符创建的对象

某些对象不是通过new创造并获得存储空间的这些对象是无法被垃圾回收机制所识别

finalize（）
那么JAVA提供了一个finalize方法

这个方法是object类方法，他被声明为protected，用户可以在自己的类中定义这个方法，定义了这个方法后，垃圾回收时会首先调用该方法

system.gc()
由于垃圾回收不受人为控制，具体的执行时间也不能明确的确定，所以finalize()方法也就无法执行，因此JAVA又提供了system.gc()方法来强制启动垃圾回收器，会主动告知垃圾回收器来清理垃圾

课后作业

package b;
 
public class rw {
	//变量
	String xing;
	String ming;
	String se;
	String jiao;
	//get   set
	public String getXing() {
		return xing;
	}
	public void setXing(String xing) {
		this.xing = xing;
	}
	public String getMing() {
		return ming;
	}
	public void setMing(String ming) {
		this.ming = ming;
	}
	public String getSe() {
		return se;
	}
	public void setSe(String se) {
		this.se = se;
	}
	public String getJiao() {
		return jiao;
	}
	public void setJiao(String jiao) {
		this.jiao = jiao;
	}
	
	//方法
	public String introduce() {
		return xing+"狗"+ming+"是"+se+"的";
	}
	public String bark() {
		return xing+"狗"+ming+"正在"+jiao+"叫";
		
	}
	//构造方法
	public rw()
	{
		
	}
	public rw(String xing, String ming, String se) {
		super();
		this.xing = xing;
		this.ming = ming;
		this.se = se;
	}
	public rw(String xing, String ming, String se, String jiao) {
		super();
		this.xing = xing;
		this.ming = ming;
		this.se = se;
		this.jiao = jiao;
	}
	
	
}

package b;
 
public class rwte {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//使用有三个参数的构造方法新建对象
		rw rw1=new rw("公","小花","黑色");
        //调用并打印introduce
		String introduce=rw1.introduce();
		System.out.println(introduce);
        //使用有四个参数的构造方法新建对象
		rw rw2=new rw("母","小黑","花色","汪汪汪");
        //调用并打印 bark
		String bark=rw2.bark();
		System.out.println(bark);
		}
 
}

肖知云

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第6章总结

(1)从这一问题中抽象出对象，这里抽象出的对象为大雁(2) 识别这个对象的属性。对象具备的属性都是静态属性，如大雁有一对翅膀、黑色的羽毛等。这些属性(3)识别这个对象的动态行为，即这只大雁可以进行的动作，如飞行、觅食等，这些行为都是这个对象基于其属性而具有的动作。(4)识别出这个对象的属性和行为后，这个对象就被定义完成了。然后可以根据这只大雁具有的特性制定这只大雁从北方飞向南方的具体方案，以解决问题。
复制链接

扫一扫