第六章总结

秦小小是boos

已于 2022-04-17 23:27:32 修改

阅读量448

点赞数

分类专栏：总结文章标签： eclipse java 开发语言

于 2022-04-05 22:01:36 首次发布

本文链接：https://blog.csdn.net/m0_62534787/article/details/123970951

版权

总结专栏收录该内容

11 篇文章 0 订阅

订阅专栏

第六章，面向对象编程基础

6.1 面对对象概述

面对对象设计实质上就是对现实世界的对象进行建模操作。

6.1.1 对象

通常对象有两个部分，静态部分和动态部分。面向对象程序设计的思想要以对象来思考问题，首先要将实体抽象为对象，然后考虑这个对象具备的属性和行为。

6.1.2 类

类就是同一类事物的统称，不能将所谓的一个事物描述成一类。

6.1.3 面向对象程序设计的特点

1.封面

封面是面向对象编程的核心思想。将对象的属性和行为封装起来，载体就是类。

2.继承

继承性主要利用特定对象之间共有的属性。

3.多态

多态的实现并不依赖具体类，而是依赖于抽象类和接口。

6.2 类和对象

6.2.1 成员变量

public class Bird{
    String wing;           //翅膀
    String claw;           //爪子
    String beak;           //喙
    String feather;        //羽毛
}

6.2.2 成员方法

定义一个add方法

package g;

public class g1 {
	public static void main(String[] args) {
		g1 book=new g1();//创建g1对象
		int x=30;//定义参数变量x
		int y=40;//定义参数变量y
		System.out.println("运算结果："+book.add(x,y));//输出结果
		System.out.println("实参x的值:"+x);//输出结果
	}
	private int add(int x,int y) {//计算两个数的和
		x=x+y;//对x进行加y操作
		return x;//返回x
	}

}

运行结果

定义一个change方法

package g;

public class g2 {
	public static void main(String[] args) {
		g2 refTest=new g2();//创建g2对象
		int[] i= {0,1,2};//定义一维数组，作为方法的实参
		System.out.print("原始数据：");//输出语句
		for (int j=0;j<i.length;j++) {//循环
			System.out.print(i[j]+" ");//输出结果
		}
		refTest.change(i);//调用方法改变数组元素的值
		System.out.print("\n修改后的数据：");//输出结果
		for (int j=0;j<i.length;j++) {//循环
			System.out.print(i[j]+" ");//输出结果
		}
	}//定义一个方法，方法的参数为一维数组
		public void change(int [] i)//在内部定义
		{
			i[0]=100;//赋值
			i[1]=200;//赋值
			i[2]=300;//赋值
	}

}

运算结果

定义一个add方法

package g;

public class g3 {
	public static void main(String[] args) {
		g3 multi=new g3();//创建g3对象
		System.out.print("运行结果："+multi.add(20,30,40,50,60));//输出语句
	}
	int add(int...x) {//定义add方法，类型为int
		int result =0;//记录运算结果
		for(int i=0;i<x.length;i++) {//循环遍历数组
			result+=x[i];//执行相加操作
		}
		return result;//返回运算结果
	}
}

运行结果

创建猎豹类

package g;

public class g4 {
	public void gaze(String target) {//凝视。目标是参数
		System.out.println("猎豹凝视："+target);//输出语句
	}
	public void run() {//奔跑
		System.out.println("猎豹开始奔跑");//输出语句
	}
	public boolean catchPrey(String prey) {//捕捉猎物，返回捕捉是否成功
		System.out.println("猎豹开始捕猎"+prey);//输出语句
		return true;//返回成功
	}
	public void eat(String meat) {//吃肉，参数是肉
		System.out.println("猎豹吃"+meat);//输出语句
	}
	public void sleep() {//睡觉
		System.out.println("猎豹睡觉");//输出语句
	}
	public static void main(String[] args) {
		g4 liebao=new g4();
		liebao.gaze("羚羊");//赋值
		liebao.run();//赋值
		liebao.catchPrey("羚羊");//赋值
		liebao.eat("羚羊肉");//赋值
		liebao.sleep();//赋值
	}

}

运行结果

6.2.3 构造方法

创建一个图书类，

package g;

