第六章面向对象总结

最新推荐文章于 2022-10-18 18:00:29 发布

何文超哈

最新推荐文章于 2022-10-18 18:00:29 发布

阅读量374

点赞数

文章标签： eclipse java

本文链接：https://blog.csdn.net/qq_65555711/article/details/124448122

版权

本文详细介绍了Java中的面向对象编程概念，包括对象、类、成员变量、成员方法、构造方法、局部变量、对象创建、访问对象属性和行为、对象销毁、this关键字、static关键字及其相关概念如静态变量、静态常量、静态方法、静态代码块和主方法。通过实例解析了类的定义和对象的使用，强调了封装、继承和多态等核心特性。

摘要由CSDN通过智能技术生成

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

对象

在面向对象中，类和对象是最基本、最重要的组成单元。类实际上是表示一个客观世界某类群体的一些基本特征抽象。对象就是表示一个个具体的东西。所以说类是对象的抽象，对象是类的具体。

类

每个人都有身高、体重、年龄、血型等属性，人会劳动、会直立行走、会用自己的头脑去创造工具等方法。人之所以能区别于其他类型的动物，是因为每个人都具有“人”这个群体的属性与方法。
“人类”只是一个抽象的概念，它仅仅是一个概念，是不存在的实体！但是所有具备“人类”这个群体的属性与方法的对象都叫人！这个对象“人” 是实际存在的实体！每个人都是“人”这个群体的一个对象。
老虎为什么不是人？因为它不具备“人”这个群体的属性与方法，老虎不会直立行走，不会使用工具等，所以说老虎不是人！也就是说，类是概念模型，定义对象的所有特性和所需的操作，对象是真实的模型，是一个具体的实体。
由此可见，类是描述了一组有相同特性（属性）和相同行为（方法）的一组对象的集合。
对象或实体所拥有的特征在类中表示时称为类的属性。例如，每个人都具有姓名、年龄和体重，这是所有人共有的特征。但是每一个对象的属性值又各不相同，例如，小明和小红都具有体重这个属性，但是他们的体重值是不同的。
对象执行的操作称为类的方法。比如，“人”这个对象都具有的行为是“吃饭”，因此，吃饭就是“人”类的一个方法。
综上所述，类是描述实体的“模板”和“原型”，它定义了属于这个类的对象所应该具有的状态和行为。
使用该类定义的不同姓名的人在上课是对象，他们可能是小明、小红、小丽、张会等。在 Java 面向对象编程中，用自定义的类模型可以创建该类的一个实例，也就是对象。
类是实体对象的概念模型，因此通常是笼统的、不具体的。关于类和对象，初学者在理解上是存在一定难度的。
类是 Java 中的一种重要的引用数据类型，也是组成 Java 程序的基本要素，因为所有的 Java 程序都是基于类的

对象的属性：静态部分

对象的行为：动态部分

类：是同一类事物的统称，类实质是封装对象属性和行为的载体，而对象则是类抽象出来的一个实例

面向对象程序设计的特点

封装性、继承型、多态性

封装：封装是面向对象编程的核心思想。将对象的属性和行为封装起来。采用封装的思想保证了类内部数据结构的完整性。

继承：类与类之间同样具有关系，继承性主要利用特定对象之间的共有属性，注意子类的实例都是父类的实例，但不能说父类的实例是子类的实例。

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

4.定义类：

class 类名称{
//类的成员变量
//类的成员方法
}

在java中对象的属性以成员变量的形式存在，对象的方法以成员方法的形式存在。

成员变量：

在java中对象的属性称为成员变量

数据类型 变量名称 [=值];

java中常见类型的默认值

成员方法：

在java语言中，成员方法对于类对象的行为，它主要用来定义类可执行的操作，它是包含一系列语句的代码块。

成员方法的定义
[权限修饰符] [返回值类型] 方法名 ([参数类型 参数名]) [throws 异常类型]{
...//方法体
return 返回值;
}
其中，"权限修饰符"可以是private、public、protected中的任一个，也可以不写，主要用来控制方法的访问权限，关于权限修饰符将在下一章详细讲解 "返回值类型"指定方法返回数据的类型，可以是任何类型，如果方法不需要返回值，则使用void关键字；一个成员方法既可以有参数，也可以没有参数，参数可以是基本类型中的任何一个。

