JavaSE · 类与对象 · 面向对象概念 · 类的实例化 · 类的成员（字段，属性，方法）· 封装private · 构造方法this · 代码块 · 匿名对象

已于 2023-02-11 13:33:57 修改
阅读量122 收藏
点赞数 1
分类专栏： JavaSE 文章标签： java 前端 jvm
于 2022-09-15 19:47:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sfg0861/article/details/126871223
版权

一、类与对象的初步认知.

C 语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
Java 是面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。
面向对象注重的是对象，也就是参与过程所涉及到的主体，是通过逻辑将一个个功能实现连接起来。

面向对象概念

  1. 面向对象是思考问题的一种思考方式，是一种思想。
  2. 类就是一类对象的统称。对象就是这一类具体化的一个实例。
  3. 面向对象的好处，将复杂的事情变简单了，只要面对一个对象即可。

面向对象设计

面向对象设计把握一个重要的经验：谁拥有数据，谁对外提供操作这些数据的方法！

开发时：找对象，建对象，用对象，并且维护对象之间的关系。

后期学习过程中，我们会就这三点进行深入学习。

简而言之

面向对象就是用代码（类）来描述客观世界事务的一种方式.
一个类主要包含一个事务的属性和行为.

二、类和类的实例化

类就是一类对象的统称。对象就是这一类具体化的一个实例。

举个例子：我们建房子的图纸就是一个类，而通过这个图纸建设出的新房子就是一个实体（对象、实例）。一个模子可以实例化无数个对象。 一张图纸，可以建设无数个房子。

总的来说：类就是一个模板，对象是由模板产生的样本。一个类可以产生无数个对象。

声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型，Java 使用关键字 class 来声明类。我们来简单声明一个类↓

基本语法

// 创建类
class <class_name>{ 
	field;//成员属性
	method;//成员方法
}

// 实例化对象
<class_name> <对象名> = new <class_name>();

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。
类中的元素称为：成员属性。类中的函数称为：成员方法。

示例

class Person{
	//成员属性
    public int age;
    public String name;
    public String sex;
    
    //成员方法
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}

注意事项
类和方法的定义还是不一样的，内部的成员方法不带 static 关键字.

类的实例化

使用类类型来创建对象的过程，称为类的实例化

  1. 类只是一个模型一样的东西，限定了类有哪些成员.
  2. 一个类可以实例化出很多对象，实例化出的对象，占用实际的物理空间（存储类成员变量）.

示例

class Person{
    public int age;
    public String name;
    public String sex;
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}

public class Test01 {
    public static void main(String[] args) {
        //通过new实例化对象
        Person person = new Person();
        //成员方法的调用，需要通过对象的引用调用
        person.eat();
        person.sleep();
        //一份图纸可以实例化多个对象
        Person person1 = new Person();
        Person person2 = new Person();
    }
}

//输出结果
吃饭
睡觉

注意事项

  1. new 关键字用于创建一个对象的实例.
  2. 使用 “.” 来访问对象中的属性和方法.
  3. 同一个类可以创建多个实例.

三、类的成员

类的成员可以包含以下：字段、方法、代码块、内部类和接口等.

我们主要介绍前三个.

字段/属性/成员变量

在类中，方法外部定义的变量.
这样的变量，我们称为 “字段” 或 “属性” 或 “成员变量”.

用于描述一个类中包含哪些数据.

class Person{
    public int age;
    public String name;
    public String sex;
}

