第六章总结

徐xu0795

已于 2022-04-05 23:29:38 修改

阅读量52

点赞数

文章标签： java eclipse

于 2022-04-05 18:09:30 首次发布

本文链接：https://blog.csdn.net/XU0795/article/details/123973514

版权

6.1 面向对象概述
面向过程：代码紧密，不易分开，可维护性差面向对象：可维护性强

在程序开发初期人们使用结构化开发语言，但随着软件的规模越来越庞大，结构化语言的弊端也逐渐暴露出来，开发周期被无休止地拖延，产品的质量也不尽如人意，结构化语言已经不再适合当前的软件开发。这时人们开始将另一种开发思想引入程序中，即面向对象的开发思想。面向对象思想是人类最自然的一种思考方式，它将所有预处理的问题抽象为对象，同时了解这些对象具有哪些相应的属性以及行为，以解决这些对象面临的一些实际问题，这样就在程序开发中引入了面向对象设计的概念，面向对象设计实质上就是对现实世界的对象进行建模操作。

6.1.1 对象
在现实世界中，随处可见的一种事物就是对象，对象是事物存在的实体，如人类、书桌、计算机、高楼大厦等。

(1)首先可以从这一问题中抽象出对象，这里抽象出的对象为大雁。
(2)然后识别这个对象的属性。对象具备的属性都是静态属性，如大雁有一对翅膀、黑色的羽毛等。这些属性如图6.1所示。
(3)接着识别这个对象的动态行为，即这只大雁可以进行的动作，如飞行、觅食等，这些行为都是这个对象基于其属性而具有的动作。

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

6.1.3 面向对象程序设计的特点
不能将所谓的一个事物描述成一类事物，有一只鸟不能称为鸟类，如果需要对同一类事物统称，就不得不说明类这个概念.类是封装对象属性和行为的载体。反过来说，具有相同属性和行为的一类实体被称为类。

1，封装
2，继承
3，多态

6.2 类与对象

6.2.1 成员变量
6.2.2 成员方法

例6.1

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

例6.2

package d6;
public class li2 {
	 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		li2 refTest = new li2();//创建对象
        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;
	}
 
}

例6.3

package d6;
public class li3 {
	 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		li3 multi = new li3();//创建MultiTest对象
	      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;//返回运算结果
	}
 
}

例6.4

public class li4 {
	public void gaze(String target) {// 凝视。目标是参数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) {
		li4 liebao = new li4();
		liebao.gaze("羚羊");
		liebao.run();
		liebao.catchPrey("羚羊");
		liebao.eat("羚羊肉");
		liebao.sleep();
	}
 
}

6.2.3 构造方法

构造方法的特点如下:

(1)构造方法没有返回类型，也不能定义为 void。

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

(3)构造方法的主要作用是完成对象的初始化工作，它能把定义对象的参数传给对象成员。

例6.5

package d6;
public class li5 {
	private li5() {
	}
			// 静态公开方法，向图书馆借书
			static public li5 libraryBorrow() { // 创建静态方法，返回本类实例对象
				System.out.println("通过调用静态方法创建对象");
				return new li5();
			}
 
		public static void main(String[] args) {
				// 创建一个书的对象，不是new实例化的，而是通过方法从图书馆借来的
			li5 book = li5.libraryBorrow();
 
	}
 
}

6.2.4 局部变量

如果在成员方法内定义一个变量，那么这个变量被称为局部变量。
局部变量在方法被执行时创建，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误

6.2.5 局部变量的有效范围

6.2.6 对象的创建

例6.6

package d6;
public class li6 {
	public li6 () { // 构造方法
		System.out.println("创建对象");
	}

	public static void main(String args[]) { // 主方法
		new li6 (); // 创建对象
}
}

例6.7

package d6;
public class li7 {
	int i = 47; // 定义成员变量

	public void call() { // 定义成员方法
		System.out.println("调用call()方法");
		for (i = 0; i < 3; i++) {
			System.out.print(i + " ");
			if (i == 2) {
				System.out.println("\n");
			}
		}
	}

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

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

}

6.2.8 对象的销毁

