Java学习笔记6——对象与类

最新推荐文章于 2024-12-11 13:50:34 发布
最新推荐文章于 2024-12-11 13:50:34 发布
阅读量526 收藏
点赞数
分类专栏： JAVA学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Hilary_Li/article/details/84099659
版权
本文详细介绍了Java中的面向对象编程，包括类与对象的概念、构造器、实例化、封装、访问器与更改器方法。文章提供了四个实例，涵盖圆的计算、日期转换、进制转换和月历打印。此外，讨论了类的静态域、静态方法、工厂方法以及对象的构造过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  • 面向对象程序设计（OOP）

  1. 类（class）：构造对象的模板或蓝图。由类构造（construct）对象的过程称为创建类的实例（instance），对象中的数据称为实例域（instance field），操纵数据的过程称为方法（method）。
  2. 对象：对象的行为（behavior）：对对象施加哪些操作方法；状态（state）：当施加那些方法时，对象如何响应；标识（identity）：如何辨识具有相同行为与状态的不同对象。
  3. 识别类：识别类的简单规则是在分析问题的过程中寻找名词，而方法对应着动词。
  4. 类之间常见关系：依赖、聚合、继承

  • 使用预定义类

  1. 对象与对象变量：使用构造器（constructor）构造新实例，构造器名字应该与类名相同。因此，要想构造一个类对象，需要在构造器前面加上new操作符。
  2. Java类库中的Gregorian Calendar类。
  3. 更改器方法与访问器方法：要查询某类信息，调用该类的get方法；改变对象的状态则调用set方法。对实例域做出修改的方法称为更改器方法（mutator method ），仅访问实例域而不进行修改的方法称为访问器方法（accessor method）。

  • 用户自定义类

1.构造器与其他方法有一个重要的不同。构造器总是伴随着new操作符的执行被调用，而不能对一个已经存在的对象调用构造器来达到重新设置实例域的目的。

  • 构造器与类同名
  • 每个类可以有一个以上的构造器
  • 构造器可以有0、1、多个参数，构造器没有返回值
  • 构造器总是伴随着new操作符一起使用

！不要在构造器中定义与实例域重名的局部变量。例：

public Employee (String n, double s,...){
    String name = n;    //Error
    double salary = s;  //Error
}

      此构造器将无法设置salary，此构造器声明了局部变量name和salary，这些变量只能在构造器内部访问，这些变量屏蔽了同名的实例域。

2.隐式参数和显示参数

  • 隐式参数：出现在方法名前的类对象
  • 显示参数：位于方法名后面括号中的数值

3.封装的优点：

  1. 可以改变内部实现，除了该类的方法之外，不会影响其他代码，解决设计上的缺陷。private、public、default、protected
  2. 更改器方法可以执行错误检查，直接对域进行赋值将不会进行这些处理。this指向当前对象。

！注意不要编写返回引用可变对象的访问器方法。如果需要返回一个可变对象的引用，应首先对它进行克隆（clone）。对象clone是指存放在另一个位置上的对象副本。

3.基于类的访问权限。方法可以访问所调用对象的私有数据。一个方法可以范文所属类的所有私有数据。

4.私有方法。在Java中，为了实现一个私有的方法，只需将关键字public改为private即可。

5.final实例域。可以将实例域定义为final，构建对象时必须初始化这样的域。final修饰符大都应用于基本（primitive）类型域，或不可变（immutable）类的域（如果类中的每个方法都不会改变其对象，这种类就是不可变的类）。如String就是一个不可变的类，对于可变的类，使用final修饰符可能会造成混乱。

使用类图描述类（参考工具：StarUML、Astah UML）。

注：

  1. +代表public，-代表private
  2. 属性名在前，后面跟着冒号和类型名
  3. 方法名在前，后面跟着冒号和返回值类型
  4. 如果有参数，参数类型写法同上

类和对象之间的关系：类是抽象的概念，仅仅是模板；对象是一个能看得见，摸得着的具体实体。

  • 静态域与静态方法

