Java基础（面向对象、类的定义、对象的创建和使用）

最新推荐文章于 2024-04-21 01:09:21 发布

赤沐

最新推荐文章于 2024-04-21 01:09:21 发布

阅读量617

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_45673369/article/details/102575454

版权

文章目录

认识面向对象
对象的创建和使用
封装的概述

认识面向对象

面向过程和面向对象的区别

面向过程和面向对象有什么关系呢？面向过程其实是最为实际的一种思考方式，就算是面向对象的方法也是含有面向过程的思想。可以说面向过程是一种基础的方法。它考虑的是实际地实现。一般的面向过程是从上往下步步求精。面向对象主要是把事物给对象化，对象包括属性与行为。当程序规模不是很大时，面向过程的方法还会体现出一种优势。因为程序的流程很清楚，按着模块与函数的方法可以很好的组织。但对于复杂而庞大的系统来说，面向过程显得就很无力了。

    使用面向对象编程思想开发系统，在现代开发中会将面向对象贯穿
整个过程，一般包括：
OOA/OOD/OOP：
① OOA：面向对象分析（Object-Oriented Analysis）
② OOD：面向对象设计（Object-Oriented Design）
③ OOP：面向对象编程（Object-Oriented Programming）

面向对象具有三大特征：

① 封装（Encapsulation）
② 继承（Inheritance）
③ 多态（Polymorphism）

那么什么是面向对象思想呢？

就是把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。
这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。

面向对象思想特点
a:是一种更符合我们思想习惯的思想懒人思想
b:可以将复杂的事情简单化
c:将我们从执行者变成了指挥者

面向对象开发就是不断的创建对象，使用对象，指挥对象做事情。

类

类和对象的概念

生活实例
面向过程：洗衣服：换下脏衣服—盛水----浸泡------手搓----漂清—晾干
面向对象：全自动洗衣机----------- 一键洗衣

我们学习编程是为了什么？
我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。
那么我们如何描述现实世界事物

举例: 描述学生事物
		 	姓名 , 年龄 , 性别 ....
			学习 , 吃饭 , 睡觉 ....	
	属性:	就是该事物的描述信息
	行为:	就是该事物能够做什么

我们学习编程语言,就是为了模拟现实中的事物,我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。

由此我们就得到了现实中的事物和类的对应关系

		事物					  类
		属性	----------------- 成员变量
		行为	----------------- 成员方法

定义类其实就是定义类的成员(成员变量和成员方法)

成员变量和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
成员方法和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
类和对象的概念

a:类：是一组具有共同特征的集合,是一堆实例抽象而来。	
b:对象：是该类的实例化
c:举例：
	类	学生
	对象	一个学生就是一个对象

类的定义

[修饰符] class 类名 {
类体 = 属性 + 方法
}

以上为类的简单定义，实际上一个完整的类的定义要比以上语法复杂一些，以后再慢慢补充

学生类

public class Student { //定义一个类：class
    //成员属性，成员变量：定义在类中方法外
    String name;
    int age;
    char sex;
    //成员功能，成员方法
    public void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }

    public void playGame() {
        System.out.println("打豆豆");
    }
}

对象的创建和使用

对象的创建

public class StudentTest {
	public static void main(String[] args) {
	//创建一个学生对象
	Student s1 = new Student();
	//再创建一个学生对象
	Student s2 = new Student();
	//以上代码其实和这行代码差不多
	int i = 10;
	}
}

对象的使用

 public static void main(String[] args) {
        //如果使用定义好的一个类
        // 类：他是一个抽象的概念，他不能直接使用，如果要使用，我们需要对类进行实例化
        //所谓实例化，就是创建该类对象，因为对象才是类的具体表现
        // 怎么创建一个类的对象呢，使用关键字new
        Student s1 = new Student();
        //该类对象创建成功后，使用该类对象，就可以调用类中的属性和功能
        System.out.println(s1.name;);
        System.out.println(s1.age);
        System.out.println(s1.sex);
        //然后给属性赋值
        s1.name = "王五";
        s1.age = 23;
        s1.sex = '男';
        //获取属性的值
        System.out.println(s1.name;);
        System.out.println(s1.age);
        System.out.println(s1.sex);

        //使用功能
        s1.eat();
        s1.sleep();
        s1.playGame();
    }