6.2.9 this关键字

例6.8

package d6;
public class li8 {
	String name="abc";
	public void showName(String name) {
		System.out.println(name);
	}

	public static void main(String[] args) {
		li8 book = new li8();
		book.showName("123");
}

}

例6.9

package d6;

public class li9 {
	String name = "abc";

	public void showName(String name) {
		System.out.println(this.name);
	}

	public static void main(String[] args) {
		li9 book = new li9();
		book.showName("123");
}

}

例6.10

package d6;
public class li10 {
	int eggCount;// 鸡蛋灌饼里有几个蛋

	// 有参数构造方法，参数是给饼加蛋的个数
	public li10(int eggCount) {
		this.eggCount = eggCount;
		System.out.println("这个鸡蛋灌饼里有" + eggCount + "个蛋。");
	}

	// 无参数构造方法，默认给饼加一个蛋
	public li10() {
		this(1);
	}

	public static void main(String[] args) {
		li10 cake1 = new li10();
		li10 cake2 = new li10(5);
}

}

6.3 static关键字

6.3.1 静态变量

例6.11

package d6;
public class li11 {
	static public int water = 0;
	public void outlet() {// 放水，一次放出2个单位
		if (water >= 2) {
			water = water - 2;
		} else {
			water = 0;
		}
	}

	public void inlet() {// 注水，一次注入3个单位
		water = water + 3;
	}

	public static void main(String[] args) {
		li11 out = new li11();
		li11 in = new li11();
		System.out.println("水池的水量：" + li11.water);
		System.out.println("水池注水两次。");
		in.inlet();
		in.inlet();
		System.out.println("水池的水量：" + li11.water);
		System.out.println("水池放水一次。");
		out.outlet();
		System.out.println("水池的水量：" + li11.water);
}

}

例6.12

package d6;

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

	public li12(int x, int y) {// 构造函数
		this.x = x;
		this.y = y;
	}

	public static void main(String[] args) {
		li12 a = new li12(1, 2);
		li12 b = new li12(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 静态常量

在处理问题时会需要两个类共享一个数据常量，可以将这个常量设置为静态。

例6.13

package d6;
public class li13 {
	final static double PI = 3.1415926;// 创建静态常量π
	public static void main(String[] args) {
		double radius = 3.0;// 半径
      double area = li13.PI * radius * radius;// 计算面积
		double volume = 4 / 3 * li13.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 静态方法

例6.14

package d6;

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

}

6.3.4 静态代码块

例6.15

package d6;

public class li15 {
	static String name;
	//静态代码块
	static {
		System.out.println(name + "静态代码块");
	}
	//非静态代码块
	{
		System.out.println(name+"非静态代码块");
	}

	public li15(String a) {
		name = a;
		System.out.println(name + "构造方法");
	}

	public void method() {
		System.out.println(name + "成员方法");
	}

	public static void main(String[] args) {
		li15 s1;// 声明的时候就已经运行静态代码块了
		li15 s2 = new li15("s2");// new的时候才会运行构造方法
		li15 s3 = new li15("s3");
		s3.method();//只有调用的时候才会运行
}

}

6.4 类的主方法

例6.16

package d6;
public class li16{
	 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
			for (int i = 0; i < args.length; i++) { // 根据参数个数做循环操作
				System.out.println(args[i]); // 循环打印参数内容
			}
	}
 
}

徐xu0795

关注

0
点赞
踩
0

收藏

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

6.1 面向对象概述面向过程：代码紧密，不易分开，可维护性差面向对象：可维护性强在程序开发初期人们使用结构化开发语言，但随着软件的规模越来越庞大，结构化语言的弊端也逐渐暴露出来，开发周期被无休止地拖延，产品的质量也不尽如人意，结构化语言已经不再适合当前的软件开发。这时人们开始将另一种开发思想引入程序中，即面向对象的开发思想。面向对象思想是人类最自然的一种思考方式，它将所有预处理的问题抽象为对象，同时了解这些对象具有哪些相应的属性以及行为，以解决这些对象面临的一些实际问题，这样就在程序开发中引入了面向对
复制链接

扫一扫