1.静态域。如果将域定义为static，每个类中只有一个这样的域，而每一个对象对于所有的实例域都有自己的一份拷贝。

2.静态常量。public static void main（String[] args）另一个多次使用的静态常量是System.out

3.静态方法。静态方法是一种不能向对象操作的方法，可以认为静态方法是没有this参数的方法（在一个非静态的方法中this参数表示这个方法的隐式参数）。因为静态方法不能操作对象，所以不能在静态方法中访问实例域，但静态方法可以访问自身类中的静态域。在下面两种情况下使用静态方法：

  • 一个方法不需要访问对象的状态，其所需参数都是通过显式参数提供
  • 一个方法只需要访问类的静态域

4.工厂方法。NumberFormat类使用工厂方法产生不同风格的格式对象。不利用构造器完成相关操作的原因：①无法命名构造器。构造器的名字必须与类名相同。②当使用构造器时，无法改变所构造的对象类型。

5.main方法。

方法：为完成一个操作而组合在一起的语句组。内置方法：有JDK类库提供、需要导入相应的包。自定义方法：不带参数、带参数。

Math.ceil(x)：向上取整x最接近的整数，取大于x的整数。

Math.floor(x)：向下取整x最接近的整数，取小于x的整数。

  • 定义方法

由方法名、返回值类型、参数列表和方法体组成。三要素：方法名、返回值类型、参数列表

修饰符  返回值类型  方法名（[参数列表]）{

                    //方法体

}

  • 关于“定义方法”和“声明变量”
  1. 定义是指被定义的条目是什么。
  2. 声明通常是指为被声明的条目分配内存来存储数据。

  • 方法参数

按值调用：表示方法接收的是调用者提供的值call by value

按引用调用：表示方法接收的是调用者提供的变量地址call 毕业reference

Java程序设计语言总是采用按值调用，即方法得到的是所有参数值的一个拷贝，特别是，方法不能修改传递给它的任何参数变量的内容。

Java程序设计语言中方法参数的使用情况：

  • 一个方法不能修改一个基本数据类型的参数（即数值型和布尔型）
  • 一个方法可以改变一个对象参数的状态
  • 一个方法不能让对象参数引用一个新的对象

调用方法时，方法的参数个数无法确定。注意：使用不定长度参数时，必须是参数的最后一个，一个方法里只能有一个不定长参数。

构造方法：

  1. 没有返回值类型
  2. 名称与类名一致
  3. 可以指定参数及实现重载
  4. 注意隐式构造和参数化构造不能共存

  • 对象的构造

1.重载（overloading）。如果多个方法有相同的名字，不同的参数，便产生了重载。编译器必须挑选出具体执行哪个方法，通过各个方法给出的参数类型与特定方法调用所使用的值类型进行匹配来挑选出相应的方法。如编译器找不到匹配的参数，或者找出多个可能的匹配，就会产生编译错误（此过程称为重载解析）

注：Java允许重载任何方法，而不只是构造器方法。因此，要完整地描述一个方法需要指出方法名和参数类型，这叫做方法的签名（signature）。返回类型不是方法签名的一部分，即不能有两个名字相同，参数类型也相同却返回不同类型的方法。

2.默认域初始化。数值为0；布尔值为false；对象引用为null

注：这是域与局部变量的主要不同点。必须明确初始化方法中的局部变量，如没有初始化类中的域，将会被初始化为默认值。

3.无参数的构造器。很多类都包含一个无参数的构造函数，对象由无参数构造函数创建时，其状态会设置为适当的默认值。

4.显式域初始化。

5.参数名。通常，参数用单个字符命名，但缺点是只有阅读代码才能了解其含义，于是，有些程序员在每个参数前面加上一个前缀“a”，还有一种常用的技巧，基于这样的事实：参数变量用同样的名字将实例域屏蔽起来。this.name = name;

6.调用另一个构造器。关键字this引用方法的隐式参数。然，此关键字还有另外一个含义，如构造器的另外一个语句形如this（...）,这个构造器将调用同一类的另一个构造器。

