Java:面向对象

最新推荐文章于 2024-06-20 15:02:17 发布

发发是只呆头鹅

最新推荐文章于 2024-06-20 15:02:17 发布

阅读量72

点赞数

分类专栏： JavaSE 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_44888950/article/details/121052306

版权

JavaSE 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章目录

1 面向对象

我们都知道C语言是面向过程的，C++,Java等语言是面向对象的，那么这两者之间有什么区别呢？来举一个洗衣服的例子：

面向过程：把衣服放在盆中->加入洗衣液->加水->揉洗->换水漂洗->洗好了

面向对象：把衣服和洗衣液放入洗衣机中->洗好了

我们可以看出来，面向过程注重的是过程，而面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来，衣服、洗衣液、洗衣机都可以称为是对象。

2 类与对象

类就是一类对象的统称。

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

所以我们经常会听到一句话：类实例化后就得到了对象，即类是抽象的，对象是具体的。一个类可以生成无数个对象，如果这么说还是有点抽象的话，那我们来举个例子：现在有鞋这么一个类，由这个类我们可以实例化出很多对象，如：运动鞋、休闲鞋、皮鞋等等。

3 类的成员

类的成员有：字段（成员变量）、方法、代码块、内部类和接口等等。

初识面向对象，这里只介绍前面三个。

3.1 字段

字段又可以称为属性、成员变量。我们来看代码：

public class Test {
    public String name = "ccc";
    public int age;

    public static void main(String[] args) {
        Test test = new Test();
        test.name = "abc";
        test.age = 20;
        System.out.println(test.name);
        System.out.println(test.age);
    }
}

输出如下：

abc
20

在Test类下的name、age就被称为属性或成员变量，我们可以在创建的时候给其赋值，也可以在main方法中赋值或修改其值，但是在调用成员变量的时候需要用对象去调用，即用new出来的test对象才能对其进行调用。

注意事项：

在成员变量没有赋值之前，会有一个默认值.
对于各种数字类型，其默认值为0.
对于boolean类型，其默认值为false.
对于String等引用类型，默认值为null.

对于null而言：

null在Java中为”空引用“，意思是不指向任何对象，如果对其进行操作，就会出现异常（空指针异常）。

3.2 方法

方法用于描述一个对象的行为，我们来看下面代码：

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

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

输入为：

我叫张三，我今年18岁

其中的show，我们就称为方法，想要调用方法，还是需要创建对象，方法可以满足某种行为，我们还可以根据具体的需要去设置方法的返回类型，传入的参数等等。

3.3 static关键字

修饰成员变量
修饰方法
修饰代码块
修饰类

3.3.1 修饰成员变量

被static修饰的成员变量称为静态成员变量，存放在方法区，又叫静态区，而普通的成员变量是存放在堆区的，局部变量存放在栈区。我们来看看普通的成员变量和静态成员变量有什么区别：

public class Test {
    public int a;
    public static int b;

    public static void main(String[] args) {
        Test test1 = new Test();
        test1.a++;
        test1.b++;
        System.out.println(test1.a);
        System.out.println(test1.b);
        System.out.println("-------------------");
        Test test2 = new Test();
        test2.a++;
        test2.b++;
        System.out.println(test2.a);
        System.out.println(test2.b);
    }
}

输出如下：

1
1
-------------------
1
2

究其原因，普通成员变量是存放在堆区的，在每new一个新的对象时，都会给该对象在堆区开辟一片新的空间用来存放成员变量a，然后未初始化的成员变量值是0，所以test1和test2在调用之前，a的值都为0，调用后都为1，刚刚我们说过static修饰的成员变量是存放在方法区的，静态成员变量是属于类的，我们调用它的时候完全可以不用new对象，并且它在方法区中只有一份，每次调用的都是唯一的那一份，所以后面test2调用b的时候，b的值会变成2。

3.3.2 修饰方法

同上，被static修饰的方法我们就称为静态方法。

静态方法属于类，不属于类的对象
可以直接调用静态方法，不需要创建对象
静态方法可以访问静态数据成员，并可以更改静态数据成员的值

来看代码：

public class Test {
    public int a;
    public static int b;

    public static void change(){
        b = 100;
        //a = 10;  报错，不可以访问非静态成员变量
    }