注意：方法的定义必须在某个类中，定义方法时如果没有指定权限修饰符，方法的访问权限为默认（即只能在本类及同一个包的类中进行访问）。

如果定义的方法有返回值，则必须使用return关键字返回一个指定类型的数据，并且返回值类型要与方法返回的值类型一致

2.成员方法的参数

调用方法时可以给该方法传递一个或多个值，传给方法的值叫做实参，在方法内部，接收实参的变量叫做形参，形参的声明跟变量的声明一样，形参只在方法内部有效。java中方法参数主要有3种，分别为值参数、引用参数和不定长参数。

值参数：表明实参与形参之间按值传递，当使用值参数的方法被调用时，编译器为形参分配存储单元，然后将对应的实参的值复制到形参中，在方法中对值类型的形参的修改并不会影响实参。
public class test1 {//创建类
	int x ;//定义一个整型变量
	public static void main(String[] args) {//主方法
		test1 book=new test1();//创建Book对象
		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
		
	}
 
}
运行结果如下：

引用参数

如果在给方法传递参数时，参数的类型是数组或者其他引用类型，那么，在方法中对参数的修改会反映到原有的数组或者其他引用类型上，这种类型的方法参数称为引用参数。
public class RefTest {//类名
 
    public static void main(String[] args) {//主方法
        RefTest refTest=new RefTest();//创建RefTest对象
        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;//给数组与元素赋值
}
}
运行结果如下：

不定长参数

声明方法时，如果有若干个相同类型的参数，可以定义为不定长参数，该类型的参数声明如下：
权限修饰符 返回值类型 方法名(参数类型...参数名)
注意：参数类型和参数名之间是三个点，而不是其他数量或省略号。
public class MultiTest {//类名
 
	public static void main(String[] args) {//主方法
		MultiTest multi=new MultiTest();//创建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;//返回运算结果
	}
 
}
运行结果如下：

注意：不定长参数必须是方法中的最后一个参数，任何其他常规参数必须在它前面。

成员方法的使用

public class Leopard {//类名
	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){//主方法
		Leopard liebao=new Leopard();//在Leopard创建一个对象
		liebao.gaze("羚羊");//调用gaze方法
		liebao.run();//调用run()方法
		liebao.catchPrey("羚羊");//调用catchPrey方法
		liebao.sleep();//调用sleep方法
		
		
	}
}

运行结果如下：

构造方法：

在类中除了成员方法之外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。

构造方法的特点如下：

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

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

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

构造方法的定义语法如下：

class Book {//新建类
public Book(){//构造方法
}
}
public:构造方法修饰符。

Book:构造方法的名称。

在构造方法中可以为成员变量赋值，这样当实例化一个本类的对象时，相应的成员变量也将被初始化。如果类中没有明确定义构造方法，则编译器会自动创建一个不带参数的默认构造方法。除此之外，在类中定义构造方法时，还可以为其添加一个或者多个参数，即有参构造方法语法如下：

class Book {
public Book(int args){//有参构造方法
//对成员变量进行初始化
}
}
构造方法除了可以用public修饰以外，还可以用private修饰，即私有的构造方法，私有构造方法无法使用new创建对象，这时需要使用静态方法生成类对象。

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

运行结果如下：

局部变量

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

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

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

说明：类成员变量和成员方法可以统称为类成员。如果一个方法中含有与成员变量同名的局部变量，则方法中对这个变量的访问以局部变量进行。

局部变量的有效范围

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

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

对象的创建

在java语言中通过new操作符来创建对象。前文在讲解构造方法时介绍过。

语法如下：

Test test=new Test();
Test test=new Test("a");
Test:类名。

解释说明：

test:创建Test类对象

new:创建对象操作符。

a:构造方法的参数。