7.初始化块

初始化数据域的方法：

  • 在构造器中设置组
  • 在声明中赋值
  • 初始化块

调用构造器的具体处理步骤：

  1. 所有数据域被初始化为默认值（0、false或null）。
  2. 按照在类声明中出现的次序，依次执行所有域初始化语句或初始化块。
  3. 如果构造器第一行调用了第二个构造器，则执行第二个构造器主体。
  4. 执行这个构造器的主体。

8.对象析构与finalize方法

  • 包（package-类似文件夹性质）

  1. 打包。package com.dilili.javabase
  2. 类的导入。可以采用两种方式访问另一个包中的公有类：第一种方式是在每个类名之前添加完整的包名，更简单常用的是使用import语句。import java.util.Scanner
  3. 静态导入。import语句步进可以导入类，还增加了导入静态方法和静态域的功能。
  4. 将类放入包中。！编译器在编译源文件的时候不检查目录结构。
  5. 包作用域。变量必须显式地标记为private，否则将默认包为可见，破坏封装性。

包的作用：

  1. 包允许将类组合成较小的单元（类似文件夹），使其易于找到和使用相应的类文件。
  2. 有助于避免命名冲突。在使用许多类时，类和方法的名称很难决定。有时需要使用与其他类相同的名称，包基本上隐藏了类，并避免了名称上的冲突。
  3. 包允许在更广的范围内保护类、数据和方法，可以在包内定义类，而在包外的代码不能访问该类。

注：1.包将类名空间划分为更加容易管理的块。2.包既是命名机制，也是可见度控制机制。

 

  • 类路径

为了使类能够被多个程序共享，需要做到以下几点：

  1. 把类放到一个目录中，需注意这个目录是包树状结构的基目录。
  2. 将JAR文件放在一个目录中。
  3. 设置类路径（class path），类路径是包含所有类文件路径的集合。

类路径包括：

  • 基目录   /home/user/clasdir或c:\classes;
  • 当前目录（.）
  • JAR文件

设置类路径，最好采用-classpath（或-cp）选项指定类路径。

  • 文档注释

  1. 类注释必须放在import语句之后，类定义之前。
  2. 每一个方法注释必须放在所描述的方法之前。
  3. 域注释，只需要对公有域（通常指静态常量）建立文档。
  4. 通用注释。
  5. 包与概述注释。要想产生包注释，就需要在每一个包目录中添加一个单独的文件：提供一个以package.html命名的HTML文件；提供一个以package.info.java命名的Java文件。
  6. 注释的抽取。

  • 类设计技巧

  1. 一定要保证数据私有
  2. 一定要对数据初始化
  3. 不要在类中使用过多的基本类型
  4. 不是所有的域都需要独立的域访问器和域更改器
  5. 将职责过多的类进行分解
  6. 类名和方法名要能够体现它们的职责

实例1：使用面向对象的方式创建一个圆类，分别计算周长和面积

import java.util.Scanner;
/**
 * 使用面向对象的方式创建一个圆类，分别计算周长和面积
   1.定义类：Circle
   2.抽取属性
   3.定义方法
   4.调用方法并打印结果
 * @author 棣哩哩
 * @date 2018年11月9日 下午8:43:52
 * @remarks TODO
 */
public class Circle {
	/** 圆的半径*/
	public double radius;
	/** 圆的周长*/
	public double perimeter;
	/** 圆的面积*/
	public double area;
	
	public void inputRadius(){
		Scanner input = new Scanner(System.in);
		System.out.print("请输入圆的半径：");
		radius = input.nextDouble();
		input.close();
	}	
	public void showPerimeter(){
		if(radius <= 0){
			inputRadius();//如果用户没有输入半径，那么强制用户输入半径
		}
		perimeter = 2 * Math.PI * radius;
		System.out.println("周长为：" + perimeter);
	}
	
