Java类和对象

最新推荐文章于 2023-09-21 14:36:43 发布
最新推荐文章于 2023-09-21 14:36:43 发布
阅读量331 收藏 11
点赞数 16
分类专栏： java基础语法 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53937197/article/details/121047058
版权

目录

1类和对象初始

2类和类的实例化

3类的成员

3.1字段/属性/成员变量

3.2方法

3.3static关键字

4封装

4.1private实现封装

4.2getter和setter方法

5构造方法

5.1基本语法

 5.2this关键字

6代码块

6.1什么是代码块

6.2普通代码块

6.3构造代码块

6.4静态代码块

7toString方法和匿名对象

7.1toString方法

7.2匿名对象

8内容重点总结及案例

8.1内容重点

8.2简单计算器

1类和对象初始

如果之前接触过c语言，我们知道c语言是面向过程的编程语言。所谓面向过程就是：注重于某件事情或者某个功能的实现的过程。将这些过程按照一定的逻辑连接起来去组成我们想要实现的效果。

而Java是面向对象的语言，相信学到这里，你一定听过Java中一切皆对象。那所谓面向对象就是：忽略某件事情或者某个功能实现的过程，更注重在实现的过程中谁应该干什么，将一个功能拆分为很多小的问题，每一类问题都有对应的一类对象来负责。最后合并不同对象所完成的功能达到我们想要的效果。

例如：

面向过程： 1. 把冰箱打开 2. 把大象放入 3. 冰箱关起来
面向对象： 打开冰箱，储存，关闭都是对冰箱的操作，是冰 箱的行为。冰箱就是一个对象，所以只要操作冰箱所具备的功能，都要定义在冰箱中。

2类和类的实例化

类是一类对象的统称，二对象就是这一类的实例化。

举个例子：

车的模型就是一个类，造出来的实体车就是一个对象，我们可以用这个车的模型构造出不同的车来。

总的来说，就是我类就是一个模型，对象就是我们依据这个模型构造出来的具体实例。我们可以根据这个模型构造出很多的实例。

声明一个类就是创建一个新的数据类型，在Java中属于引用类型，用class来声明。

基本语法

// 创建类
class <class_name>{  
    field;//成员属性
    method;//成员方法
}
// 实例化对象
<class_name> <对象名> = new <class_name>();
class 为 定义类的关键字， ClassName 为类的名字， {} 中为类的主体。
类中的元素称为：成员属性。类中的函数称为：成员方法。
示例代码： 
class Person{

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

注意事项：

注意这里的方法没有带static关键字，static关键字具体干什么的后面我们会谈到。

类的实例化：

类的实例化就是用类创建对象的过程。

1.类是一个模型一样的东西，限定了类中有哪些成员。

2.一个类可以实例化出很多对象，每个对象都是实际的物理空间来储存类的成员。

class Person{

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

    public static void main(String[] args) {

        Person person =new Person ();
        person.age=29;
        person.name="小明";
        System.out.println(person.age);
        System.out.println(person.name);
        person.eat();
        person.sleep();
    }

注意事项：

1.实例化一个对象用new关键字

2访问对象中的成员，用对象名.成员名的方式方式访问。

3。同一个类可以创建多个对象。

3类的成员

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

此处我们重点介绍前三个

3.1字段/属性/成员变量

在类中 , 但是方法外部定义的变量 . 这样的变量我们称为 " 字段 " 或 " 属性 " 或 " 成员变量 "。（三种称呼都可以）
代码示例： 
class Person{

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

    public static void main(String[] args) {

        Person person =new Person ();
        System.out.println(person.age);
        System.out.println(person.name);
    }



}

 注意事项：

1.访问属性的方式是：对象名.属性名的方式。

2访问包含两种概念，既有读也有写。（通俗来说就是既可以对属性的值进行使用，也可以对属性的值进行修改）

3一个对象的属性如果没有被设置初始值 ，那么会被设置一个默认的赤初始值。

默认初始值规则：

1数字类型的属性默认初始值是0.

2boolean类型的属性默认初始值是false。

3引用类型（String Array和自定义类型）的属的初始值是null。

那么久又有了一个新的问题，null是什么呢？

认识null

在Java中null就是空引用的意思，类似于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 int age=19;
   public String name="小明";

}
public class TestDemo{

    public static void main(String[] args) {

        Person person =new Person ();
        System.out.println(person.age);
        System.out.println(person.name);
    }



}

3.2方法

方法也是类的成员的一种，用于描述类的行为

例如：

class Person{