test对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了存储空间，
public class CreateObject {//类名
public CreateObject(){//构造方法
	System.out.println("创建对象");//输出信息
}
	public static void main(String[] args) {//输出信息
		
new CreateObject();//创建对象
	}
 
}
运行结果如下：

访问对象的属性和行为

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

public class TransferProperty {//类名
int i=47;// 定义一个成员变量
public void call(){//定义成员方法
	System.out.println("调用call()方法");//输出信息
	for(i=0;i<3;i++){//使用for循环输出0到2
		System.out.println(i+" ");//输出信息
		if(i==2){//判断i是否等于2
			System.out.println("\n");//换行
		}
	}
}
	public static void main(String[] args) {//主方法
TransferProperty t1=new TransferProperty();//创建一个对象
TransferProperty t2=new TransferProperty();//创建一个对象
t2.i=60;//将类成员变量赋值为60
	System.out.println("第一个实例对象调用变量i的结果："+t1.i);//输出
	t1.call();//使用第一个对象调用类成员方法
	System.out.println("第二个实例对象调用变量i的结果："+t2.i);//输出信息
t2.call();//使用第二个对象调用类成员方法
 
	}
 
}

运行结果如下：

对象的销毁

每个对象都有生命的周期，当对象的生命周期结束时，分配给该对象的内存地址会被回收。在其它语言中需要手动回收废弃的对象，但在Java拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收站将回收无用的但占用内存的资源。

何种对象会被Java虚拟机视为垃圾。

（1）对象引用超出其作用范围，这个对象将被视为垃圾

（2）将对象赋值为null。

finalize()方法可进行垃圾回收但不一定会发生

System.gc()方法强制启动垃圾回收器。

this关键字

调用成员变量和方法。

public class Book2 {//创建一个Book类
String name="abc";//定义一个成员变量
public void showName(String name){//定义一个showName类并从传入一个参数
	System.out.println(name);//输出
}
	public static void main(String[] args) {
		Book2 book=new Book2();//在Book2类定义一个对象
		book.showName("123");//调用showName方法
 
	}
 
}

运行结果如下：

public class Book3 {//类名
String name="abc";//创建一个成员变量
public void showName(String name){
	System.out.println(this.name);//调用成员变量并输出
}
	public static void main(String[] args) {
		
Book3 book=new Book3();//创建对象
book.showName("123");//调用showName方法
	}
 
}

运行结果如下：

this关键字除了可以调用成员变量和方法，事实上this还可以调用类中的构造方法。

public class EggCake {//类名
int eggCount;//鸡蛋灌饼里有几个蛋
public EggCake(int eggCount){
	this.eggCount=eggCount;
	System.out.println("这个鸡蛋灌饼里有"+eggCount+"个蛋");
}//无参数构造方法，默认给饼加一个蛋
public EggCake(){//方法名
	this(1);
}
	public static void main(String[] args) {//主方法
		EggCake cake1=new EggCake();//在EggCake里创建一个对象
		EggCake cake2=new EggCake(5);//在EggCake里创建一个对象
		
 
	}
 
}

运行结果如下：

注意：在无参构造方法中可以使用this关键字调用有参的构造方法。但是要注意，this（）语句之前不可以有其他代码。

static关键字

由static修饰的变量、常量和方法被称作静态变量、静态常量、静态方法，也被称为类的静态成员。静态成员是属于类所有的。区别于个别对象。

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

类名.静态类成员

public class Pool {//类名
static public int water=0;//定义一个静态的公开的整型变量并赋值
public void outlet(){//放水，一次放出2个单位
	if(water>=2){
		water=water-2;//水量减2
	}else{
		water=0;//水量为0
	}
}
public void inlet(){//注水，一次注入3个单位
	water=water+3;//水量加3
}
	public static void main(String[] args) {
		Pool out=new Pool();//在Pool类里创建一个对象
		Pool in=new Pool();//在Pool类里创建一个对象
		System.out.println("水池的水量："+Pool.water);//输出信息
		System.out.println("水池注水两次。");//输出信息
		in.inlet();//调用注水方法
		in.inlet();//调用注水方法
		System.out.println("水池的水量："+Pool.water);//输出信息
		System.out.println("水池放水一次");//输出信息
		out.outlet();//调用防水方法
		System.out.println("水池的水量："+Pool.water);//输出信息
	}
 
}

