第六章 类和对象总结

最新推荐文章于 2024-07-25 14:31:34 发布
最新推荐文章于 2024-07-25 14:31:34 发布
阅读量52 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z1314zppl/article/details/129856015
版权

6.1面向对象概述

  • 方法：将具有独立功能的代码块组成一个整体，使其具有特殊功能的代码集
  • 方法必须先创建才能使用，该过程称为方法定义
  • 方法创建后并不是直接运行，需要手动使用后才执行，该过程称为方法调用

6.1.1对象 

  • 1.使用成员变量
  • 格式：对象名.变量名;
  • 范例：p.brand;
  • 2.使用成员方法
  • 格式：对象名.方法名;
  • 范例：p.call();

2、类和对象，封装 

  • 类的组成：共同属性和行为
  • 属性：在类中通过成员变量体现（类中方法外的变量）
  • 行为：在类中通过成员方法体现（和前面的方法相比，去掉static关键字即可）

 6.1.3面向对象

 继承的弊端
     继承让父类和子类产生关系，当父类发生改变时子类也会改变，削弱了子类的独立性

封装性
封装的原则：将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供的对应的getXxx() 和 setXxx() 方法
封装的好处：
1、通过方法来控制成员变量的操作，提高了代码的安全性
2、把代码用方法进行封装提高了代码的复用性
 
继承性
继承是面向对象三个特征之一。可以使子类具有父类的属性和方法，还可以在子类重新定义，追加属性和方法。
继承的好处
提高了代码的复用性（多个类相同的成员可以放到同一类中）
提高了代码的维护性（修改一处多处修改）
多态性
同一个对象，不同时刻表现出来的不同形态
多态的分类：具体类多态、抽象类多态、接口多态
 

6.2类与对象 

  • 成员变量：可以是变量，可以是常量
  • 构造方法：有构造方法但是本身不能实例化，用于子类访问父类数据初始化（多态的方式实例化）
  • 成员方法：
    1，可以是抽象方法，限定子类必须重写
    2，还可以上非抽象方法，提高代码的复用性
  •                            

 6.2.2成员方法

成员方法：
1，可以是抽象方法，限定子类必须重写
2，还可以上非抽象方法，提高代码的复用性
1、静态方法：有static修饰的成员方法称为静态方法，也叫类方法，属于类本身的，直接用类名访问即可

2、实例方法：无static修饰的成员方法称为实例方法，属于类的每个对象的，必须用类的对象来访问
 

 

例6.1

