java中的类和对象

于 2021-11-04 21:18:56 发布
阅读量82 收藏
点赞数
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60391870/article/details/121132202
版权

java中的类和对象

前言

“思考”这一行为在早期似乎是一种无用的。作为虚拟世界的原始人的我，已经能用数据类型、逻辑语句、方法、以及数组来制作工具了，于是我开始去思考。回想现实世界中“概念”，所为“概念”就是将具有大多相同属性的实物抽象成一个类别。例如“人”这个概念，就是从具有相同物种属性，社会属性作为实物的我们中抽象出来的。再例如，“电器”，也是从具有相同物理属性，功能属性的电力产品中抽象出来的集合。然后我们从属于“电器”的类别中再拿出一个冰箱或者电视出来。
但是在虚拟世界中只能自己去创造，即定义“类”。然后在从类中拿出实例化的对象出来用。就如同我在电器中拿出来一个冰箱一样。

一、面向对象

  • 面向对象：说白了就是从我们定义的类中拿出具有多种具体属性，然后组合在一起实例化出一个对象或者多个对象，再然后通过这些对象彼此交互完成工作。就像我在电器类中买了显示屏，买了主机，然后主机与显示屏连接做成电脑。

  • 思考：我是否能从不同的类中拿出不同的对象，彼此交互完成工作呢？例如从人这类别中拿出一个叫“张三”的人和从电器类中拿出“电脑”，让张三与电脑去交互写代码呢？

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

二、创建类

// 创建类
class <class_name>{  
    field;//成员变量
    method;//成员方法
    ......;//代码块
    ......;//内部类
    ......;//接口
}
// 实例化对象
<class_name> <对象名> = new <class_name>();

1 、类中包含什么？

类中所包含的是一些“引用”很类似于“指针”，在使用它们时再创建出“对象”。

  • 成员变量
  • 方法
  • 代码块
  • 内部类
  • 接口
    以下将重点介绍前三种。

（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
  • 认识 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 at  Test.main(Test.java:9)
  • 成员变量就地初始化
    很多时候我们不希望字段使用默认值, 也可以设定初值.
class Person {
    public String name = "张三";
     public int age = 18; }

（2）方法

  • 就是在类中定义的方法（函数）用于描述一个对象的行为/功能。
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();
        Person person2 = new Person();
        person2.name = "李四";
        person2.age = 20;
        person2.show()
   }
}
// 执行结果
我叫张三, 今年18岁
我叫李四, 今年20岁
  • 构造方法
    a、 在实例化对象的时候会被自动调用到的方法, 方法名字和类名相同, 用于对象的初始化.
    b、虽然我们前面已经能将属性就地初始化, 但是有些时候可能需要进行一些更复杂的初始化逻辑, 那么就可以使用构造方法.
    c、使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作
    d、规则：类似于重载
    方法名称必须与类名称相同
    构造方法没有返回值类型声明
    每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）
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: 男

（3）代码块

  • 普通代码块：定义在方法中的代码块，直接用{ }定义普通代码块。
  • 构造代码块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量
  • 静态代码块：使用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 = "张三"; 
 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+" 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: 张三 age:12 sex：男
  • 静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
    静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。

三、更好的使用类。

  • 如图：由上文总结在这里插入图片描述为了跟好的运行上面这张图，接下来将介绍在一些关键词来使用。

1、static 关键字：

正如它的中文释义，“静态的”，也就是说在类中被它修饰的成员变量、方法、代码块和内部类都是静止的。因为被其修饰的东西都会存放在方法区中。
如图：在这里插入图片描述

（1）修饰成员变量

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   // 被static修饰的变量仍然为1
2

（2）修饰方法：无需创建实例对象 就可以调用

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

2、this关键字

this表示当前在类中对“对象"的引用 ，（即在类里面使用一个类的对象，且不用去实例化。）
例如：

class Person { 
 private String name;//实例成员变量
 private int age; 
 private String sex; 
 
 //默认构造函数 构造对象
 public Person() { 
 //this调用构造函数
 this("张三", 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: 张三 age: 12 sex: man

2、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(); 
 } 
}
  • 当给别人这个人类时，他不能直接使用，类的调用者(main方法中)不能直接使用. 而需要借助 show 方法. 此时类的使用者就不必了解 Person 类的实现细节.
  • private 不光能修饰字段, 也能修饰方法

3、使用封装

被人用了我的类，但是这人有需要一定要获取或者修改这个 private 修饰的属性和方法时, 就需要使用 getter / setter 方法

（1）setter / getter 方法

  • 即为：创建/获取
    直接上代码
class Person { 
 private String name;//实例成员变量
 private int age; 
 public void setName(String name){  //创建name的接口
 //name = name;//不能这样写
 this.name = name;//this引用，表示调用该方法的对象
 } 
 public String getName(){  //获取name的接口
 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

结语：

本篇主要以我自己的理解记得还算人话的笔记，若有错误，望批评指正。谢谢

Henry Jekyll
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值