public class g5 {
	private g5() {//私有构造方法
	}
	static public g5 libraryBorrow() {//创造静态方法，返回本类实例对象
		System.out.println("通过调用静态方法创建对象");//输出语句
		return new g5();//返回
	}
	public static void main(String[] args) {//创建一本书，不是new实例化的，而是通过方法从图书馆借来的
		// TODO Auto-generated method stub
		g5 book=g5.libraryBorrow();//在libraryBorrow中借书
	}

}

运行结果

6.2.4 局部变量

public String getName(){//定义一个getName()方法
int id=0;               //局部变量
setName("Java");        //调用类中其他方法
return id +this.name;   //设置方法返回值
}

6.2.5 局部变量的有效范围

局部变量的有效范围从该变量的声明开始到该变量的结束为止。

6.2.6 对象的创建

在java中一般是用new操作符来创建对象。

创建g6类(),并在主方法中创建对象

package g;

public class g6 {
	public g6(){
		System.out.println("创建对象");//构造方法
	}
	public static void main(String[] args) {//主方法
		new g6();//创建对象
	}
}

运行结果

6.2.7 访问对象的属性和行为

创建g7类并调用类的成员

package g;

public class g7 {
	int i = 47; // 定义成员变量

	public void call() { // 定义成员方法
		System.out.println("调用call()方法");
		for (i = 0; i < 3; i++) {//循环i
			System.out.print(i + " ");//输出语句
			if (i == 2) {//是否为偶数
				System.out.println("\n");//换行
			}
		}
	}

	public g7() { // 定义构造方法
	}

	public static void main(String[] args) {
		g7 t1 = new g7(); // 创建一个对象
		g7 t2 = new g7(); // 创建另一个对象
		t2.i = 60; // 将类成员变量赋值为60
		// 使用第一个对象调用类成员变量
		System.out.println("第一个实例对象调用变量i的结果：" + t1.i);
		t1.call(); // 使用第一个对象调用类成员方法
		// 使用第二个对象调用类成员变量
		System.out.println("第二个实例对象调用变量i的结果：" + t2.i);
		t2.call(); // 使用第二个对象调用类成员方法
	}
}

运行结果

6.2.8对象的销毁

每个对象都有生命周期，当没有生命时该对象就会被回收。只能回收new操作符创建的对象。所有java中提供了一个finalize()方法。这个方法是Object类的方法，它被声明为protected。

6.2.9 this 关键字

创建g8类并输出方法中的name的值。

package g;

public class g8 {
	String name="abc";//定义值
	public void showName(String name) {//内部定义
		System.out.println(name);//输出语句
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		g8 book=new g8();//创建构造方法
		book.showName("123");//调用方法并赋值
	}

}

运算结果

在g9类的showName()方法中，使用this关键字

package g;

public class g9 {
	String name="abc";//给name赋值
	public void showName(String name) {//内部定义
		System.out.println(this.name);//输出name
	}
	public static void main(String[] args) {//主函数
		// TODO Auto-generated method stub
		g9 book=new g9();//创建构造方法
		book.showName("123");//调用方法
	}

}

运算结果

创建有参数和无参数构造方法

package g;

public class g10 {
	int eggCount;//鸡蛋灌饼里有几个数
	public g10(int eggCount) {//内部定义
		this.eggCount=eggCount;//调用方法
		System.out.println("这个鸡蛋灌饼里有"+eggCount+"个蛋。");//输出语句
	}//无参数构造方法，默认给饼加一个鸡蛋
	public g10() {
		this(1);//给为空的赋值
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		g10 cake1=new g10();//创建构造方法
		g10 cake2=new g10(5);//创建构造方法
	}

}

6.3 static关键字

6.3.1 静态变量

把共享的变量用static修饰，该变量就是静态变量。

创建一个水池，创建注水和放水方法。

package g;

public class g11 {
	static public int water=0;//给water赋值
	public void outlet() {
		if(water>=2) {//判断
			water=water-2;//输出water的值
		}else {//反之
			water=0;//判断
		}
	}
	public void inlet() {
		water=water+3;//输出water+3的值
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		g11 out=new g11();//创建构造方法
		g11 in=new g11();//创建构造方法
		System.out.println("水池的水量："+g11.water);//输出语句
		System.out.println("水池注水两次。");//输出语句
		in.inlet();//调用方法
		in.inlet();//调用方法
		System.out.println("水池的水量："+g11.water);//输出调用方法中的语句
		System.out.println("水池放水一次。");//输出语句
		out.outlet();//8调用方法
		System.out.println("水池的水量："+g11.water);//输出调用方法中的语句
	}

}

