初识Java类和对象

最新推荐文章于 2022-05-22 00:08:29 发布
最新推荐文章于 2022-05-22 00:08:29 发布
阅读量1.1k 收藏 15
点赞数 32
分类专栏： java学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46078890/article/details/109143977
版权

类和对象

1. 类与对象的初步认知

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。
面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来。

简而言之

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

2.类和类的实例化

类就是一类对象的统称。对象就是这一类具体化的一个实例。
总的来说：类相当于一个模板，而对象是由模板产生的样本。一个类可以产生无数的对象。
声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型，Java 使用关键字 class 来声明类。我们来看以下简单的声明一个类。

基本语法：
//创建类
class 类名{  
    field;//成员属性/变量
    method;//成员方法
}
// 实例化一个对象
类名 对象名 = new 类名();

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

类的实例化：

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

  1. 类只是一个模型一样的东西，限定了类有哪些成员。
  2. 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。
  3. 类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。
    代码示例：
class Student {
	//成员属性 实例变量
    public int age;
    public String name;
    public String sex;
    //成员方法
    public void eat() {
       System.out.println("吃饭!");  
   }
    public void sleep() {
       System.out.println("睡觉!");  
   }
    public void study(){
       System.out.println("上学!");  
   }
}
public class Demo{
 public static void main(String[] args) {
        Student student = new Student();//通过new实例化对象
        student.eat();//成员方法调用需要通过对象的引用调用 使用"."操作符
        student.sleep();
        student.study();
        //产生对象        实例化对象 开辟空间
        Student student2 = new Student();
        Student student3 = new Student();
 }
}
运行结果：
吃饭!
睡觉!
上学!
注意：
  1. new关键字用于创建一个对象的实例。
  2. 使用 . 来访问对象中的属性和方法。
  3. 同一个类可以创建多个实例。
3.类的成员

类的成员可以包含以下：字段、方法、代码块、内部类和接口等。
此处我们重点介绍前三个。

3.1字段/属性/成员变量

在类中, 在方法外部定义的变量。这样的变量我们称为 “字段” 或 “属性” 或 “成员变量”(三种称呼都可以, 一般不会严格区分)。
用于描述一个类中包含哪些数据：

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);
        System.out.println(person.age)
   }
}
//执行结果
null
0

//空引用
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
         at Test.main(Test.java:9)
注意：
  1. 使用 . 访问对象的字段，访问既包括读，也包括写。
  2. 对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值。
  3. null在java中为"空引用"，表示不引用任何对象。类似于C语言中的空指针。如果对null 进行**.** 操作就会引发异常。

默认值规则：

  1. 对于各种数字类型，默认值为0.
  2. 对于boolean类型，默认值为false。
  3. 对于引用类型(String，Array，以及自定义类)，默认值都为null。
字段就地初始化

很多时候我们不希望字段使用默认值, 而是需要我们显式设定初值. 可以这样写：

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
3.2方法(method)

就是我曾经总结过的方法，用于描述一个对象的行为。
详情参考 java中方法的使用 ，这里不做详细介绍，要注意的一点是如果在类中定义普通成员方法，不用加static关键字。
这里的方法是和这个类相关联的，如果创建了其他实例，那么方法的行为就会发生变化。
要注意的是方法中还有一种特殊的方法称为构造方法 ，在实例化对象时会自动调用。有些时候可能需要进行一些更复杂的初始化逻辑，那么就可以使用构造方法用于对象的初始化。

3.2构造方法(重要)
3.2.1 基本语法

构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作。
new 执行过程：

  1. 为对象分配内存空间。
  2. 调用对象的构造方法。(完成对象的创建)

语法规则：

1.方法名称必须与类名称相同
2.构造方法没有返回值类型声明
3.每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）
calss Person {
  public Person() {
  	//默认构造函数
  }
}
代码示例：
class Person{
	public int age;
	public String name;
	Person(){
		System.out.println("无参构造函数");
	}
	Person(int age,String name){
		System.out.println("带有2个参数的构造函数");
		this.age = age;
		this.name = name;	
	}
	Person(int age){
		System.out.println("单参构造函数");
		this.age = age;
	}
	public void show(){ 
		 System.out.println("name: "+this.name+" age: "+this.age); 
		 }
}
public class test {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.show();
		Person p2 = new Person(18,"张三");
		p2.show();
		Person p3 = new Person(20);
		p3.show();
	}
}
//运行结果：
如果在定义了带参构造函数的情况下， 而又没有自己定义无参构造函数。创建p1会抛出异常
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The constructor Person() is undefined
	at practice.test.main(test.java:26)
	