	public void showArea(){
		if(radius <= 0){
			inputRadius();//如果用户没有输入半径，那么强制用户输入半径
		}
		area = Math.PI * Math.pow(radius, 2);
		System.out.println("面积为：" + area);
	}
}

import java.util.Scanner;

/**
 * 使用面向对象的方式创建一个圆类，分别计算周长和面积
   1.定义类：Circle
   2.抽取属性
   3.定义方法
   4.调用方法并打印结果
 * @author 棣哩哩
 * @date 2018年11月9日 下午8:43:52
 * @remarks TODO
 */
public class Circlev2 {
	/** 圆的半径*/
	public double radius;
	/** 圆的周长*/
	public double perimeter;
	/** 圆的面积*/
	public double area;
	
	public Circlev2(){
		inputRadius();
	}
	
	public Circlev2(double radius1){
		if(radius1 > 0){
			radius = radius1;
		}else{
			inputRadius();
		}
	}
	private void inputRadius(){
		Scanner input = new Scanner(System.in);
		System.out.print("请输入圆的半径：");
		radius = input.nextDouble();
		input.close();
	}
	
	public void showPerimeter(){
		if(radius <= 0){
			inputRadius();//如果用户没有输入半径，那么强制用户输入半径
		}
		perimeter = 2 * Math.PI * radius;
		System.out.println("周长为：" + perimeter);
	}
	
	public void showArea(){
		if(radius <= 0){
			inputRadius();//如果用户没有输入半径，那么强制用户输入半径
		}
		area = Math.PI * Math.pow(radius, 2);
		System.out.println("面积为：" + area);
	}
}

public class Circlev3 {
	/** 圆的半径*/
	private double radius;
	/** 圆的周长*/
	private double perimeter;
	/** 圆的面积*/
	private double area;
	
	public double getRadius(){
		return radius;
	}
	
	public void show(){
		System.out.println("周长为：" + this.getPerimeter());
		System.out.println("面积为：" + this.getArea());
	}
	
	public Circlev3() {}
	public Circlev3(double radius) {
		//this.radius = radius;
		this.setRadius(radius);
	}

	public void setRadius(double radius){
		if(radius <= 0){//封装的好处，可以对传入的属性进行简单的验证
			radius = 1;
		}else{
		//this->自指针 朕/寡人
		this.radius = radius;
		}
	}
	public double getPerimeter() {
		perimeter = 2 * Math.PI * radius;
		return perimeter;
	}
	public double getArea() {
		area = Math.PI * Math.pow(radius, 2);
		return area;
	}
}
import java.util.Scanner;

public class CircleTest {
	public static void main(String[] args) {
//		Circle circle = new Circle();
//		circle.inputRadius();
//		circle.showPerimeter();
//		circle.showArea();
		
//		Circlev2 circle = new Circlev2();
//		circle.showArea();
		
		
		Scanner input = new Scanner(System.in);
		System.out.print("请输入圆的半径：");
		double radius = input.nextDouble();
		Circlev3 circle = new Circlev3(radius);
		circle.show();
	}

}

实例2：书写代码，将数字星期转换为文字版并输出

import java.util.Scanner;

/**
 * 书写代码，将数字星期转换为文字版并输出
 * @author 棣哩哩
 * @date 2018年10月30日 下午9:13:17
 * @remarks TODO
 */