   public int age=19;
   public String name="小明";
   public void show(){
       System.out.println("name::"+name+"age::"+age);
   }

}
public class TestDemo{

    public static void main(String[] args) {

        Person person =new Person ();
        System.out.println(person.age);
        System.out.println(person.name);
        person.show();
    }
}

 show方法就是对对象的属性进行展示，不同的对象调用show方法就会显示出不同的属性内容。

3.3static关键字

static关键字

1.修饰属性

2修饰方法

3修饰代码块（本节最后介绍）

4修饰类（后面的章节中会介绍到）

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);
   }
}

普通成员变量和静态成员变量的内存分布

我们知道对象是类的实例化，类是一种自定义的类型，我们示例化出来的对象存在堆区，对象名是对象的引用，用来存储对象的地址，放在栈区，那么对象都有自己的普通属性这些属性存放在堆区。每实例化一个对象就会在堆区开开辟空间来存放这个对象的普通属性，而静态成员变量存放在方法区。所有对象都用这个静态变量。

图解：

 static修饰方法

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

    public int a;
    public static int count;
    public static void change(){
        count=10;
        //a=10; error a是普通成员变量 需要对象才能访问
    }
}
public class TestDemo{

    public static void main(String[] args) {
      Person.change();//无需对象就可以调用
        System.out.println(Person.count);
    }
}

注意事项：

1.因为静态的属性属于类所有只能在类中方法外定义。

2.静态的方法中不能直接使用非静态成员变量。

3.静态放法不能直接调用普通方法。

4封装

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

4.1private实现封装

public 和private两个关键字是表示”访问权限控制“

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岁

1.这样的的代码导致类的使用者在使用类的时候必须清楚类的实现，这样就使得类的使用者学习使用类的成本过高。