    public static void main(String[] args) {
        Test.change();
        System.out.println(b);
    }
}

输出为：

我们可以看出static修饰的方法和普通方法的区别，至于如何去使用，就需要结合具体的情况。

static修饰代码块和类在此处先不作陈述。

4 封装

4.1 private封装

private/ public 这两个关键字表示 “访问权限控制”。我们来看看这两者的区别：

直接使用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岁

使用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.show(); 
 } 
}

输入为：

我叫张三, 今年18岁

对于成员变量，其实我们根本不需要知道，也不需要关注一个类都有哪些 private 的成员。从而让类调用者以更低的成本来使用类。并且使用public修饰成员变量其维护成本也会更高，用private进行封装后其可行性更佳。

4.2 getter和setter方法

当我们使用 private 来修饰成员变量的时候, 就无法直接使用这个成员变量了。而我们想要使用它，无非就是想给它赋值或得到其值，在Java中为了解决这个问题，引入了getter和setter方法。

public class Test {
    private String name;
    private int age;

    public void setName(String name){
        this.name = name;
    }
    public String  getName(){
        return this.name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return this.age;
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.setName("张三");
        System.out.println(test.getName());
        test.setAge(18);
        System.out.println(test.getAge());
    }
}

输入为：

张三
18

其中的getName和getAge即为getter方法，表示获取这个成员的值，setName和setAge即为setter方法，表示设置这个成员的值。

注意事项：

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

5 构造方法

5.1 基本语法

构造方法是一种特殊方法，在new一个对象的时候会自动调用，用于完成初始化操作。

new执行过程

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

规则

方法名必须与类名相同
构造方法没有返回值类型
每个类中至少有一个构造方法（如果不定义的话系统会自动生成一个无参构造）
若定义了构造方法，则默认的无参构造就没有了
构造方法支持重载，和普通方法的重载一样

public class Test {
    private String name;
    private int age;

    public Test(){
        System.out.println("这是无参构造");
    }
    public Test(String name){
        this.name = name;
    }
    public Test(String name,int age){
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {
        Test test = new Test();
        Test test1 = new Test("张三");
        System.out.println(test1.name);
        System.out.println(test1.age);
        Test test2 = new Test("张三", 18);
        System.out.println(test2.name);
        System.out.println(test2.age);
    }
}

输出为：

这是无参构造
张三
0
张三
18

从输出可以看出，在new对象时，会根据传入参数的个数自动找到对应的构造方法。

5.2 this关键字

this表示当前对象引用，而不是当前对象，可以借助this来访问对象的成员变量和方法。

public class Test {
    private String name;
    private int age;

    public Test(){
        this("张三",18);  //this调用构造方法
    }
    public Test(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void show(){
        System.out.println("我叫" + name + "，今年" + age + "岁");
    }

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

输入为：

我叫张三，今年18岁

6 代码块

代码块可以分为四种：

普通代码块
构造代码块
静态代码块
同步代码块

6.1 普通代码块

定义在方法中的代码块就称为普通代码块。

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

这种用法无较大意义。

6.2 构造代码块

定义在类中的代码块就称为构造代码块，一般用于初始化成员变量。

public class Test {
    private String name;
    private int age;
    //构造代码块
    {
        this.name = "张三";
        this.age = 18;
        System.out.println("构造代码块");
    }
    public void show(){
        System.out.println("我叫" + name + "，今年" + age + "岁");
    }

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

输出为：

构造代码块
我叫张三，今年18岁

6.3 静态代码块

也是在类中定义，一般用于初始化静态成员变量。和构造代码块用法类似，要在{}前面加上static关键字修饰。

注意事项：

静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。

发发是只呆头鹅

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java:面向对象

文章目录1 面向对象2 类与对象3 类的成员3.1 字段3.2 方法3.3 static关键字3.3.1 修饰成员变量3.3.2 修饰方法4 封装4.1 private封装4.2 getter和setter方法5 构造方法5.1 基本语法5.2 this关键字6 代码块6.1 普通代码块6.2 构造代码块6.3 静态代码块1 面向对象我们都知道C语言是面向过程的，C++,Java等语言是面向对象的，那么这两者之间有什么区别呢？来举一个洗衣服的例子：面向过程：把衣服放在盆中->加入洗衣液-&gt
复制链接

扫一扫