public class WeekDayDemo {
	public static void main(String[] args) {
		System.out.print("请输入今天是星期几：");
		int dayOfWeek = new Scanner(System.in).nextInt();
		//中文
		ShowWeekDayByChinese(dayOfWeek-1);
		//日文
		ShowWeekDayByJapanese(dayOfWeek-1);
		//英文
		ShowWeekDayByEnglish(dayOfWeek-1);
	}
	/**
	 * 用来判断输入的参数是否在1-7之间
	 * @param dayOfWeek 要判断的整型数字，星期几
	 * @return 如果合法，返回true。非法，返回false
	 */
	private static boolean isRight(int dayOfWeek){
		if(dayOfWeek < 1 || dayOfWeek> 7){
			//System.out.println("必须输入1-7之间的数字");
			return false;
		}
		return true;
	}
	/**
	 * 以中文的方式打印星期几
	 * @param dayOfWeek 1-7之间的整型数字，再来表示星期几
	 */
	public static void ShowWeekDayByChinese(int dayOfWeek){
		if(!isRight(dayOfWeek)){
			System.out.println("必须输入1-7之间的数字");
			return;
		}
		String[] weekdays = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};
		System.out.println(weekdays[dayOfWeek]);
	}
	static void ShowWeekDayByJapanese(int dayOfWeek){
		if(!isRight(dayOfWeek)){
			System.out.println("必须输入1-7之间的数字");
			return;
		}
		String[] weekdays = {"月曜日", "火曜日", "水曜日", "木曜日", "金曜日", "土曜日", "日曜日"};
		System.out.println(weekdays[dayOfWeek]);
	}
	static void ShowWeekDayByEnglish(int dayOfWeek){
		if(!isRight(dayOfWeek)){
			System.out.println("必须输入1-7之间的数字");
			return;
		}
		String[] weekdays = {"Monday", "Tuesday", "Wednessday", "Thursday", "Friday", "Saturday", "Sunday"};
		System.out.println(weekdays[dayOfWeek]);
	}
}

实例三：十六进制和十进制之间的转换

import java.net.StandardSocketOptions;
import java.util.Scanner;

/**
 * 十六进制和十进制之间的转换
 * @author 棣哩哩
 * @date 2018年11月6日 上午9:12:36
 * @remarks TODO
 */
public class HexToDecimalDemo {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		//1.让用户输入一个十进制的数字
		System.out.print("请输入一个整型数字：");
		int decNum = input.nextInt();
		//2.调用一个方法，将十进制转换成十六进制
		System.out.println(decToHex(decNum));
		//3.再将十六进制转换回十进制
		System.out.println(hexToDec(decToHex(decNum)));
	}
	/**
	 * 十六进制转换为十进制
	 * @param hexNum  要转换的十六进制数字
	 * @return     转换成功的十进制数字
	 */
	public static int hexToDec(String hexNum){
		int dec =  0;
		//6E -> 6 * 16 + 14 * 1
		//需要遍历十六进制字符串
		//如果数组中首元素下标为i，那么最后一个元素下标为：len - i - 1
		for (int i = 0; i < hexNum.length(); i++) {
			//取出字符串中的每一个字符串进行判断
			char tempChar = hexNum.charAt(i);
			//两种情况，字符0-9或字符A-F
			if(tempChar >= '0' && tempChar <= '9'){
				dec += (tempChar - '0') * Math.pow(16, hexNum.length() - i - 1);
			}else if(tempChar >= 'A' && tempChar <= 'F'){
				dec += (tempChar - 'A' + 10) * Math.pow(16, hexNum.length() - i - 1);
			}
			
		}
		return dec;
	}
	
	/**
	 * 将十进制转换成十六进制
	 * @param decNum 要转换的十进制数字
	 * @return 换换成十六进制的数字（以字符串的方式返回）
	 */
	public static String decToHex(int decNum){
		//45/16 反取余数
		String hex = "";	//转换好的十六进制字符串
		while(decNum != 0){
			int temp = decNum % 16;//取余数
			//余数可能是0-9或10-15之间的数字
			if(temp >= 0 && temp <= 9){
				hex = temp + hex;	//每取一个余数，就往前拼接
			}else if(temp >= 10 && temp <= 15){
				//把数字转换成字符再拼接
				hex = (char)(temp - 10 + 'A') + hex;
			}
			//卸磨杀驴
			decNum /= 16;
		}
		return hex;
	}

}

实例四：使用方法实现月历的打印

import java.util.Scanner;
/**
 * 使用方法实现月历的打印
 * @author 棣哩哩
 * @date 2018年11月7日 上午9:01:53
 * @remarks TODO
 */