public static void main(String[] args) {//主函数
		// TODO Auto-generated method stub
		WWW1 book = new WWW1 ();//创建对象
	    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

代码

 
public class www2 {//创建类
 
	public static void main(String[] args) {//主函数
		// TODO Auto-generated method stub
		www2 refTest = new www2();//创建对象
        int[] i = { 0, 1, 2 }; //定义一维数组，作为方法的实参
        //输出一维数组的原始元素值
        System.out.print("原始数据：");
        for (int j = 0; j < i.length; j++)     //for循环
        {
            System.out.print(i[j]+" ");         //输出结算结果
        }
        refTest.change(i);                        //调用方法改变数组元素的值
        System.out.print("\n修改后的数据：");       //输出修改后的数据
        for (int j = 0; j < i.length; j++)       //for循环
        {
            System.out.print(i[j]+" ");             //输出结算结果
        }
	}
	
	public void change(int [] i)     //定义一个方法，方法的参数为一维数组（形参）            
    {
        i[0] = 100;          //数组1
        i[1] = 200;          //数组2
        i[2] = 300;          //数组3
 
 
	}
 
}


 

例6.3

代码

public class MultiTest {    //创建类
	public static void main(String[] args) {    //主方法
		// TODO Auto-generated method stub
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;    //返回运算结果
}
}

 

 

例6.4

代码

 
public class Leopard {       //创建类
	public void gaze(String target){    //普通类
		// TODO Auto-generated method stub
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) {      //定义meet
	System.out.println("猎豹吃"+meat);//输出猎豹吃
}
public void sleep() {       //睡觉
System.out.println("猎豹睡觉");   //输出猎豹睡觉
}
public static void main (String[] args) {  //主函数
	Leopard liebao =new Leopard();                       //定义新数组
	liebao.gaze("羚羊");          //羚羊
     liebao.run();                  //奔跑
	liebao.catchPrey("羚羊");       //捕捉羚羊
	liebao.eat("领羊肉");              //羚羊肉
	liebao.sleep();                  //睡觉
}
 
}

 

6.2.3构造方法 

构造方法的特点如下:

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

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

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

 例6.5

代码

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

 

 

6.2.4 局部变量

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

6.2.5局部变量的有效范围  

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

6.2.6 对象的创建

Test test=new Test();

Test test=new Test("a"); y

Test:类名。test:创建 Test类对象。 new:创建对象操作符。 a:构造方法的参数。

例6.6

代码

6.2.7访问对象的属性和行为

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

例6.7

代码

public class WWW7 {              //创建类
 
		int i = 47; // 定义成员变量
		 
		public void call() { // 定义成员方法
			System.out.println("调用call()方法");  //输出"调用call()方法"
			for (i = 0; i < 3; i++) {     //控制长度
				System.out.print(i + " ");   //输出结果
				if (i == 2) {            //if语句
					System.out.println("\n");  //输出结果
				}
			}
		}
 
		public WWW7() {             // 定义构造方法
		}
 
		public static void main(String[] args) {  //主函数
			WWW7 t1 = new WWW7();                // 创建一个对象
			WWW7 t2 = new WWW7();                  // 创建另一个对象
			t2.i = 60;                          // 将类成员变量赋值为60
		                           	
			System.out.println("第一个实例对象调用变量i的结果：" + t1.i);// 使用第一个对象调用类成员变量
			t1.call(); // 使用第一个对象调用类成员方法
			
			System.out.println("第二个实例对象调用变量i的结果：" + t2.i);// 使用第二个对象调用类成员变量
			t2.call(); // 使用第二个对象调用类成员方法
 
 
	}
 
}

 

 6.2.8对象的销毁

每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址会被回收。在其他语言中需要手动回收废弃的对象，但是Java拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器将回收无用的但占用内存的资源。
   在谈到垃圾回收机制之前，首先需要了解何种对象会被 Java 虚拟机视为垃圾。主要包括以下两种情况:
 

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

(2)将对象赋值为null。

 

 6.2.9 this关键字

例6.8

代码

 
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方法
 
	}

 

例6.9

代码

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

 

例6.10

代码

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

 

 6.3.1 静态变量

 很多时候，不同的类之间需要对同一个变量进行操作，比如一个水池，同时打开入水口和出水，进水和出水这两个动作会同时影响到池中的水量，此时池中的水量就可以认为是一个共享的变量。在Java 程序中，把共享的变量用 static 修饰，该变量就是静态变量。

 

例6.11

代码

public class Pool {//类名
static public int water=0;//定义一个静态的公开的整型变量并赋值
public void outlet(){//放水，一次放出2个单位
	if(water>=2){   //if ...else语句
		water=water-2;//水量减2
	}else{        //if ...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);//输出信息
	}
 
}

 例6.12

代码

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);//输出a.x的值是
		System.out.println("a.y的值是="+a.y);//输出a.y的值是
		System.out.println("b.x的值是="+b.x);//输出b.x的值是
		System.out.println("b.y的值是="+b.y);//输出b.y的值是
 
 
	}
}

 

6.3关键字 

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

 

6.3.2 静态常量

例6.13

代码

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);//输出信息
	}
}

6.3.3 静态方法

例6.14

代码

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

 

  6.3.4 静态代码块

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

静态代码块

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

 

例6.15

代码

public class WWW15 {          //创建类
	static String name;   //普通类
	//静态代码块
	static {  //普通类
		System.out.println(name + "静态代码块");  //输出结果
	}
	//非静态代码块
	{
		System.out.println(name+"非静态代码块");//输出结果
	}
 
	public WWW15(String a) {// 公开类
		name = a;
		System.out.println(name + "构造方法");//输出结果
	}
 
	public void method() {// 公开类
		System.out.println(name + "成员方法");//输出结果
	}
 