2.一旦类的实现这改变了代码(例如name改为myName），就会导致类的使用者的代码的大量改动。


为了解决这个问题，我们们可以将成员属性进行私有化，不让类的使用者直接访问，然后提供公共的接口供类的使用者使用。

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岁

这样一来我就可以直接调用公共的方法来实现使用类的属性。

同时如果类的实现者修改了字段的名字 , 类的调用者不需要做出任何修改 ( 类的调用者根本访问不到
name, age 这样的字段).
那么问题来了要是类的使用者要是修改了公共接口怎么办呢？
这种问题是有可能存在的，但是一般情况不会修改接口方法的代码，这是一种约定。一般类的设计，那么公共接口是不会改变的，库里面的更是如此。
注意事项：
private 不光能修饰字段 , 也能修饰方法
通常情况下我们会把字段设为 private 属性 , 但是方法是否需要设为 public,
就需要视具体情形而定 . 一般我们希 望一个类只提供 " 必要的 " public 方法 , 而不应该是把所有的方法都无脑设为 public.

4.2getter和setter方法

当字段被设置为private的时候我们就无法访问这个字段了，但是在实际使用中我们就需要用到这个字段，那怎么办呢？
这时候类就会为我们提供接口，供我们使用字段。

getter是获得这个字段内容，setter是设置这个字段的内容。

代码示例：

class Person{
    private int age;
    private String name;
    public int getAge(){
        return age;
    }
    public String getName(){
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class TestDemo{

    public static void main(String[] args) {
        Person person=new Person();
        person .setAge(19);
        person.setName("小明");
        System.out.println(person.getAge());
        System.out.println(person.getName());
    }
}

 这里我们用到了this。现在来介绍一下this，this就是代表当前对象的引用，后面会谈到具体的作用。

不是所有的字段都一定要提供 setter / getter 方法 , 而是要根据实际情况决定提供哪种方法 .
在 IDEA 中可以使用 alt + insert ( 或者 alt + F12) 快速生成 setter / getter 方法 . 

5构造方法

5.1基本语法

构造方法是一个特殊的方法，在使用关键字new实例化对象时被调用，用来给字段初始化。

new执行的过程：
1.为对象开辟空间

2.调用对象的构造方法

语法规则：
1.方法名和类名相同

2没有返回值类型声明。

3.每个类中至少有一个构造方法（没有时，编译器会自动帮我们生成一个无参的构造方法）。

注意事项：

如果类中没有构造方法，编译器就会自动帮我们生成一个没有参数的构造方法，

当类中有了构造方法，就不会自动生成构造方法。

构造方法可以重载，重载规则和普通方法一样。

示例代码：

class Person {
    private int age;
    private String name;

    //无参构造方法
    public Person() {

    }

    //带一个参数的构造方法
    public Person(int age) {
        this.age = age;

    }
   //带两个参数的构造方法
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
    public void show(){
        System.out.println("name="+name+" age="+age);
    }
}
public class TestDemo{

    public static void main(String[] args) {
        Person person1=new Person();//调用无参构造方法
        person1.show();
        Person person2=new Person(18);//调用一个参数的构造方法
        person2.show();
        Person person3=new Person(18,"小明");//调用两个参数的构造方法
        person3.show();
    }
}

 5.2this关键字

this关键字是指的当前对象的引用，也就是你正在使用的对象，你用A对象调用含有this的方法时，this就对象A的引用，你用B对象调用含有this的方法时，this就是B对象的引用。

this有三种用法（只能在类的内部使用）：

1.this.属性

2.this.方法

3this()注意这个只能存在于构造方法里面。而且是能出现在方法的第一行。

class Person {
    private int age;
    private String name;

    //无参构造方法
    public Person() {
        this(18);
      //  this(18,"小明");error 这里会报错，this()自只能在构造方法里面的第一行使用

    }

    //带一个参数的构造方法
    public Person(int age) {
        this.age = age;

    }
   //带两个参数的构造方法
    public Person(int age, String name) {
     //   this(19,"ahhah");this() error 只能在其他构造方法中使用
      this.age=age;
      this.name =name;
    }
    public void show(){
        System.out.println("name="+name+" age="+age);
    }
}

6代码块

字段的初始化方式有：
1. 就地初始化
2. 使用构造方法初始化
3. 使用代码块初始化
前两种方式前面已经学习过了 , 接下来我们介绍第三种方式 , 使用代码块初始化。

6.1什么是代码块

用{}包含的一段代码称为代码块。

代码块分为

普通代码块

构造代码块

静态代码块

6.2普通代码块

定义在方法中的代码块叫做，普通代码块。

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

这种方式使用的很少。

6.3构造代码块

构造块：定义在类中的代码块 ( 不加修饰符 ) 。也叫： 实例代码块 。构造代码块一般用于初始化实例成员变量。 
class Person {
    private int age;
    private String name;

    {
        this.age=19;
        this.name="小明";
        System.out.println("实例代码块");
    }
    //无参构造方法
     public Person() {
         System.out.println("构造函数");
    }
    public void show(){
        System.out.println("name="+name+" age="+age);
    }
}
public class TestDemo{


    public static void main(String[] args) {

        Person person=new Person();
    }
}

 实例代码块先于构造函数调用

6.4静态代码块

静态代码块：是用static修饰的代码块，用来给静态的成员变量初始化。


class Person {
    private int age;
    private String name;
    public static int count ;
//实例代码块
    {
        this.age=19;
        this.name="小明";
        System.out.println("实例代码块");
    }
    //静态代码快
    static{
        count=10;//静态代码块只能访问静态属性
        System.out.println("静态代码块");
    }
    //无参构造方法
     public Person() {
         System.out.println("构造函数");
    }
    public void show(){
        System.out.println("name="+name+" age="+age);
    }
}
public class TestDemo{


    public static void main(String[] args) {

        Person person=new Person();
        Person person1=new Person();
    }
}

注意事项 

1.静态代码块只能访问静态成员变量。

2.静态代码块只执行一次

3.在对象被构造的时候，首先执行静态代码块，然后执行实例代码块，最后执行构造函数。

7toString方法和匿名对象

7.1toString方法

之前的代码中我们要想输出对象的属性的内容需要自己去写代码输出。其实可以直接输出，就是toSring方法，我们现在就来讨论这种方法。

class Person {
    private int age;
    private String name;

}
public class TestDemo{


    public static void main(String[] args) {

        Person person=new Person();
        System.out.println(person);
    }

我们一直说引用存放的是对象的地址，那么这里输出的就是对象的地址。以字符串的形式输出出来。

 

我们按住ctrl点击println看源码可以发现，println实际是调用了一个toString方法，帮我们实现的输出。其实这个方法可以自己去写，规定怎样输出。这种方式叫做重写（具体后面的额章节中讨论）。


class Person {
    private int age;
    private String name;
    public Person(){

    }
    public Person(int age){
        this.age=age;
    }
    public Person(int age, String name){
        this.age=age;
        this. name=name;
    }
    public String toString(){
        return  "name="+name+"  age="+age;
    }

}
public class TestDemo{


    public static void main(String[] args) {

        Person person=new Person(19,"小明");
        System.out.println(person);
    }
}

 注意事项：

toString 方法会在 println 的时候被自动调用 .
将对象转成字符串这样的操作我们称为 序列化 .
IDEA 快速生成 Object 的toString方法快捷键 Alt+  f12(Insert)

7.2匿名对象

匿名对象顾名思义，就是没有名字的对象

没有引用的对象称为匿名对象 .
匿名对象只能在创建对象时使用 .
如果一个对象只是用一次 , 后面不需要用了 , 可以考虑使用匿名对象 

class Person {
    private int age;
    private String name;
    public Person(){

    }
    public Person(int age){
        this.age=age;
    }
    public Person(int age, String name){
        this.age=age;
        this. name=name;
    }
    public String toString(){
        return  "name="+name+"  age="+age;
    }

}
public class TestDemo{


    public static void main(String[] args) {


        System.out.println(new Person(19,"小明"));
    }
}

8内容重点总结及案例

8.1内容重点

一个类可以产生无数的对象，类就是模板，对象就是具体的实例。
类中定义的属性，大概分为几类：类属性，对象属性。其中被 static 所修饰的数据属性称为类属性 , static 修饰的 方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。
静态代码块优先实例代码块执行，实例代码块优先构造函数执行。
this 关键字代表的是当前对象的引用。并不是当前对象。

8.2简单计算器

编写一个类 Calculator, 有两个属性 num1,num2, 这两个数据的值，不能在定义的同时初始化，最后实现加减乘除四种运算 
import java.util.Scanner;

class Calculator {
    private int num1;
    private int num2;

    public Calculator() {

    }

    public Calculator(int num1, int num2) {
        this.num1 = num1;
        this.num2 = num2;
    }

    public int add() {

        return num1 + num2;
    }

    public int minus() {
        return num1 - num2;
    }

    public int multi() {
        return num1 * num2;
    }

    public int method() {
        return num1 / num2;
    }

}

public class TestDemo {
    public static void menu(){

        System.out.println("1加法"+"     2减法");
        System.out.println("3乘法"+"     4除法");
    }
    public static void main(String[] args) {
        menu();
        System.out.println("请输入你的选择");
        int input=0;
        Scanner scanner=new Scanner(System.in);
        input=scanner.nextInt();
        int a=0;
        int b=0;
        System.out.println("请输入你要计算的数");
        a=scanner.nextInt();
        b=scanner.nextInt();
        Calculator calculator=new Calculator(a,b);
        switch(input){
            case 1:
                System.out.println("a+b="+calculator.add());
                break;
            case 2:
                System.out.println("a-b="+calculator.minus());
                break;
            case 3:
                System.out.println("a*b="+calculator.multi());
                break;
            case 4:
                System.out.println("a/b="+calculator.method());
                break;
            default:
                break;
        }

    }
}

 

 

零零星星枫叶梦
关注
  • 16
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
java类和对象原理与用法分析
08-25
`this`关键字表示本类对象，用于区分成员变量和局部变量。例如： ```java public class MyClass { private int x; public void myMethod() { int x = 10; this.x = x; // 使用this关键字区分成员变量和局部变量...
java类和对象.ppt
06-04
定义类、属性和方法 创建并使用对象、对象和引用 Java方法的参数传递机制 方法的重载 实现良好的封装 构造方法的作用和构造方法重载
Java培训：类、接口作为参数和返回值详解
最新发布
Blue92120的博客
09-21 1129
1.类作为方法参数时，说明要向方法中传入该类的对象2.类作为方法返回值时，说明该方法要返回一个该类的对象。3.抽象类作为方法参数时，说明要传入一个实现抽象类所有抽象方法的子类对象。4.抽象类作为方法返回值时，说明需要返回一个实现抽象类所有抽象方法的子类对象。5.接口作为方法参数时，说明该方法要传入一个接口实现类对象。6.接口作为方法返回值时，说明该方法需要返回一个接口实现类对象。本文版权归黑马程序员Java培训学院所有，欢迎转载，转载请注明作者出处。作者：黑马程序员Java培训学院。
类
qq_36690502的博客
09-27 165
package person; /*创建类*/ public class person {       //创建类person String name; String sex; int age;                //定义类中的三个属性 void getInfo(String n,String s,int a) {   //创建方法getInfo(),获取类pers
阿里云【名师课堂】Java面向对象开发48 ~ 50：代码块
Love Letter
06-12 137
阿里云【名师课堂】Java面向对象开发48 ~ 50：代码块48、普通代码块定义在方法中的代码块。49、构造块定义在类中的代码块。50、静态代码块使用static关键字定义的代码块。在非主类中在主类中总结 现阶段代码块并不是一个重点概念，作为结构清楚一下就好。 所谓代码块指的是使用{}定义的一段程序代码，而代码块根据其定义的位置以及声明的关键字的不同一共可以分为四类：普通代码块、构造块、静态块、同步代码块。 同步代码块在多线程部分讲解。 48、普通代码块 定义在方法中的代码块。 范例：观察一个简单程序
java 抽象类中构造函数的作用
weixin_44627672的博客
04-17 3113
#抽象类 毋庸置疑抽象类中可以定义构造函数，但是这时会有一个疑问，既然抽象类的实例化毫无意义那为何又要定义其自己的构造函数呢？ 首先，可以通过其内部的构造函数初始化其内部的变量。 其次，可以通过实现它的子类通过super（）调用其内部构造函数。实质上就是调用父类构造函数初始化自己的成员变量。 在此附上两张图大家更好地理解一下。 ...
#Java学习#习题三
热门推荐
vircorns的博客
05-25 1万+
文章目录判断题单选题函数题写出派生类构造方法（Java）根据派生类写出基类（Java）人口统计编程题通过键盘输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数数组元素交换集体评分jmu-Java-03面向对象基础-01-构造函数与toString 判断题 单选题 函数题 写出派生类构造方法（Java） 裁判测试程序样例中展示的是一段定义基类People、派生类Student以及测试两个类的相关Java代码，其中缺失了部分代码，请补充完整，以保证测试程序正常运行 函数接口定义: 根提示： 观察类
Java类和对象之间的差
12-22
java类和对象之间的差别是一个普遍的问题，刚开始学习java当它来到与类和对象接触。来总结一下它们之间的差异。 　先说说class和object差异。事实上，词：object是全部class的父类，全部class类都默认继承object。 ...
javaDuiXiang.zip_Java类和对象
09-24
Java类和对象源码,Java实用教程的类和对象源码
java类和对象
04-12
java类和对象
Java类和对象入门级实例代码
03-16
内容索引:Java源码,初学实例,学习实例　Java类和对象入门级实例源代码，并不多，仅五个小例子，主要是将输入的三个员工对象的数据赋值给职工数组、掷一个六面骰子6000次的程序、Java简单好用的Calendar日历。...
全面理解Java类和对象
09-02
下面小编就为大家带来一篇全面理解Java类和对象。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java类和对象练习题.docx
09-30
java类和对象练习题.docx
java类和对象实验
04-10
java编程 类和对象实现例子 包含抽象类 构造函数 继承 等
JAVA类和对象
01-15
对JAVA学习中的类和对象进行详细介绍，很好的编程学习资料
#Java学习#习题五
vircorns的博客
06-30 8718
文章目录判断题单选题填空题123456程序填空题12编程题jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company字符串反转图书价格汇总数组元素交换 其他JAVA学习的内容见：目录 判断题 1-1.java语言中不用区分字母的大写小写。 F 1-2.在Java程序中，可以使用private来修饰一个类。 T 1-3.接口中的方法默认是public abstract方法。 T 1-4.一个类可以实现多个接口。 T 1-5.异常也
java练习 不对之处请斧正
th18711313263的博客
03-27 1041
不定项选择 1、错误的是： A、覆盖包括成员方法的覆盖和成员变量的覆盖                                 错 分析：覆盖 (override)：也叫重写，就是在当父类中的某些方法不能满足要求时，子类中改写父类的方法。当父类中的方法被覆盖了后，除非用super关键字，否则就无法再调用父类中的方法了。 发生覆盖的条件： 1、“三同一不低” 子类和父类的方法名称，
JavaSE学习总结第08天_面向对象3
diaoji9561的博客
05-15 123
08.01 工具类中使用静态 例: 1 class ArrayTool 2 { 3 //将构造方法私有，外界不能创建该类的对象 4 private ArrayTool(){} 5 //遍历数组 6 public static void print(int[] arr) 7 { 8 Syst...
Java学习（6）—— 面向对象2（对象的基本特征）
Archer__13的博客
10-10 177
面向对象的基本特征：封装、继承、多态 一. 封装性 将类的属性私有化(private)，提供公共(public)的方法来设置(set)和获取(get)该属性的值。 public class PersonTest { public static void main(String[] args){ Person person = new Person(); person.name = "Tom"; //person.age ...
java类和对象练习
09-03
Java类和对象的练习可以帮助我们理解和掌握面向对象的编程思想和技巧。通过实践，我们可以加深对类和对象的理解，并能够灵活应用于实际项目中。在实际项目中，类和对象是编写高质量、可维护和可扩展代码的基础。所以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值