运算结果

创建g12类，包含一个静态成员变量和普遍成员变量。

package g;

public class g12 {
	static int x;// 静态变量
	int y;// 普通成员变量

	public g12(int x, int y) {// 构造函数
		this.x = x;//调用构造方法
		this.y = y;//调用构造方法
	}

	public static void main(String[] args) {
		g12 a = new g12(1, 2);//创建对象并给值
		g12 b = new g12(13, 17);//创建对象并给值
		System.out.println("a.x的值是 = " + a.x);//输出语句
		System.out.println("a.y的值是 = " + a.y);//输出语句
		System.out.println("b.x的值是 = " + b.x);//输出语句
		System.out.println("b.y的值是 = " + b.y);//输出语句
	}
}

运算结果

6.3.2 静态常量

将Π的值赋予静态常量PI，计算圆的面积和体积。

package g;

public class g13{
		final static double PI = 3.1415926;// 创建静态常量π
		public static void main(String[] args) {
			double radius = 3.0;// 半径
	      double area = g13.PI * radius * radius;// 计算面积
			double volume = 4 / 3 * g13.PI * radius * radius * radius;// 计算体积
			Circular yuan = new Circular(radius, area);//创建对象
			Spherical qiu = new Spherical(radius, volume);//创建对象
		}
	}
	class Circular {
		double radius;// 半径
		double area;// 面积
		public Circular(double radius, double area) {//内部定义
			this.radius = radius;//调用构造方法
			this.area = area;//调用构造方法
			System.out.println("圆的半径是：" + radius + ",圆的面积是：" + area);//输出语句
		}
	}
	class Spherical {
		double radius;// 半径
		double volume;// 体积
		public Spherical(double radius, double volume) {//内部定义
			this.radius = radius;//调用构造方法
			this.volume = volume;//调用构造方法
			System.out.println("球的半径是：" + radius + ",球的体积是：" + volume);//输出语句
		}
	}

运算结果

6.3.3 静态方法

不创建类方法，直接使用静态方法

package g;

public class g14 {
	static public void show() {//定义静态方法
		System.out.println("静态方法无需实例化就可以调用");
	}
	public static void main(String[] args) {
		g14.show();//使用类名调用静态方法
	}
}

运算结果

6.3.4 静态代码块

创建静态代码块，非静态代码块，构造方法，成员方法

package g;

public class g15 {
	static String name;//定义string型name
	static {
		System.out.println(name+"静态代码块");//输出语句
	}
	{
		System.out.println(name+"非静态代码块");//输出语句
	}
	public g15(String a) {//内部定义
		name=a;//定义变量
		System.out.println(name+"构造方法");//输出语句
	}
	public void method() {
		System.out.println(name+"成员方法");//输出语句
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		g15 s1;
		g15 s2=new g15("s2");//创建对象
		g15 s3=new g15("s3");//创建对象
		s3.method();//使用类方法
	}

}

运行结果

6.4 类的主方法

在主方法中编写以下代码。

package g;

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

6.5 总结

本章学习了面向对象的概括，类的定义，成员方法，类的结构方法，主方法以及对象的应用等。所以对象的创建，比较，销毁的应用就解决一些实际问题。

秦小小是boos

关注

0
点赞
踩
0

收藏

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

第六章，面向对象编程基础6.1 面对对象概述面对对象设计实质上就是对现实世界的对象进行建模操作。6.1.1 对象通常对象有两个部分，静态部分和动态部分。面向对象程序设计的思想要以对象来思考问题，首先要将实体抽象为对象，然后考虑这个对象具备的属性和行为。6.1.2 类类就是同一类事物的统称，不能将所谓的一个事物描述成一类。6.1.3 面向对象程序设计的特点1.封面封面是面向对象编程的核心思想。将对象的属性和行为封装起来，载体就是类。2.继承继承性主要利用特定对.
复制链接

扫一扫