public class PrintCalendarDemo {
	/** 用户输入的年份*/
	public static int year = Integer.MIN_VALUE;
	/** 用户输入的月份*/
	public static int month = Integer.MIN_VALUE;
	/**对应每个月份的天数*/
	private static int[] dayOfMonth = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
	
	public static void main(String[] args) {
		PrintCalendar();
		//getSumDayOfYears();
	}
	/**
	 * 打印月历的核心方法
	 */
	private static void PrintCalendar() {
		//1.让用户输入年份和月份
		InputYearAndMonth();
		//2.计算1900-1-1到用户输入月份的总天数（year=2017， month=7 2017-7-1）
		//  2-1.计算各年的总天数
		//  2-2.计算各月的天数之和
		int sum = getSumDayOfYears();
		sum += getSumDayOfMonth();
		sum++;
		if (sum % 7 == 0){
		    System.out.println(7);
		}else{
			System.out.println(sum % 7);
		}
		//3.打印年份和月份（英文）
		//4.打印月份的标题（星期一-星期日）
		PrintMonthTitle();
		//5.根据某月1日是星期几打印月历内容
		PrintCalendarContent(sum % 7);
	}
	/**
	 * 根据当月1号是星期几打印月历内容
	 * @param dayOfWeek 当月1号是星期几
	 */
	private static void PrintCalendarContent(int dayOfWeek){
		//注意dayOfWeek取值范围是0-6
		int sepCount = 0;   //\t的数量
		if(dayOfWeek == 0){
			sepCount = 6;
		}else{
		sepCount = dayOfWeek - 1;
		}
		for (int i = 0; i < sepCount; i++) {
			System.out.print("\t");
		}
		for (int i = 0; i < dayOfMonth[month - 1]; i++) {
			System.out.print(i + 1);
			if((dayOfWeek + i) % 7 == 0){
				//星期日
				System.out.println();
			}else{
				System.out.print("\t");
			}
		}
	}
	/**
	 * 打印标题
	 */
	private static void PrintMonthTitle(){
		String[] monthNames = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
		System.out.println("\t\t" + year + "\t" + monthNames[month -1]);
		String[] weekdays = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};
		for (int i = 0; i < weekdays.length; i++) {
			System.out.print(weekdays[i] + "\t");
		}
		System.out.println();
	}
	/**
	 * 获得1900-year年的总天数
	 * @return
	 */
	private static int getSumDayOfYears(){
		//需要判断用户是否已经输入了年份
		if(year == Integer.MIN_VALUE){
			System.out.println("年份错误，请重新输入年份和月份");
			InputYearAndMonth();
		}
		int sum = 0;
		for (int i = 1900; i < year; i++) {
			sum += 365;     //每一年累积365天
			if(isLeapYear(i)){
				sum++;   //闰年多加一天
			}
		}
		return sum;
	}
	/**
	 * 得到year年1月1日到year年month-1月最后一天的总天数
	 * @return
	 */
	private static int getSumDayOfMonth(){
		int sum = 0;
		for (int i = 0; i < month - 1; i++) {
			sum += dayOfMonth[i];
			}
		//如果year年是闰年，并且month>=3
		if(isLeapYear(year) && month >= 3){
			sum++;
		}
		return sum;
	}
	/**
	 * 用来判断传入年份是否为闰年
	 * @param year 要判断的年份
	 * @return     是闰年，返回true
	 */
	private static boolean isLeapYear(int year){
		return year % 400 == 0 || year % 4 == 0 && year % 100 != 0;//先算与关系，再算或关系
	}
	/**
	 * 接收用户输入年份和月份
	 */
	private static void InputYearAndMonth(){
		Scanner input = new Scanner(System.in);
		System.out.print("请输入年份：");
		year = input.nextInt();
		System.out.print("请输入月份：");
		month = input.nextInt();
		input.close();
		input = null;
	}
}

 