public class Test01 {
    public static void main(String[] args) {
        //通过new实例化对象
        Person person = new Person();
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

//执行结果
null
0

注意事项

  1. 使用 “ . ” 访问对象的字段.
  2. “访问”，既包含读，也包含写.
  3. 一个对象的字段，如果没有显式设置初始值，那么会设置一个默认值.
  4. 默认值规则，数字类型默认值为 0，boolean 类型默认值为 false，引用类型（String，Array，自定义类）默认值为 null.

认识null
null 在 Java 中为“空引用”，表示不一样任何对象，类似于 C 语言的空指针.
如果对 null 进行 “ . ” 操作，会引发空指针异常.

class Person {
	public String name;
	public int age;
}

class Test {
	public static void main(String[] args) {
		Person person = new Person();
		System.out.println(person.name.length());  // 获取字符串长度
	}
}

// 执行结果
Exception in thread "main" java.lang.NullPointerException

字段就地初始化
很多时候，我们可以显式地设定初始值.

class Person {
	public String name = "张三";
	public int age = 18;
}

class Test {
	public static void main(String[] args) {
    	Person person = new Person();
	    System.out.println(person.name);
	    System.out.println(person.age);
	}
}

// 执行结果
张三
18

方法（method）

用于描述一个对象的行为( Person 类的 eat 方法，sleep 方法).

class Person {
	public int age = 18;
	public String name = "张三";
 
	public void show() {
		System.out.println("我叫" + name + ", 今年" + age + "岁");
	}
}

class Test {
	public static void main(String[] args) {
    	Person person = new Person();
    	person.show();
	}
}

// 执行结果
我叫张三, 今年18岁

此时的 show 方法，表示 person 这个对象具有一个“自我展示”的行为.
这样的 show 方法是和 person 实例相关联的.
如果创建了其它实例，那么 show 的行为也会发生改变.

Person person2 = new Person();
person2.name = "李四";
person2.age = 20;
person2.show()
 
// 执行结果
我叫李四, 今年20岁

static 关键字

可以用于修饰属性、修饰方法、代码块、修饰类.

修饰属性

Java 静态属性和类相关，和具体的实例无关.
换句话说，同一个类的不同实例共用一个静态属性.

class TestDemo{
  public int a;
  public static int count;
}

public class Main{
	public static void main(String[] args) {
	    TestDemo t1 = new TestDemo();
	    t1.a++;
	    TestDemo.count++;
	    System.out.println(t1.a);
	    System.out.println(TestDemo.count);
	    System.out.println("============");
	    TestDemo t2 = new TestDemo();
	    t2.a++;
	    TestDemo.count++;
	    System.out.println(t2.a);
	    System.out.println(TestDemo.count);
 	}
}

//输出结果：
1
1
============
1
2

count 被 static 所修饰，所有类共享。
不属于对象，访问方式为：类名.属性

修饰方法

如果在任何方法上应用 static 关键字，此方法称为静态方法.

  • 静态方法属于类，而不属于类的对象.
  • 可以之间调用静态方法，无需创建类的实例.
  • 静态方法可以访问静态数据成员，并且可以改变静态数据成员的值.
class TestDemo{
	public int a;
	public static int count;
	public static void change() {
		count = 100;
    	//a = 10; error 不可以访问非静态数据成员
	}
}

public class Main{
	public static void main(String[] args) {
    	TestDemo.change()；//无需创建实例对象 就可以调用
    	System.out.println(TestDemo.count); 
 	}
}

//输出结果
100

注意事项 ：静态方法和实例无关，而是和类相关. 因此导致了两个情况：

  1. 静态方法不能之间使用非静态数据成员或调用非静态方法（非静态数据成员和方法都是和实例相关的）.
  2. this 和 super 两个关键字不能在静态上下文使用（this 是当前实例的引用，super 是当前实例父类实例的引用，也是和当前实例有关）.

小结
实在记不住 static 关键字的具体效果，我们就直接记着：

  1. 带有 static 关键字的数据，都是在 Java 程序运行一开始就执行的代码.
  2. static 的变量和方法在内存中一块叫方法区的内存块，每个 static 都只存在一份.

四、封装

什么是封装？
<<代码大全>> 开篇就在讨论一个问题: 软件开发的本质就是对程序复杂程度的管理. 如果一个软件代码复杂程度太高, 那么就无法继续维护. 如何管理复杂程度? 封装就是最基本的方法.

在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者.

封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.

private 实现封装

private / public 这两个关键字表示 “访问权限控制”.

  • public 修饰的成员变量或者成员方法，可以直接被类的调用者使用.
  • private 修饰的成员变量或者成员方法，不能被类的调用者使用.

直接使用 public

class Person {
	public String name = "张三";
	public int age = 18;
}

class Test {
	public static void main(String[] args) {
    	Person person = new Person();
    	System.out.println("我叫" + person.name + ", 今年" + person.age + "岁");
	}
}

// 执行结果
我叫张三, 今年18岁

这样有什么缺点？
这样的代码导致类的使用者(main方法的代码)必须要了解 Person 类内部的实现, 才能够使用这个类. 学习成本较高
一旦类的实现者修改了代码(例如把 name 改成 myName), 那么类的使用者就需要大规模的修改自己的代码, 维护成本较高.


使用private封装属性
并且提供 public 方法供类的调用者使用.

class Person {
	private String name = "张三";
	private int age = 18;
	
	public void show() {
		System.out.println("我叫" + name + ", 今年" + age + "岁");
	}
}

class Test {
	public static void main(String[] args) {
		Person person = new Person();
		person.show();
	}
}

// 执行结果
我叫张三, 今年18岁

  • 此时字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用. 而需要借助 show 方法. 此时类的使用者就不必了解 Person 类的实现细节.

  • 同时如果类的实现者修改了字段的名字, 类的调用者不需要做出任何修改(类的调用者根本访问不到 name, age这样的字段).

注意事项

  • private 不光能修饰字段，也能修饰方法.
  • 通常情况下我们会把字段设为 private 属性, 但是方法是否需要设为 public, 就需要视具体情形而定. 一般我们希望一个类只提供 “必要的” public 方法, 而不应该是把所有的方法都无脑设为 public.

getter 和 setter 方法

当我们使用 private 来修饰字段的时候，就无法直接使用这个字段了.

代码示例

class Person {
	private String name = "张三";
	private int age = 18;
	public void show() {
		System.out.println("我叫" + name + ", 今年" + age + "岁");
	}
}

class Test {
	public static void main(String[] args) {
		Person person = new Person();
		person.age = 20;
		person.show();
	}
}

// 编译出错
Test.java:13: 错误: age可以在Person中访问private

如果此时需要获取或者修改这个 private 属性，就需要使用 getter / setter 方法.

代码示例

class Person {
	private String name;//实例成员变量
	private int age;
	
	public void setName(String name){
		//name = name;//不能这样写
		this.name = name;//this引用，表示调用该方法的对象
	}
	public String getName(){
		return name;
	}
	
	public void show(){
		System.out.println("name: "+name+" age: "+age);
	}
}

public static void main(String[] args) {
	Person person = new Person();
	
	person.setName("caocao");
	String name = person.getName();
	
	System.out.println(name);
	person.show();
}

// 运行结果
caocao
name: caocao age: 0

注意事项

  • getName 即为 getter 方法，表示获取这个成员的值.
  • setName 即为 setter 方法，表示设置这个成员的值.
  • 当 set 方法的形参名字和类中的成员属性的名字一样的时候，如果不使用 this，相当于自赋值. this 表示当前实例的引用.
  • 不是所有字段都需要提供 setter / getter 方法，而是要根据实际情况决定提供哪种方法.

五、构造方法

基本语法

构造方法是一种特殊方法，使用关键字 new 实例化新对象时会被自动调用，用于完成初始化操作.


new 执行过程

  • 为对象分配内存空间
  • 调用对象的构造方法

语法规则

  • 方法名称必须与类名称相同
  • 构造方法没有返回值类型声明
  • 每一个类中至少存在一个构造方法

注意事项

  • 如果类中没有提供任何构造方法，那么编译器会默认生成一个不带有参数的构造方法.
  • 类中定义了构造方法，则默认的无参的构造方法将会无效.
  • 构造方法支持重载，规则和普通方法的重载一致.

代码示例

class Person {
	private String name;//实例成员变量
	private int age;
	private String sex;
	
	//默认构造函数 构造对象
	public Person() {
		this.name = "caocao";
		this.age = 10;
		this.sex = "男";
	}
	//带有3个参数的构造函数
	public Person(String name,int age,String sex) {
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
		
	public void show(){
		System.out.println("name: "+name+" age: "+age+" sex: "+sex);
	}
}

public class Main{
	public static void main(String[] args) {
		Person p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
		p1.show();
		Person p2 = new Person("zhangfei",80,"男");//调用带有3个参数的构造函数
		p2.show();
	}
}

// 执行结果
name: caocao age: 10 sex: 男
name: zhangfei age: 80 sex: 男

this 关键字

this 表示当前对象的引用（注意不是当前对象）.
可以借助 this 来访问对象的字段和方法.

class Person {
	private String name;//实例成员变量
	private int age;
	private String sex;
	//默认构造函数 构造对象
	public Person() {
		//this调用构造函数
		this("bit", 12, "man");//必须放在第一行进行显示
	}
	//这两个构造函数之间的关系为重载。
	public Person(String name,int age,String sex) {
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public void show() {
		System.out.println("name: "+name+" age: "+age+" sex: "+sex);
	}
}

public class Main{
	public static void main(String[] args) {
		Person person = new Person();//调用不带参数的构造函数
		person.show();
	}
}

// 执行结果
name: bit age: 12 sex: man

我们会发现在构造函数的内部，我们可以使用 this 关键字，构造函数时用来构造对象的，对象还没有构造好，我们就使用 this，那 this 还代表当前对象吗？

当然不是，this 代表的时当前对象的引用。

六、认识代码块

字段初始化的方式有：

  1. 就地初始化.
  2. 使用构造方法初始化.
  3. 使用代码块初始化.

前两种我们都介绍过了，接下来我们学习下代码块初始化.

什么是代码块

使用 { } 定义的一段代码.

根据代码块定义的位置以及关键字，又可以分为以下四种：
1. 普通代码块
2. 构造块
3. 静态快
4. 同步代码块

普通代码块

定义在方法中的代码块.

public class Main{
	public static void main(String[] args) {
		{ //直接使用{}定义，普通方法块
			int x = 10 ;
			System.out.println("x1 = " +x);
		}
		int x = 100 ;
		System.out.println("x2 = " +x);
	}
}

// 执行结果
x1 = 10
x2 = 100

这种用法比较少见.


构造代码块

定义在类中的代码块，也叫：实例代码块。
构造代码块一般用于初始化实例成员变量。

class Person{ 
	private String name;//实例成员变量
	private int age;
	private String sex;
	
	public Person() {
		System.out.println("I am Person init()!");
	}
	//实例代码块
	{
		this.name = "bit";
		this.age = 12;
		this.sex = "man";
		System.out.println("I am instance init()!");
	}
	public void show(){
		System.out.println("name: "+name+" age: "+age+" sex: "+sex);
	}
}

public class Main {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.show();
	}
}

// 运行结果
I am instance init()!
I am Person init()!
name: bit age: 12 sex: man

注意事项： 实例代码块优先于构造函数执行.


静态代码块

使用 static 定义的代码块。一般用于初始化静态成员属性

class Person{
    private String name;
    private int age;
    private String sex;
    private static int count = 0;
    public Person(){
        System.out.println("I am Person init()!");
    }
    
    {
        this.name = "aaa";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }
    
    static{
        count = 10;
        System.out.println("I am static init()!");
    }
    
    public void show(){
        System.out.println("name: " + name);
        System.out.println("age: " + age);
    }
}

public class Test01{
    public static void main(String[] args) {
        Person person = new Person();
        Person person1 = new Person();
    }
}

//执行结果
I am static init()!
I am instance init()!
I am Person init()!
I am instance init()!
I am Person init()!

注意事项

  • 静态代码块不管生成多少个对象，只会执行依次，且是最先执行的.
  • 执行顺序是：静态代码块、构造代码块、构造方法.

七、补充说明

toString 方法

我们刚刚把对象的属性进行打印的时候，都自己实现了 show 方法 ↓

class Person {
	private String name;
	private int age;
	public Person(String name,int age) {
		this.age = age;
		this.name = name;
	}
	public void show() {
		System.out.println("name:"+name+" " + "age:"+age);
	}
}

public class Main {
	public static void main(String[] args) {
		Person person = new Person("caocao",19);
		person.show();
		//我们发现这里打印的是一个地址的哈希值 原因：调用的是Object的toString方法
		System.out.println(person);
	}
}

// 执行结果
name：caocao age：19
Person@1c168e5

其实我们不必每次都自定义 show 方法，可以使用 toString 这样的方法来将对象自动转成字符串.

代码示例

class Person {
	private String name;
	private int age;
	
	public Person(String name,int age) {
		this.age = age;
		this.name = name;
	}
	
	public void show() {
		System.out.println("name:"+name+" " + "age:"+age);
	}
	
	//重写Object的toString方法
	@Override
	public String toString() {
		return "Person{" +
		"name='" + name + '\'' +
		", age=" + age +
		'}';
	}
}

public class Main {
	public static void main(String[] args) {
		Person person = new Person("caocao",19);
		person.show();
		System.out.println(person);
	}
}

// 执行结果
name：caocao age：19
Person{name='caocao', age=19}

注意事项

  • toString 方法会在 println 的时候被自动调用.
  • 将对象转成字符串这样的操作，我们称为 序列化.
  • toString 是 Object 类提供的方法，我们自己创建的 Person 类默认继承自 Object 类，可以重写 toStirng 方法实现我们自己版本的转换字符串方法.

匿名对象

匿名只是表示没有名字的对象.

  • 没有引用的对象称为匿名对象.
  • 匿名对象只能在创建对象时候使用.
  • 如果一个对象只使用依次，可以考虑使用匿名对象.

代码示例

class Person {
	private String name;
	private int age;
	public Person(String name,int age) {
		this.age = age;
		this.name = name;
	}
	public void show() {
		System.out.println("name:"+name+" " + "age:"+age);
	}
}

public class Main {
	public static void main(String[] args) {
		new Person("caocao",19).show();//通过匿名对象调用方法
	}
}

// 执行结果
name：caocao age：19

八、内容重点总结

  • 一个类可以产生无数的对象，类就是模板，对象就是具体的实例.
  • 类中定义的属性，大概分为几类：类属性，对象属性。其中被 static 所修饰的数据属性称为类属性，static 修饰的方法称为类方法，特点是不依赖于对象，我们只要通过类名就可以调用其属性或者方法.
  • 静态代码块优先实例代码块执行，实例代码块优先构造函数执行.
  • this 关键字代表的是当前对象的引用，并不是当前对象.
牧濑红莉栖cc
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java面向对象和工具类
06-26
java 面向对象的重难点知识以及常用的工具类的使用
JAVASE.面向对象(1)
12-22
面向对象基础内容1面向对象的概念1.1类的定义格式1.2如何通过类创建对象1.3封装1.3.1封装的步骤1.4构造器1.4.1构造器的作用1.5this关键字1.6匿名对象2继承2.1继承的概念2.2继承的含义2.3继承的好处2.4类的继承格式...
Java new一个对象的过程中发生了什么：类加载过程、创建对象过程
HD243608836的博客
09-03 1306
需要注意的是，每个子类对象持有父类对象的引用，可在内部通过super关键字来调用父类对象，但在外部不可访问补充：通过实例引用调用实例方法的时候，先从方法区中对象的实际类型信息找，找不到的话再去父类类型信息中找。如果继承的层次比较深，要调用的方法位于比较上层的父类，则调用的效率是比较低的，因为每次调用都要经过很多次查找。这时候大多系统会采用一种称为虚方法表的方法来优化调用的效率。
Java基础了解-01-基础语法/对象和类/基本数据类型/变量类型
Xiaowu2048的博客
03-15 445
基础语法/对象和类/基本数据类型/变量类型
有关于在Java 类的静态初始化块中创建一个自身实例的问题。
lang_m的专栏
12-12 1986
有关于在Java 类的静态初始化块中创建一个自身实例的问题。class a{ static {...} //1 static {...} //2 static {new a()} //3 static {...} //4}这会造成什么样的静态初始化块执行顺序那？4是否应该在3之前执行那？这个问题在JVM的规范中有说明，对应这里的解释就是线程在3部分要初始化a时会发现当前线程正在初始化这个
【Java】类和对象详解
最新发布
qq_61635026的博客
06-15 5926
面向对象（Object-oriented）是一种程序设计的方法和编程范式，它以对象作为程序的基本单位，通过封装、继承、多态等概念来组织和实现程序逻辑。面向对象的编程思想强调将问题分解为对象的集合，每个对象具有自己的状态（属性）和行为（方法），并通过相互之间的消息传递来实现协助和交互。类（Class）是用来对一个实体（对象）进行描述的，主要包括实体（对象）的属性和行为的描述。在Java语言中，类是面向对象编程的基本组织单位，它是对象的模版或者蓝图，描述了对象的属性和行为。
Java——类和对象（对象与类）
W20223161730的博客
01-11 657
java类和对象总结——墙裂推荐
西安云工厂xaygc.com_JavaSE_04类与对象_旺旺老师
09-22
学习java,讲的很不错
5-JavaSE之面向对象编程-类与对象（上）1
08-03
5-JavaSE之面向对象编程-类与对象（上）1
JavaSE之StringBuilder类与String类
07-21
这个文件里的内容适合Java初学者，String类为引用类，不属于基本数据类型，但是String类非常的重要，在后边学习的JavaSE中，几乎使用的全是String类，这个文件里边包含了对String字符串的拆分、拼接以及怎么声明进行...
类与对象-java实验报告
06-22
实验目的及要求 1) 熟悉Java中类的设计； 2) 设计类的数据域与方法； 3) 设计类与类之间的关系 4）使用设计的类 实验内容 对平面几何中的各种基本图形使用面向对象的设计方法建模，需要设计的类包括：点、直线、三角形、矩形、正方形、圆形、椭圆；设计这些类的数据域和方法；设计类与类之间的关系；使用这些设计的类进行基本的运算。
类与对象实验报告
10-20
1、掌握类的定义和使用，编写构造方法及成员方法。 2、能够创建类的实例，掌握对象的声明和不同访问属性的成员访问方式。 3、会定义接口、实现接口。
java类与对象（超详细！）
weixin_51976923的博客
10-27 2583
java笔记之类与对象，超详细！必读好文！
java基础 — new关键字的使用
个人博客
09-20 7945
Java中使用 new关键字 加上 构造方法，来创建一个对象。 下面是一个名为Cat的类： public class Cat { public Cat() { System.out.println("这是构造方法"); } } 使用new + 构造方法 来创建一个对象。 那么也就是Cat c = new Cat(...
java类和对象的详解
weixin_55079859的博客
06-15 1505
java类和对象的详解
面向对象实验 ——（二）类与对象
我们都有光明的未来
08-07 1083
以前的博客： C++ 构造函数+析构函数+函数参数的传递 C++ 模块累积的理解 一、实验目的及要求 内容： （1）定义一个具体的类（如Point类），该类应包含构造函数、析构函数； （2）定义一个组合类（如Line类），该组合类应该含有（1）中所定义的基本类内嵌对象，定义该组合类的构造及析构函数； （3）利用所定义的组合类实现一定的具体功能。 要求：（ 1）掌握对象与类的基本概念、定义与使用； ...
python--类和对象
Hao_python的博客
05-12 245
类 : 具有相同的属性和方法的对象的集合 .它定义了该集合中每个对象所共有的属性和方法。对象: 万物皆对象.类和对象的关系 : 类是对象的模板; 对象是类的实例.语法:  class   类名:class Myclass: """一个简单的类实例""" i = 12345 #属性 def f(self): #方法 return 'hello ...
java实验类与对象_JAVA类与对象实验报告
weixin_39758618的博客
02-20 922
《面向对象程序设计》实验报告实验三、类与对象(1)课程代码：1H10500学分：6实验类型：实践型实验学时：4个学时实验时间：2017.10.12 实验地点：5407班级：计算机164 专业：计算机科学与技术专业学号：2016011147 姓名：林文辉一、实验目的(1)掌握类和对象(2)理解封装(3)会创建和使用对象(4)会定义和使用类的方法(5)理解变量作用域二、实验内容及步骤内容：定义学校类、...
实验14 类和对象
lvcongying0601的博客
12-11 369
实验14 类和对象 一、实验目的和要求 （1）掌握类、类的数据成员、类的成员函数的定义方法。 （2）掌握构造函数的定义方法和执行过程。 （3）掌握类成员的public和private访问属性的区别及用法。 （4）掌握对象的定义方法及对成员函数的调用方法。 二、实验内容和步骤 定义一个正方形类，类中有1个私有数据成员和四个公有成员函数（1个无参构造函数、1个有参构造函数、求面积的area函数、求...
javase编写一个通用方法,实现对任意类的对象的任意方法的调用
05-26
这个通用方法名为callMethod，接收三个参数：对象obj、方法名methodName和方法参数args。该方法的返回值类型为Object，因为它可以用来调用任意类的任意方法，所以返回值类型也需要是通用的。 在方法内部，首先通过...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值