	public static void main(String[] args) {  //主函数
		WWW15 s1;// 声明的时候就已经运行静态代码块了
		WWW15 s2 = new WWW15("s2");// new的时候才会运行构造方法
	    WWW15 s3 = new WWW15("s3");// new的时候才会运行构造方法
		s3.method();           //只有调用的时候才会运行
}
 
}

6.4类的主方法

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

 

  1.  主方法是静态的，所以如要直接在主方法中调用其他方法，则该方法必须是静态的。
  2.  主方法没有返回值。
  3.  主方法的形参为数组。其中args[0]~args[n]分别代表程序的第一个参数到第n+1个参数，可以使用args.length获取参数的个数

 

例6.16

代码

 

 

马虎小丸子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言程序设计第六章类和对象(二).(推荐文档).ppt
11-15
在C++编程语言中，类和对象是面向对象编程的核心概念...总结来说，理解和熟练运用类的成员指针和对象指针对于深入掌握C++的面向对象编程至关重要。这些特性使我们能够灵活地操作类的内部结构，实现更复杂的设计和算法。
2015.6.13--java第六章类和对象章总结.doc
06-27
2015.6.13--java第六章类和对象章总结.doc
第6章类和对象PPT学习教案.pptx
10-03
面向对象编程是软件开发中的核心思想之一，它以类和对象为中心进行程序设计。在Java等面向对象语言中，类是对象的蓝图，而对象则是类的实例。 **类和对象概述** 类是面向对象编程的基础，它描述了一组具有相同特征...
2015.6.13--java第六章类和对象章总结[借鉴].pdf
10-10
类是面向对象编程的基础，它是一个模板或者蓝图，定义了一组具有相同属性和行为的对象。在Java中，定义类的语法如下： ```java public class ClassName { // 类的内部代码 } ``` 类的属性（成员变量）用于存储...
c#第4章面向对象的高级编程.ppt
11-13
C# 第4章面向对象高级编程 本章教学目的：介绍C# 高级编程的相关知识，使学生对C# 高级编程有一个感性认识。 一、封装、继承与多态 * 封装：隐藏调用者不需要了解的信息。例如，模块信息通过类封装，类的成员通过...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1183
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 476
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 232
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1940
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1328
Java实现拼图小游戏
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 996
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 230
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 846
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
4.Jmeter接口性能测试
weixin_43444329的博客
07-23 712
系统用户数：软件系统注册的用户总数（要注意初始化环境）在线用户数：某段视角内访问用户数，这些用户只是咋先，不一定同时做某一件事情。（初始化环境（warm up热机：让系统接近运行的系统，让系统运行更快 磁盘->内存））并发用户数：某一个时间同时向系统提交请求的用户数，场景不一定是同一个。：测试web系统的性能，支持多少并发？在确定并发用户数之前，必须先对用户的业务进行分解，分析出其中的典型业务场景（用户最常用、最关注的业务操作）然后基于场景获得其并发用户数。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 706
java、数据类型、循环、选择等
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 103
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
19.jdk源码阅读之FutureTask
最新发布
前端、移动端、后端源码级底层原理分享
07-25 541
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
Java的集合框架（Collection Framework）中的Iterator接口详解
m0_49013185的博客
07-22 623
在Java中，将Iterator定义为接口是一种设计上的选择，目的是提供一个统一的迭代机制，使不同类型的集合都能以一致的方式进行遍历。以下是将Iterator以下是IteratorE next();将Iterator定义为接口的主要目的是提供一个统一、灵活且可扩展的迭代机制。通过这种方式，Java集合框架能够支持多种类型的集合，并且客户端代码能够以一致的方式使用这些集合。这种设计不仅简化了集合的使用，还提高了代码的可维护性和可扩展性。
mysql表设计
wwwwwww31311的博客
07-23 155
status 状态 java代码中用一个枚举类，比如我的请假表还处于草稿状态，可以是新建态，提交后处于待审批状态，审批完成则是成功态，审批拒绝就是拒绝态。start_time 开始时间 dateTime类型。end_time 起始时间 dateTime类型。employee_id 外键，和员工信息表想管理。type 请假类型，对应一个枚举类，病假，事假。create_time 请假记录的创建时间。如果让你设计一个请假表，如何设计？approve_id 外键。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值