运行结果如下：

public class StaticVariable {//创建类
	static int x;//静态变量
	int y;//普通成员变量
public StaticVariable(int x,int y){//构造函数
	this.x=x;//调用静态变量并初始化
	this.y=y;//调用成员变量并初始化
}
	public static void main(String[] args) {//主方法
		StaticVariable a=new StaticVariable(1,2);//在类里创建一个对象并赋值
		StaticVariable b=new StaticVariable(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);//输出
 
 
	}
 
}

运行结果如下：

说明：当类首次被加载时，静态变量就被分配到内存中，直到程序结束才会释放。

静态常量

final static 数据类型 变量名=值;

public class Graphical {//创建类
final static double PI=3.1415926;//创建静态常量Π
	public static void main(String[] args) {//主方法
		double radius=3.0;//半径
				double area=Graphical .PI*radius*radius;//计算面积
				double volume=4/3*Graphical.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);//输出信息
	}
}

运行结果如下：

注意：给静态常量赋值时所有的字母都应该大写。

静态方法

类名.静态方法();

public class StaticMethod {//创建类
	static public void show(){//静态方法
		System.out.println("静态方法无需实例化就可以调用");//输出信息
	}
 
	public static void main(String[] args) {
		
		StaticMethod.show();//使用类名调用静态方法
	}
 
}

运行结果如下：

静态代码块

在类中除成员方法之外，用static修饰代码块可以称之为静态代码块。定义一块静态代码块，可以完成类的初始化操作，在类声明时就会运行.

public class StaticTest{
static{
//此处编辑执行语句
}
}

public class StaticTest {//创建类
static String name;//定义静态变量
static{
	System.out.println(name+"静态代码块");//输出
}
{
	System.out.println(name+"非静态代码块");//输出
}
public StaticTest(String a){
	name=a;
	System.out.println(name+"构造方法");//输出
}
public void method(){
	System.out.println(name+"成员方法");//输出
}
	public static void main(String[] args) {
		StaticTest s1;
		StaticTest s2=new StaticTest("s2");//new的时候才会运行构造方法
		StaticTest s3=new StaticTest("s3");
		s3.method();//只有调用的时候才会运行
	}
 
}

运行结果如下：

说明：

（1）静态代码块由始至终只运行一次

（2）非静态代码块，每创建对象时候，会在构造方法之前运行。所以读取成员变量时，只能获取到默认值null。

类的主方法

public static void main(String[]args){
//方法体
}

说明：
（1）主方法是静态的，所以如要直接在主方法中调用其他方法，则该方法必须是静态的。

（2）主方法没有返回值。

（3）主方法的形参为数组。其中args[0]~args[n]分别代表程序的第一个参数到第n+1个参数，可以使用args.length获取参数的个数。

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

运行结果如下：

总结：

面向对象简称 OO（Object Oriented），20 世纪 80 年代以后，有了面向对象分析（OOA）、面向对象设计（OOD）、面向对象程序设计（OOP）等新的系统开发方式模型的研究。

对 Java 语言来说，一切皆是对象。把现实世界中的对象抽象地体现在编程世界中，一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计，这些对象可以是独立存在的，也可以是从别的对象继承过来的。对象之间通过相互作用传递信息，实现程序开发。

何文超哈

关注

0
点赞
踩
1

收藏

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

目录对象类成员变量：成员方法：构造方法：局部变量局部变量的有效范围对象的创建访问对象的属性和行为对象的销毁this关键字static关键字静态变量：把共享的变量用static 修饰，该变量就是静态变量。静态常量静态方法静态代码块类的主方法总结：对象在面向对象中，类和对象是最基本、最重要的组成单元。类实际上是表示一个客观世界某类群体的一些基本特征抽象。对象就是表示一个个具体的东西。所以说类是对象的抽象，对象是类的具...
复制链接

扫一扫