在都定义的情况下，创建p1、p2、p3结果是：
无参构造函数
name: null age: 0
带有两个参数的构造函数
name: 张三 age: 18
单参构造函数
name: null age: 20
注意事项：
  1. 如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数。
  2. 若类中定义了构造方法，则默认的无参构造将不再生成。
  3. 构造方法支持重载，规则和普通方法的重载一致。
3.2.2 this关键字

细心的同学已经发现，带有参数的构造函数中出现了this关键字。那么，这个this代表的是当前对象的引用(注意不是当前对象)，在类中，可以借助this来访问对象的字段和方法。
代码示例：

class Person{
	public int age;
	public String name;
	//默认构造函数    构造对象
	Person(){
		//this调用构造函数
		this(12);//必须放在第一行，不然编译不通过
		System.out.println("无参构造函数");
	}
	//这三个构造函数之间的关系为重载。
	Person(int age,String name){
		System.out.println("带有两个参数的构造函数");
		this.age = age;
		this.name = name;	
	}
	Person(int age){
		System.out.println("单参构造函数");
		this.age = age;
	}
	public void show(){ 
		 System.out.println("name: "+this.name+" age: "+this.age); 
		 }
}
public class test {
	public static void main(String[] args) {
		Person p4 = new Person(); //调用不带参数的构造函数
		p4.show();	
	}
}
//运行结果：
单参构造函数
无参构造函数
name: null age: 12

在类中，this是隐藏的关键字，但是提倡写代码的时候带上。我们发现，构造函数是用来构造对象的，对象还没有构造好，我们就使用了this，在这里this不是代表的当前对象，而是当前对象的引用。

4.static关键字
4.1修饰属性

static修饰的成员变量是不属于对象的，和具体的实例无关，换句话说，同一个类的不同实例共用一个静态属性。
代码示例：

class Person{
    public int a;
    public static int count; 
 }
 public class test {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.a++;
		Person.n++;
		System.out.println(p1.a);
		System.out.println(Person.n);
		System.out.println("================");
		Person p2 = new Person();
		p2.a++;
		Person.n++;
		System.out.println(p2.a);
		System.out.println(Person.n);		
	}
}
//运行结果：
1
1
============
1
2

代码内存解析：
n被static所修饰，所有类共享，且不属于对象，访问方式为：类名 . 属性。

4.2修饰方法

如果在任何方法上应用 static 关键字，此方法称为静态方法。
静态方法属于类，而不属于类的对象。可以直接调用静态方法，而无需创建类的实例。静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

代码示例：
class Person{
    public int a;
    public static int n; 
    public static void show() {
    	n = 1;
    	//a = 0; error 静态方法中不能访问非静态成员
    }
 }
  public class test {
	public static void main(String[] args) {
		Person.show(); //无需创建实例对象，直接用类名进行调用
		System.out.println(Person.n);	
	}
}
//运行结果：
1
注意事项：
  1. 静态方法不能调用非静态方法，反之可以。
  2. 静态方法内，不能访问非静态成员变量。
  3. 普通的成员方法不能定义静态成员变量，但是可以访问。
  4. main方法是静态的，因为如果是普通方法，要依赖于对象的调用，而想要调用main方法要执行test.main(); ，要执行这一句，必然要先进入main方法中，但是没有人调用，所以说没办法执行。所以main方法是静态方法。
    在这里插入图片描述
4.3小结
  1. 静态成员变量虽然可以通过已实例化的对象来调用，但会有警告，正确的调用方式是直接使用类名来调用。
  2. 所有被static修饰的方法或者属性，全部不依赖于对象。
  3. java 中使用局部变量一定要先初始化。
5.封装(重要)

在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者。封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了。这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度，提高开发效率。

5.1 private实现封装

private/ public 这两个关键字表示 “访问权限控制” 。
public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用。
private 修饰的成员变量或者成员方法, 不能被类的调用者使用。
换句话说, 类的使用者根本不需要知道, 也不需要关注一个类都有哪些 private 的成员. 从而让类调用者以更低的成本来使用类。

直接使用public：
public String name = "张三";
 public int age = 18;

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

范例：
private String name = "张三"; 
private int age = 18;

使用 private 封装属性, 并提供 public 方法供类的调用者使用。通常情况下，我们会把字段设置为private属性，但是方法是否需要设为public，就需要视情况而定，一般我们希望一个类只提供必要的public方法，而不应该把所有方法都设置为public。

5.2 getter 和setter方法