通过学生类实例化的学生对象对象的年龄，不赋值的情况下获取了到的年龄都是 0，这是因为在 java 语言当中，当实例变量没有手动赋值，在创建对象的时候，也就是说在 new 的时候，系统会对实例变量默认赋值，它们的默认值请参考下表：
在这里插入图片描述

成员变量和局部变量的区别

在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

注意事项：局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
方法的形式参数是类名的时候如何调用

Java中参数传递问题
形式参数
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
方法的参数是类名
如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。

匿名对象的概述和应用

什么是匿名对象
就是没有名字的对象
匿名对象应用场景
（1）. 调用方法，仅仅只调用一次的时候。
（2）. 匿名对象可以作为实际参数传递

封装的概述

封装的引入
通过学生案例，给年龄赋值为负数引出数据问题。
然后通过private解决这个问题。最后说其实这就是封装。
封装概述
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装好处
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。
封装原则
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。

private关键字的概述和特点

private关键字特点
a:是一个权限修饰符
b:可以修饰成员变量和成员方法
c:被其修饰的成员只能在本类中被访问
private最常见的应用：
a:把成员变量用private修饰
b:提供对应的getXxx()和setXxx()方法
案例

public class Phone {
    //私有成员变量
    //this 表示本类的一个引用。你可以理解为本类的一个对象，哪个对象调用这个方法，那么方法中的this就代表这个对象
    private String name;
    private double price;
    //提供公共的set get 方法
    public void setName(String name){
        //方法中的this 就代表那个调用者，谁调用就代表谁
       // p.name=name;
        //就近原则
        System.out.println("this代表调用者的地址值"+this);
        this.name=name;
    }
    public void setPrice(double price){
       // p.price=price;
        System.out.println("this代表调用者的地址值" + this);
        this.price=price;
    }
    public String getName(){
        return name;
    }
    public double getPrice(){
        return price;
    }

 public static void main(String[] args) {
        Phone phone = new Phone();
        System.out.println(phone+"调用者的地址值");
        phone.setName("小米");
        phone.setPrice(500);

        String name = phone.getName();
        double price = phone.getPrice();
        System.out.println(name+"===="+price);

        System.out.println("------------------------");
        Phone phone2 = new Phone();
        System.out.println(phone2 + "调用者的地址值");
        phone2.setName("小米");
        phone2.setPrice(500);

        String name2 = phone2.getName();
        double price2 = phone2.getPrice();
        System.out.println(name2 + "====" + price2);
    }

在上文中我们看到这样的代码
this.name=name;
这个this.是什么意思呢？又有什么作用呢？

this关键字

为什么要有this
当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题
this关键字特点
this 可以看做一个变量，它是一个引用，存储在 Java 虚拟机堆内存的对象内部， this 这个引用保存了当前对象的内存地址指向自身，任何一个堆内存的 java 对象都有一个 this，也就是说创建 100 个 java 对象则分别对应 100 个 this。
this的应用场景
this 指向“当前对象”，也可以说 this 代表“当前对象”， this 可以使用在实例方法中以及构造方法中，语法格式分别为“this.”和“this(…)”。this 不能出现在带有 static 的方法当中。
this 使用在构造方法中
this 还有另外一种用法，使用在构造方法第一行（只能出现在第一行，这是规定，记住就行），通过当前构造方法调用本类当中其它的构造方法，其目的是为了代码复用。调用时的语法格式是： this(实际参数列表)

static关键字

静态属性、静态方法

当一个类的所有对象的某个“属性值”不会随着对象的改变而变化的时候，建议将该属性定义为静态属性（或者说把这个变量定义为静态变量），静态变量在类加载的时候初始化，存储在方法区当中，不需要创建对象，直接通过“类名”来访问。
如果静态变量使用“引用”来访问，可以吗，如果可以的话，这个访问和具体的对象有关系吗？看以下代码：

public class ManTest {
	public static void main(String[] args) {
		//静态变量比较正式的访问方式
		System.out.println("性别 = " + Man.sex);
		//创建对象
		Man jack = new Man(100);
		//使用“引用”来访问静态变量可以吗？
		System.out.println("性别 = " + jack.sex);
		//对象被垃圾回收器回收了
		jack = null;
		//使用“引用”还可以访问吗？
		System.out.println("性别 = " + jack.sex);
	}
}

运行结果如下图所示：
在这里插入图片描述
通过以上代码以及运行结果可以看出，静态变量也可以使用“引用”去访问，但实际上在执行过程中，“引用”所指向的对象并没有参与，如果是空引用访问实例变量，程序一定会发生空指针异常，但是以上的程序编译通过了，并且运行的时候也没有出现任何异常，这说明虽然表面看起来是采用“引用”去访问，但实际上在运行的时候还是直接通过“类”去访问的。静态方法也是这样。

代码块的概述和分类

代码块概述

在Java中，使用{}括起来的代码被称为代码块。

代码块分类

根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。

常见代码块的应用

a:局部代码块
在方法中出现；限定变量生命周期，及早释放，提高内存利用率

b:构造代码块
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行

c:静态代码块
在类中方法外出现，加了static修饰
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。

大家看看这段代码

class Student {
		static {
			System.out.println("Student 静态代码块");
		}
		