Java学习笔记21——使用JDBC访问MySQL数据库
2303_79232676的博客
03-19 1541
通常不需要开发人员在程序中直接调用registerDriver方法来注册驱动程序的实例，因为实现Driver接口的驱动程序类都包含了一个静态代码块，在这个静态代码块中，会调用DriverManager.registerDriver方法来注册自身的的一个实例。当使用Class类的forName方法在数据库驱动程序类的时候，会自动执行该静态代码块，从而注册驱动程序的一个实例，这样使用DriverManager.getConnection方法，就返回相应的驱动程序的数据库连接（Connection）对象。
JAVA学习笔记——面向对象编程：枚举类与反射
weixin_43410001的博客
04-07 668
目录枚举类定义枚举类枚举类方法反射Class 类捕获异常利用反射分析类的能力在运行时使用反射分析对象使用反射编写泛型数组代码调用任意方法 枚举类 “枚举”，顾名思义，就是一一全部列举。生活中我们时常用到“枚举”，例如性别有“男”和“女”、一星期只有周一到周日 7 天。 而在程序设计时，对于这种有固定个数取值的变量，不妨可以考虑使用枚举类。类比基本数据类型（仅仅是类比，并不完全相同），枚举类可以看作是我们自定义了一个新的“数据类型”，它的取值为有限个，类名等价于 int，我们自定义的取值等价于 int 类的各
Java笔记（对象与类）
gc2297的博客
07-29 213
类 类（class）是构造对象的模板或蓝图。由类构造（construct）对象的过程称为创建类的实例（instance）。在java程序中创建一些自己的类，以便描述应用程序所对应的问题域中的对象。 封装（encapsulation）是与对象有关的概念，从形式上看，封装不过是将数据和行为组合在一个包中，并对对象的使用者隐藏了数据的实现方式。对象中的数据称为实例域（instance field），操纵数据的过程称为方法（method）。 实现封装的关键在于绝对不能让类中的方法直接地访问其他类的实例域，程序仅通过
python类生成对象的操作叫做( )_Python——类和对象（一）
weixin_39861882的博客
01-15 898
一、定义类在面向对象的程序设计中有两种重要概念：类：可以理解为一个种类，一个模型，是一种抽象的东西。实例、对象：可以理解为一种具体制作或者存在的东西。定义类的语法格式如下：class 类名：执行语句零到多个类变量零到多个类方法例如我们需要制作一只碗，首先需要这个碗的模型就是类，在制作这个碗的过程就叫做实例化，制作出来的碗就是实例、对象；这个碗在中国制作，就是类变量；而这个碗的颜色、材料就是这个类的...
面向对象软件工程知识点
最新发布
bishe361的博客
12-11 687
程序。
python面向对象（3）
weixin_48445640的博客
09-27 315
类属性 顾名思义，类对象拥有的属性，被该类的所有的实例对象所共同拥有 可以被类对象、实例对象访问 class Gun(object): length = 10 wuzi = Gun() print(Gun.length) print(wuzi.length) 均输出为10 修改类属性 此时不能用实例对象修改类属性，如果还是用实例对象修改类属性，那么相当于自己创建了一个新的实例属性，而并没有修改类属性，唯一方法是通过类属性进行直接修改 类方法 ...
java中什么是包
weixin_42981419的博客
07-14 673
一、什么是包 包允许将类组合成较小的单元（类似文件夹），使其易于找到和使用相应的类文件 包有助于避免命名冲突。在使用许多类时，类和方法的名称很难决定。有时需要使用与其他类相同的名称。包基本上隐藏了类并避免了名称上的冲突 包允许在更广的范围内保护类、数据和方法，可以在包内定义类，而在包外的代码不能访问该类 二、声明包和使用包 我们可以在新建一个类的同时定义包。在Eclipse操作如下： ...
JAVA学习笔记————————
04-25
在深入探讨JAVA学习笔记之前，我们首先理解一下JAVA这一编程语言的重要性。JAVA，由Sun Microsystems公司（现已被Oracle收购）于1995年推出，是一种面向对象的、跨平台的编程语言，以其“一次编写，到处运行”的特性...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java Web学习笔记15——DOM对象
CCH2024的专栏
06-06 381
Java Web学习笔记
对象的的操作
qinhuaming的博客
04-04 526
对象的意义是用来存储数据以及编程。对象也称键值对，顾名思义是由属性名和属性值成对出现。 定义对象 直接定义： 在定义过程中，属性名与属性值之间通过冒号分隔，左侧是属性名，右侧是属性值，各个值之间用逗号分隔。 示例： 1 var obj = { 2 name:”张三”, 3 sex:”男”, 4 fn:function(){ 5 console.log(1); 6 } 7 } 点语法定义： 通过...
java第六章学习笔记:对象和类---java世界的细胞
Enetaunt的博客
03-12 454
【因为每一章都篇幅比较长（10多页，难免有的地方会写错字，如发现请指正，本人不胜感激）】 本章介绍面向对象理念以及如何通过类创建对象 6.1 面向对象概述 主要包括面向对象诞生，面向过程与面向对象程序设计思想的对比，面向对象技术的背景和特点； 提示：面向对象（Object Oriented简称oo）java是完全面向对象语言 6.1.1 面对对象程序设计思想的诞生 【对象不再仅仅与名词...
软件工程复习笔记——第七章 面向对象的设计方法
weixin_51206814的博客
12-10 1万+
第七章 面向对象的设计方法 7.1 面向对象的基本概念 面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统，交互式界面，分布式系统，网络管理结构和人工智能等领域。面向对象的技术已成为软件开发的一种新方法，新技术。 7.1.1 什么是面向对象的开发方法 面向对象的开发方法——OOSD法是一种把面向对象的思想应用于软件开发过程，指导开发活动的系统方法。 问题空间——软件系统所涉及到的应用领域和业务范围（现实世界）。 解空间——用于解决某些问题的软件系统。 一、软件开发过程 二、传统软件
类和对象
qq_45661125的博客
12-29 222
一.对象的初步认识 面向过程和面向对象的区别 C语言是面向过程的，关注的是过程，分析楚求解问题的步骤，通过函数调用逐步解决问题。 JAVA是面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互来完成。 面向过程注重的是过程，在整个过程中所涉及的行为就是功能。 面向对象注重的是对象，也就是参与过程中所涉及到的主体。这个主体中有一些相应的功能。 举例： 面向过程： 1.把冰箱打开 2. 把大象放入 3. 冰箱关起来 面向对象： 打开冰箱，储存，关闭都是对冰箱的操作，是冰箱的行为。冰箱就是一个对
python中类生成对象的操作叫做_深入 python 类和对象
weixin_39654067的博客
12-11 238
一，python 新式类和经典类的区别python 的新式类是2.2版本引进来的，通常将之前的类叫做经典类或者旧类。官方对新式类的解释是：为了统一类(class)和类型(type)，在 2.2 版本之前，类和类型是不同的，如下所示 a 是 class A的一个实例，那么a.class返回 ‘__main__.A‘，type(a)返回总是。而引入新类后，比如 class B是个新类，b是class...
Java面试题及答案2019版（上）
热门推荐
Java笔记
07-15 12万+
1、面向对象的特征有哪些方面？ 答：面向对象的特征主要有以下几个方面： 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。 继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继...
面向对象编程（包、类、对象）
yu的博客
03-03 728
类和对象的概念。类的构成（属性、方法、构造器、代码块、内部类）。对象的创建和使用
Python基础学习：类与对象
a_liang123的博客
03-30 265
一、初识类 1.在面向对象编程中，编写现实社会中的类，并基于类来创建一系列对象。根据类创建的对象称为实例化。 2.例如：人是一个类，具体的某个人就是一个对象。 3.python中，使用关键字**class**来定义类，类名首字母一般大写。 二、创建和使用类 代码示例1：创建一个Person类 class Person: def __init__(self,name,age): #__init__()为一个特殊方法，类中的函数称为方法。 #初始化姓名和年龄 se
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值