当我们使用 private 来修饰字段的时候, 就无法直接使用这个字段了。
此时如果需要获取或者修改这个 private 属性，就需要使用getter 和setter方法。

class Person{
	private int age;
	private String name;
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
public class test {
	public static void main(String[] args) {
		Person p = new Person();
		p.setAge(18);
		p.setName("lisi");
		System.out.println(p.getAge());
		System.out.println(p.getName());
	}
}
//运行结果：
18
lisi
注意事项：
  1. getName 即为 getter 方法, 表示获取这个成员的值。
  2. setName 即为 setter 方法, 表示设置这个成员的值。
  3. 当set方法的形参名字和类中的成员属性的名字一样的时候，如果不使用this, 相当于自赋值。 this 表示当前实例的引用。
  4. 不是所有的字段都一定要提供 setter / getter 方法, 而是要根据实际情况决定提供哪种方法。
  5. 我们自己可以写setter / getter 方法，也可以根据自己的编译器选项快速生成。
6.代码块

字段的初始化方式有：

  1. 就地初始化
  2. 使用构造方法初始化
  3. 使用代码块初始化
    前两种方式前面已经学习过了, 接下来介绍第三种方式，使用代码块初始化。
6.1什么是代码块

使用 {} 定义的一段代码.
根据代码块定义的位置以及关键字，又可分为以下四种：
普通代码块
构造块
静态块
同步代码块(这里不做解释，后面学到再谈)

6.2普通代码块

普通代码块：定义在方法中的代码块。

public class test{ 
 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

这种用法比较少见。

6.3构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

class Person{ 
 private String name;//实例成员变量
 private int age; 
 private String sex; 
 
 public Person() { 
 System.out.println("无参构造函数!"); 
 } 
 
 //实例代码块
 { 
 this.name = "zhangsan"; 
 this.age = 12; 
 this.sex = "man"; 
 System.out.println("实例代码块"); 
 }
 public void show(){ 
 	System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
 }
 public class test { 
 public static void main(String[] args) { 
 	Person p1 = new Person(); 
	 p1.show(); 
 } 
}
// 运行结果
实例代码块! 
无参构造函数! 
name: zhangsan age: 12 sex: man

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

6.4静态代码块

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

class Person{
 	private String name;//实例成员变量
 	private int age; 
 	private String sex; 
 	private static int n = 0;//静态成员变量 由类共享数据 方法区
 	public Person() { 
 System.out.println("无参构造函数!"); 
 } 
 //静态代码块
 static { 
 	n = 10;//只能访问静态数据成员 
 	System.out.println("静态代码块!"); 
 }
public class test { 
	 public static void main(String[] args) { 
 		Person p1 = new Person(); 
 		Person p2 = new Person();
 } 
}
// 运行结果
静态代码块
无参构造函数
无参构造函数
注意事项：
  1. 静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
  2. 静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。
7.序列化和匿名对象
7.1 toString方法

我们刚刚注意到，我们在把对象的属性进行打印的时候，都自己实现了show函数，其实，我们大可不必。接下来我们看一些示例代码：

public class test {
	public static void main(String[] args) {
		Person p1 = new Person();
		System.out.println(p1);
	
	}
}
运行结果：
Person@7852e922 //这里打印的是一个地址的哈希值 ，原因调用的是object的toString方法

那么此时就需要重写toString这个方法：

class Person { 
 private String name; 
 private int age; 
 public Person(String name,int age) { 
 this.age = age; 
 this.name = name; 
 } 
 //重写Object的toString方法
 @Override  //表示该方法已经被重写
 public String toString() { 
 return "Person{" + 
 "name='" + name + '\'' + 
 ", age=" + age + 
 '}'; 
 } 
}
public class test {
	public static void main(String[] args) {
		Person p1 = new Person("zhangsan",18);
		System.out.println(p1);
	}
}
运行结果：
Person{name='zhangsan', age=18}

注意事项：

  1. toString 方法会在 println 的时候被自动调用。
  2. 将对象转成字符串这样的操作我们称为序列化。
  3. toString是Object 类提供的方法, 我们自己创建的 Person 类默认继承自 Object类, 可以重写 toString 方法实现我们自己版本的转换字符串方法。
  4. @Override 在 Java 中称为 “注解”, 此处的 @Override 表示下面实现的 toString 方法是重写了父类的方法。
  5. 我们自己可以重写toString 方法，也可以根据自己的编译器选项快速生成。
7.2匿名对象

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

