C语言是一个面向过程的语言,而Java是一个面向对象的语言,强调类和对象的概念,以面向对象的方式来编写代码,本篇文章就带大家了解java中类和对象有关的内容。
上面也说了,C语言是一个面向过程的语言,它的设计思想更加接近硬件和底层操作。在C语言中,程序主要由函数组成,程序的执行是按照函数调用的顺序来进行的。C语言提供了丰富的控制结构和指针操作,使得程序员可以更加灵活地管理内存和处理底层细节。
Java是一种面向对象的编程语言,它强调对象和类的概念,允许开发人员以面向对象的方式编写代码。面向对象编程 (OOP) 是一种编程范式,其中数据和行为被组织为对象,对象之间通过消息传递进行交互。Java通过类、对象、封装、继承和多态等概念来实现面向对象编程。
总的来说,Java是一种高级面向对象的编程语言,适合开发大型应用程序和跨平台应用,而C语言则更偏向于系统编程和嵌入式开发,因为其更接近底层硬件操作。两者在设计哲学和用途上有所不同,开发者可以根据项目需求和个人偏好选择适合的编程语言。
比如我们来描述一个汽车的概念。
在面向对象编程中,我们将汽车视为一个对象,具有属性和行为。我们可以创建一个“Car”类来表示汽车,该类具有属性(如颜色、品牌、型号)和行为(如加速、刹车、转弯)。然后,我们可以实例化这个类创建具体的汽车对象,比如一辆红色的奔驰轿车。每辆汽车都是一个独立的实体,拥有自己的状态和行为。
public class Car {
String color;
String brand;
String model;
public void accelerate() {
// 加速的行为
}
public void brake() {
// 刹车的行为
}
public void turn() {
// 转弯的行为
}
}
在面向过程编程中,我们将汽车的功能分解为一系列步骤或过程。我们可能会创建不同的函数来执行不同的操作,比如加速函数、刹车函数、转弯函数。每个函数都是独立的,而汽车本身只是数据的集合,没有与这些操作直接相关联。
struct Car {
char color[20];
char brand[20];
char model[20];
};
void accelerate(struct Car* car) {
// 加速的操作
}
void brake(struct Car* car) {
// 刹车的操作
}
void turn(struct Car* car) {
// 转弯的操作
}
在面向对象编程中,重点是对象及其交互,而在面向过程编程中,重点是过程和函数的执行顺序。面向对象编程更具有灵活性和可维护性,因为它更好地模拟现实世界中的实体和关系。而面向过程编程更倾向于简单的线性执行,适用于一些较为简单的任务。
类是用来描述对象(比如说上面的车就是一个对象)的模板和蓝图。
定义类使用class关键字,沿用上面的例子
public class Car {
String color;
String brand;
String model;
public void accelerate() {
// 加速的行为
}
public void brake() {
// 刹车的行为
}
public void turn() {
// 转弯的行为
}
}
上面三个是车的属性,叫成员变量,下面三个是车的行为,叫成员方法。这里面包含的内容统称为类的成员。
在面向对象编程中,实例化是指根据类的定义创建类的具体对象的过程。当我们实例化一个类时,我们基于类的模板创建了一个具体的对象,该对象具有类中定义的属性和行为。换句话说,实例化是将类转换为对象的过程。在Java中,我们用new关键字来进行类的实例化。
下面继续沿用上面的例子:
public class Car {
// 属性
public String color;
public String brand;
public String model;
// 行为
public void accelerate() {
// 加速的行为
System.out.println("加速");
}
public void brake() {
// 刹车的行为
System.out.println("刹车");
}
public void turn() {
// 转弯的行为
System.out.println("转弯");
}
}
这里就定义了一个车类
public class Main {
public static void main(String[] args) {
// 创建一辆红色的奔驰轿车对象
Car myCar = new Car();
//给车赋予属性
myCar.brand = "奔驰";
myCar.color = "红色";
myCar.model = "轿车";
// 调用汽车对象的行为
myCar.accelerate();
myCar.brake();
myCar.turn();
}
}
在主类中 Car myCar = new Car(); 就是对车类的一个实例化。创建了一个新的车,可以给车的属性赋值,也可以使用成员方法,使车进行一些操作。此时打印结果为:
注意,可以进行多次实例化
对车类修改,区分一下不同的车
public class Car {
// 属性
public String color;
public String brand;
public String model;
// 行为
public void accelerate() {
// 加速的行为
System.out.println(brand + "加速");
}
public void brake() {
// 刹车的行为
System.out.println(brand + "刹车");
}
public void turn() {
// 转弯的行为
System.out.println(brand + "转弯");
}
}
Main类:
public class Main {
public static void main(String[] args) {
// 创建一辆红色的奔驰轿车对象
Car myCar = new Car();
Car myCar2 = new Car();
myCar.brand = "奔驰";
myCar.color = "红色";
myCar.model = "轿车";
// 调用汽车对象的行为
myCar.accelerate();
myCar.brake();
myCar.turn();
myCar2.brand = "宝马";
myCar2.color = "蓝色";
myCar2.model = "轿车";
// 调用汽车对象的行为
myCar2.accelerate();
myCar2.brake();
myCar2.turn();
}
}
在Java中,this是一个关键字,用于引用当前对象的引用。
假设有一个Person类,其中有一个实例变量name表示人的姓名,以及一个方法setName用于设置姓名。在这种情况下,如果方法参数和实例变量同名,就需要使用this关键字来区分它们。
public class Person {
private String name;
public void setName(String name) {
// 使用this关键字来引用实例变量,区分方法参数和实例变量
this.name = name;
}
public void printName() {
System.out.println("Name: " + this.name);
}
public static void main(String[] args) {
Person person = new Person();
person.setName("Alice");
person.printName();
}
}
在上面的例子中,setName方法中的参数name与实例变量name同名。在setName方法中,使用this.name来引用实例变量,以明确指示将传入的参数值赋给实例变量。这样可以避免混淆,确保正确地设置实例变量的值。
this主要用于以下方面:
public class Person {
private String name;
public void setName(String name) {
this.name = name; // this.name引用实例变量,name引用方法参数
}
}
public class Person {
private String name;
private int age;
public Person() {
this("小明", 30); // 调用另一个构造方法
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
public class Person {
private String name;
public Person setName(String name) {
this.name = name;
return this;
}
}
public class Person {
private String name;
public void doSomething() {
OtherClass.processPerson(this);
}
}
this关键字的使用可以帮助代码更清晰地表达出当前对象的引用,避免混淆和错误。它在实例方法中经常用于引用当前对象的实例变量,以及在构造方法中调用其他构造方法。
初始化对象的步骤:
构造方法(Constructor)是一种特殊类型的方法,在创建类的实例(对象)时用于初始化对象的特定属性。构造方法的名称必须与类名相同,并且没有返回类型(包括void)。在Java中,每个类都可以有一个或多个构造方法,用于初始化对象的状态。
与类同名:构造方法的名称必须与类名完全相同。
没有返回类型:构造方法没有返回类型,包括void。
用于初始化对象:构造方法用于在创建对象时初始化对象的状态,为对象的属性赋初值。
此外:如果在类中没有显式定义任何构造方法,Java会提供一个默认的无参构造方法(默认构造器),用于创建对象。默认构造方法不包含任何参数,且不执行任何操作。
public class Person {
private String name;
private int age;
// 构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void displayInfo() {
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
public static void main(String[] args) {
// 创建对象并初始化
Person person = new Person("Alice", 25);
person.displayInfo();
}
}
在上面的示例中,Person类包含一个带有两个参数的构造方法,用于初始化name和age属性。在main方法中,我们通过调用构造方法来创建Person对象,并初始化对象的属性。构造方法在对象创建时自动调用,确保对象在创建时具有正确的初始状态。
封装(Encapsulation)是面向对象编程中的一种重要概念,它指的是将数据(属性)和操作数据的方法(行为)捆绑在一起,并对外部隐藏对象的内部实现细节。封装通过限制对对象的直接访问,提供了更好的控制和安全性,同时提高了代码的可维护性和灵活性。
在讲封装之前,要先认识访问限定符,java中通过类和访问权限来实现封装。java提供了四种访问限定符。
public:
公有访问修饰符,表示对所有类可见。在任何地方都可以访问该成员。
protected:
受保护的访问修饰符,表示对同一包内的类和所有子类可见。在不同包的子类中也可以访问。
default(默认,不使用关键字修饰):
默认访问修饰符,表示对同一包内的类可见。如果不指定访问修饰符,默认为默认访问修饰符。
private:
私有访问修饰符,表示只有在同一类中可见。其他类无法访问私有成员。
示例:
public class Person {
public String publicName; // 公有成员
protected int protectedAge; // 受保护成员
String defaultCity; // 默认访问修饰符,默认包内可见
private String privatePhoneNumber; // 私有成员
// 构造方法
public Person(String name, int age, String city, String phoneNumber) {
this.publicName = name;
this.protectedAge = age;
this.defaultCity = city;
this.privatePhoneNumber = phoneNumber;
}
// Getter和Setter方法
public String getPrivatePhoneNumber() {
return privatePhoneNumber;
}
public void setPrivatePhoneNumber(String phoneNumber) {
this.privatePhoneNumber = phoneNumber;
}
}
在上面的示例中,Person类包含了不同访问修饰符修饰的成员变量。根据不同的访问修饰符,这些成员变量具有不同的可见性和访问权限。
讲到这里,又出现了一个陌生的概念:包。
在Java中,包(Package)是一种用于组织类和接口的命名空间。包可以包含类、接口、枚举和注解等Java元素,帮助开发人员组织和管理大型项目中的代码。包的主要作用是避免命名冲突,提供命名空间,以及帮助开发人员更好地组织和管理代码。
命名空间:包提供了命名空间,避免了不同类之间的命名冲突,允许在不同包中使用相同名称的类。
访问控制:包可以限制类的访问范围,通过使用不同的访问修饰符来控制包内和包外的访问权限。
组织代码:包可以帮助开发人员更好地组织和管理代码,将相关的类放在同一个包中,提高代码的可维护性。
可重用性:包可以作为代码的单元,方便在不同项目中重用和共享代码。
包名通常使用小写字母,多个单词用.分隔,例如com.example.myproject。
包名应该是唯一的,通常使用公司域名的倒置形式作为包名的前缀,以确保包名的唯一性。
包名中不应该包含Java保留关键字或特殊字符。
在Java中,要使用另一个包中的类,需要使用import语句将该类引入到当前的代码文件中。通过import语句,可以告诉编译器在哪里找到所需的类,并且可以使用该类的方法和属性。
import packageName.className; //自定义包
import java.util.ArrayList;
import packageName.*
;。这样可以导入包中的所有类。import java.util.*
;import static java.lang.Math.*;
下面是个例子:
import java.util.ArrayList; // 导入ArrayList类
import java.util.Collections; // 导入Collections类
import java.util.*; // 导入java.util包中的所有类
public class Main {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>(); // 使用ArrayList类
list.add("Java");
list.add("is");
list.add("fun");
// 使用Collections类中的方法对集合进行排序
Collections.sort(list);
// 遍历集合并输出
for (String str : list) {
System.out.println(str);
}
}
}
在上面的示例中,我们使用import语句导入了ArrayList类、Collections类以及java.util包中的所有类。通过导入这些类,我们可以在代码中直接使用它们的方法和属性,实现了对包中类的引用和使用。
在Java中,static关键字用于创建静态成员,包括静态变量(类变量)和静态方法。静态成员属于类本身,而不是类的实例,因此可以直接通过类名访问,无需创建类的实例。
静态变量是使用static关键字声明的变量,它们属于类而不是实例。
所有类的实例共享同一个静态变量的值。
静态变量在类加载时初始化,并且在整个程序的生命周期内存在。
public class MyClass {
public static int count = 0; // 静态变量
public static void main(String[] args) {
MyClass.count++; // 直接通过类名访问静态变量
System.out.println(MyClass.count); // 输出静态变量的值
}
}
静态方法是使用static关键字声明的方法,可以直接通过类名调用,无需创建类的实例。
静态方法不能直接访问非静态成员,因为在调用静态方法时可能还没有类的实例存在。
public class MathUtil {
public static int add(int a, int b) { // 静态方法
return a + b;
}
public static void main(String[] args) {
int sum = MathUtil.add(5, 3); // 调用静态方法
System.out.println("Sum: " + sum);
}
}
这个部分将在下面代码块内容中讲。
在Java中,代码块是一段包含一组语句的代码块,用于在特定条件下执行一些操作或初始化工作。
普通代码块是指在方法中使用花括号 {} 包围的一段代码,也称为局部代码块。这种代码块用于限定变量的作用域,使得在代码块外部无法访问在代码块内部声明的变量。普通代码块可以包含任意数量的语句,用于执行特定的操作或逻辑。
示例:
public class LocalBlockExample {
public static void main(String[] args) {
int x = 5; // 在代码块外部声明的变量
{
int y = 10; // 在普通代码块内部声明的变量
System.out.println("普通代码块执行");
System.out.println("x: " + x); // 可以访问外部变量
System.out.println("y: " + y); // 可以访问内部变量
}
// System.out.println(y); // 编译错误,y超出作用域
}
}
构造代码块(构造块)是在类中使用花括号 {} 包围的一段代码,用于在创建对象时执行初始化操作。构造代码块在类的每次实例化时都会执行,优先于构造方法执行。构造代码块常用于对实例变量进行初始化操作。
构造代码块没有任何参数,不接受任何参数。
构造代码块在每次创建对象时都会执行,优先于构造方法执行。
构造代码块不能被对象直接调用,只能在对象创建时自动执行。
public class ConstructorBlockExample {
private int x;
// 构造代码块
{
System.out.println("构造代码块执行");
x = 10; // 初始化实例变量
}
// 构造方法
public ConstructorBlockExample() {
System.out.println("构造方法执行");
}
public static void main(String[] args) {
ConstructorBlockExample obj = new ConstructorBlockExample();
System.out.println("x的值: " + obj.x);
}
}
静态代码块(静态初始化块)是在类加载时执行的一段代码块,用于初始化静态变量或执行静态操作。静态代码块使用 static 关键字进行声明,在类加载时只会执行一次,且优先于静态变量的初始化和静态方法的执行。
静态代码块使用 static 关键字声明,不接受任何参数。
静态代码块在类加载时执行,且只会执行一次。
静态代码块用于静态变量的初始化、静态方法的调用以及执行其他静态操作。
public class StaticBlockExample {
private static int x;
// 静态代码块
static {
System.out.println("静态代码块执行");
x = 5; // 初始化静态变量
}
public static void main(String[] args) {
System.out.println("x的值: " + x);
}
}
在上面的示例中,静态代码块用来初始化静态变量 x,并且在类加载时执行,只会执行一次。静态代码块可以用来执行一些静态操作,如静态变量的初始化、静态方法的调用、加载驱动程序等。静态代码块通常用于在类加载时执行一些初始化操作,确保类的静态资源被正确初始化。
在Java中,内部类是定义在另一个类内部的类。内部类可以访问外部类的成员,包括私有成员,并且可以提供更好的封装和组织代码的方式
成员内部类是定义在类内部的普通类,可以访问外部类的成员,包括私有成员。
public class Outer {
private int x;
class Inner {
public void display() {
System.out.println("x的值 " + x);
}
}
}
静态嵌套类是定义在类内部的静态类,与外部类实例无关,可以直接通过外部类名访问。
public class Outer {
private static int y;
static class Nested {
public void display() {
System.out.println("y的值: " + y);
}
}
}
匿名内部类是没有类名的内部类,通常用于创建临时的子类或实现接口。这在后面再说。
以上就是类的对象的全部内容,希望大家看完之后,对类和对象有进一步的理解