		{
			System.out.println("Student 构造代码块");
		}
		
		public Student() {
			System.out.println("Student 构造方法");
		}
	}

	class StudentDemo {
		static {
			System.out.println("StudentDemo的静态代码块");
		}
		
		public static void main(String[] args) {
			System.out.println("我是main方法");
			
			Student s1 = new Student();
			Student s2 = new Student();
		}
	}

不知道其他人怎么样，反正我看到这些代码的时候我是懵逼的。。。（笑哭脸）
那大家猜猜结果呀。

StudentDemo的静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法

这些都是各种代码块的特点造成的结果。

静态代码块

静态代码块的语法格式是这样的：

类{
	//静态代码块
	static{
		java 语句;
	}
}

静态代码块在类加载时执行，并且只执行一次。只在类加载时刻执行一次，如果需要在类加载是实现某些功能，那么静态代码块就排上用场了。
2. 一个类当中可以编写多个静态代码块（尽管大部分情况下只编写一个），并且静态代码块遵循自上而下的顺序依次执行，所以有的时候放在类体当中的代码是有执行顺序的（大部分情况下类体当中的代码没有顺序要求，方法体当中的代码是有顺序要求的，方法体当中的代码必须遵守自上而下的顺序依次逐行执行），另外静态代码块当中的代码在 main 方法执行之前执行，这是因为静态代码块在类加载时执行，并且只执行一次。

public class StaticTest01 {
	//静态代码块
	static{
		System.out.println(2);
	}
	//静态代码块
	static{
		System.out.println(1);
	}
	//main 方法
	public static void main(String[] args) {
		System.out.println("main execute!");
	}
	//静态代码块
	static{
		System.out.println(0);
	}
}

运行结果：
在这里插入图片描述
3. 无法从静态代码中直接使用实例变量，因为实例变量必须要先创建对象才能使用，当然也可以在一些变量之前加上‘static’，使之成为静态变量，从而进行访问。

public class StaticTest02 {
   int i = 100;
   static{
   	System.out.println(i);
   }
}

结果如下：
在这里插入图片描述
4. 静态方法
静态方法，比较方便调用，不需要创建对象，直接使用类名
就可以访问。

赤沐

关注

0
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
Java基础（面向对象、类的定义、对象的创建和使用）

面向对象引言我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步...
复制链接

扫一扫