  1. 没有引用的对象称为匿名对象.
  2. 匿名对象只能在创建对象时使用.
  3. 如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象.
代码示例：
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("lisi",19).show();//通过匿名对象调用方法
 } 
}
//运行结果：
name：lisi age：19

优点: 只使用一次
缺点：每次使用都要 new 类名(); 来创建一个对象。

na小子叫坚强
关注
  • 32
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
Java-初识类和对象
weixin_44378053的博客
02-09 219
理解对象和类 写代码是为了解决客观生活中的问题，代码就注定要和现实中的“物体”打交道，就需要使用代码把现实中的“物体”表示出来，这个物体也就是Java中的对象；而现实中的物体可能非常复杂，我们需要通过抽象的方式，把复杂的物体变得简单一些，根据需要，只提取一些比较核心的信息到代码中，这个提取出来的信息就是Java中的类。Java中的类像C语言中的结构体一样，也是一种用户自定义类型，但是类功能相比...
JAVA基础面向对象之多态、抽象类、内部类、接口、方法参数和返回值以及内部类
weixin_42478671的博客
04-17 263
1多态 1.1多态概念 多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。 多态就是允许方法重名 参数或返回值可以是父类型传入或返回。 举例： Cat c=new Cat(); Animal a=new Cat(); 猫可以是猫的类型。猫 ...
初识Java的类和对象
Helltaker的博客
07-19 152
类、对象、属性和方法之间的关系及使用面向对象的开发方法结构化开发面向对象开发（OOP）对象的特征属性方法类与对象的关系Java中的使用Java类模板如何创建和使用对象方法方法的返回值方法调用 面向对象的开发方法 Java语言是一种面向对象的语言，比较符合人类认识现实世界的思维方式。与之相对的有结构化开发。 结构化开发 面向功能划分软件结构 自顶而下 最小的子系统是方法 制约了软件的可维护性和可扩展性 面向对象开发（OOP） 把软件系统看成各种对象的集合 系统结构较稳定 子系统相对独立 软件可重用性、可
初识java中的类和对象
每天努力一点点
11-17 111
多种多样的语言： 面向过程(处理规模小的问题）：C 面向对象(处理规模大的问题)：JAVA,C++…(一共三步：找对象，创建对 象，适用对象) 面试题： 说出oop语言的三大特征oop(Object-Oriented-…面向对象编程) 答：继承、封装、多态 类？ 对象？ 类就是一类对象的统称。对象就是这一类具体化的一个实例。 一个类可以实例化多个对象（用new） 一个类生成一个class...
初识Java（Java类和对象-对象)
jsl-空零之旅
04-20 242
一、对象    Java 是一门面向对象的程序设计语言，对象时由类抽象出来的，所有的问题都通过对象来处理，对象可以操作类的属性和方法解决相应的问题，所以了解对象的产生、操作和消亡是必要的。    1.1  对象的创建    对象可以认为是在一类事物中出现出来的某一特例，可以通过这个特例来处理这类事物出现的问题。在 Java 语言中通过 new 操作符来创建对象。每实例化一个对象就会自动调用一次构造...
Java语言初识——类与对象
chirengreng的博客
01-28 626
一、面向对象编程    面向过程：吃狗屎      面向对象：狗吃屎 二、类与对象 类：    模板，规定了该类所具有的属性和方法； 对象：  类的一个实例；
Java学习，面向对象之初识类与对象
weixin_44253162的博客
10-31 113
类和对象的概念： 类 类是一个范围，一个指向，一个比较抽象的形象，类是一类事物的抽象概念，它不指代某一个具体的事物，而是将这一类事物所具有的特点进行抽取，然后形成一个带有范围指向性的概念。 对象 对象就是某一类中的具体的指代，表示的是一个实实在在的具体的事物。由类生成对象的过程叫做实例化。 在使用类与对象时，要学会找出对象的属性与方法； 例如：家中养的宠物 属性：它的名字，它的性别，年龄，体重等等； 方法：它能跑，能撒娇，能吃，能喝；这些是行为属于方法 ...
对象的使用（3，4）
fx2278642759的博客
05-22 100
1）static与单例模式（设计模式的一种） 2)const成员函数 3）const对象 4）mutable 保证一个类中只有一个实例，并提供一个全局访问点. #include <iostream> using namespace std; class Singleton { public: static Singleton* GetInstance() //获取实例的访问点 { if (instance_ == NULL) { instance_ = ne
java创建2参构造器,第2项：当面临多个参数的构造器时考虑使用构建器
weixin_32211137的博客
03-15 328
静态工厂和构造器有个共同的局限性：他们都不能很好地扩展到大量的可选参数。考虑用一个类表示包装食品外面显示的营养成分标签。这些标签中有几个域是必需的：每份的含量、每罐的含量以及每份的卡路里，还有超过20个可选域：总脂肪、饱和脂肪量、转化脂肪、胆固醇、钠等等。大多数产品在某几个可选域中都会有非零的值。对于这样的类，应该采用哪种构造器或者静态方法来编写呢？程序猿一向习惯采用重叠构造器(telescopi...
Java学习（5）—— 面向对象1（类和对象）
Archer__13的博客
10-07 987
面向对象的基本特征：封装、继承、多态。 一. 类和对象 1. 类和对象的创建步骤 （1）创建类，设计类的成员（属性、方法）； （2）实例化类的对象（创建类的对象）：类名 对象名 = new 类名； （3）调用对象的属性（对象名 . 属性），调用对象的方法（对象 . 方法） public class PersonTest { public static void main(String[] args){ Person perso...
The constructor Employee(String, int) is undefined这个怎么解决啊！我是新手麻烦能讲解的
wowxwa的博客
11-13 7551
**这是一个集成类的题目，这是题目要求：**定义名为Employee的父类和两个名为Manager和Salesman的子类。各个类中均需要自己定义相应的构造方法，用来初始化对象,子类构造方法中调用父类的构造完成对父类成员的初始化；Employee包含2个属性和一个方法，属性为name，basic（基本工资），方法show(),用于显示这些属性的值。Manager类有一个称为department（部...
关于The constructor Student(int, String, int, char) is undefined报错问题与简单解决办法
hdkczkl的博客
10-25 2万+
刚刚写代码时遇到这个问题，困扰了一会会，所以把解决办法写出来供大家参考。 其实这个是一个非常简单基础的问题： 我的报错页面是这样的： 这里显示我没有这个Student的有参构造函数，这时候我需要在Student类中增加构造函数。 这里有一个便捷方法可以增加构造函数： 在需要增加构造函数的页面右击—》进行选择（如图） 然后就会生成这样的构造函数 注意：**一定要保存后重新运行界面才能实现！*...
错误：Implicit super constructor xx() is undefined for default constructor.
热门推荐
关于代码的那些事
10-31 4万+
错误：Implicit super constructor xx() is undefined for default constructor. Must define an explicit constructor 因为你的父类已经定义了一个有参的构造函数，此时编译器不会为你调用默认的构造函数， 当子类继承时，必须在自己的构造函数显式调用父类的构造函数，自己才能确保子类在初始化前父类
The constructor Date() is undefined
unique_cn的博客
08-01 3240
import java.sql.Date; public class Zuoy1 {     public static void main(String[] args) {                  Date date = new Date();//错误The constructor Date() is undefined         long l = date.getTime()...
public void setName(String name)
u012402926的专栏
07-11 6698
public void setName(String name) { 　　this.name = name; 　　} 　　public int getAge() { 　　return age; 　　} 　　public void setAge(int age) { 　　this.age = age; 　　} 　　public void cry(){ 　　System.out.p
java实验3_java 实验3 继承+多态
weixin_39864489的博客
02-12 1235
实验3 继承与多态**类可以实现多个接口 但只有单继承！**1、继承1)、继承语法class子类名extends父类{}2)、构造函数(通过source即可得到)注意： 当子类实例化，首先调用父类构造函数，其次调用子类本身构造函数3)、函数重载:简单来说 相同函数名 参数需求不同 在调用时自动寻找匹配的函数4)、覆盖问题override子类重写了一个从父类继承过来的函数与属性---当使用时就直接...
易错的JAVA笔试题
wys0127的博客
04-17 926
需求：阅读下面程序，并给出程序的运行结果 。 public class Test01 { public static void main(String[] args) { new B(); } } class B extends A{ int x = 5; public B(){ run(); } public void run(){ System.out.println(x); } } class
定义一个有关学生的Student类,内包含成员变量:String name，String sex，int age,所有的变量必须为私有的(private).(Java)
spursping的博客
07-03 8175
package spurs_ping; import java.util.Scanner; /*定义一个有关学生的Student类,内包含成员变量:String name，String sex，int age,所有的变量必须为私有的(private). 1.编写有参的构造函数:能对name,sex,age赋值. 2.覆盖toString函数: 按照格式:类名[name=,sex=,age=]输出.使用idea自动生成,然后修改成该输出格式 3.对每个属性生成setter/getter方法
类和对象的实现
weixin_34292924的博客
03-20 88
#include<iostream> usingnamespacestd; intmain() { inti1=1; doubled1=3.21; cout<<"int->"<<i1<<endl<<"double->"<<d1<<endl; sys...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值