Java面向对象
面向对象概念简述
Java是一种面向对象的编程语言，是一个至关重要的概念，面向对象是编程（OOP）一种极其重要的编程范式，它提供了类和对象、构造方法、继承、封装和多态等面向对象的基本特性。
面向对象的核心在于将现实世界中的事物抽象为对象。每个对象都具有自己独特的属性和行为。这种方式极大地增强了代码的组织性、可读性和可维护性。这使得代码的组织和理解更加清晰、自然。
一、类和对象
在Java中，类使对对象的抽象描述，它定义了对象的属性和方法。对象是类的实例，具有类的属性和方法。
类：类是对象的模板，类是抽象的，不能被具体描述
对象：能够被具体描述，万事万物皆对象，通过类的模板实例化出对象
创建对象：类名 对象名 = new 类名（）；
下面是一个简单的Person类的定义以及对象的创建和使用：
//定义一个Person类
public class Person {
//1.创建属性（特征）
String name; //名字
String sex; //性别
int age； //年龄
/**
创建方法（功能、行为）
*/
public void showData(){
System.out.println("我的名字叫" + name + " 性别是" + sex + " 年龄" + age);
}
}
//再创建一个测试类，来创建Person对象并给属性赋初始值
public class Test {
public static void main(String[] args){
//创建Person对象
Person person = new Person();
//设置对象的属性
person.name = "蟒蛇boy";
person.sex= "男";
person.age= 18;
//调用对象的showData方法
person.showData(); //输出：我的名字叫蟒蛇boy 性别是男 年龄18
}
}在这个例子中，Person是一个类，我定义了三个属性name、sex和age，和一个showData方法。在Tset类中，我们创建Person类的对象（实例）person，并给它的属性赋值，调用了它的方法。
给对象属性赋值 对象名.属性 = "值"；
调用对象的方法 对象名.方法()；
二、构造方法
构造方法是类的一种特殊方法，用于初始化对象的状态。它的名称必须与类名完全相同，并且没有返回值。
作用：创建对象，实例化对象，默认调用无参构造函数，创建对象并赋初始值，调用有参构造函数。
特点：
- 方法名必须和类名相同
- 没有返回值
- 一般为public 公开的
- 会默认提供一个无参构造函数，当定义了一个有参构造的时候，无参就不再提供，需要手动再写一个无参构造函数。
- 可以进行重载（同名不同参）
//定义一个Person类
public class Person {
//1.创建属性（特征）
String name; //名字
String sex; //性别
int age； //年龄
//构造方法
//无参构造方法
public Person(){
//方法名必须要与类名相同
//默认会提供无参构造
}
//有参构造方法
public Person(String name, String sex, int age){
//方法名必须要与类名相同
//不写无参构造会将无参构造覆盖
}
/**
创建方法（功能、行为）
*/
public void showData(){
System.out.println("我的名字叫" + name + " 性别是" + sex + " 年龄" + age);
}
}
//再创建一个测试类，用构造方法来创建Person对象并给属性赋初始值
public class Test {
public static void main(String[] args){
//创建并初始化Person对象
Person person = new Person("蟒蛇boy", "男", 18);
//调用对象的showData方法
person.showData(); //输出：我的名字叫蟒蛇boy 性别是男 年龄18
}
}
在这个例子中，我们为Person类添加了一个构造方法，它接受三个参数name、sex和age，并用于初始化创建对象的name、sex和age属性。
Java中的面向对象三大特性指的是：封装、继承和多态。
三、面向对象三大特征：封装
1. 概念简述
在Java面向对象编程中，封装是一个核心概念。封装将对象隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类的方法进行操作，以确保对象内部数据的完整性和安全性。
封装的主要目的是增强安全性和简化程序。通过将对象属性和方法隐藏在类的内部，能够防止外部程序直接访问和修改对象内部状态，就这样我们可以控制对象状态的访问和修改，确保数据的完整性和安全性。
2. 访问修饰符
Java提供了四种访问修饰符来控制类、属性和方法的访问级别：
- public：可以在任何地方访问
- 缺省（无修饰符）：可以在同一包内的类访问
- protected：可以在同一包内的类以及不同包的子类访问
- private：仅能在本类中访问
在封装的过程中，我们通常将对象的属性设置为private，以确保它们不会被外部直接访问或修改。
3. 封装示例
下面是一个简单的Java类，展示了封装的基本应用：
java
//创建一个Student类
public class Student {
// 创建私有属性，只能被该类内部访问
private String name; //名字
private String sex; //性别
private int age; //年龄
// get方法，用于获取name属性的值
public String getName() {
return name;
}
// set方法，用于设置name属性的值
public void setName(String name) {
this.name = name;
}
// get方法，用于获取sex属性的值
public String getSex() {
return sex;
}
// set方法，用于设置sex属性的值
public void setSex(String sex) {
this.sex= sex;
}
// get方法，用于获取age属性的值
public int getAge() {
return age;
}
// set方法，用于设置age属性的值
public void setAge(int age) {
this.age = age;
}
// 有参构造方法
public Student(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
// 无参构造方法
public Student(){
}
/**
创建方法（功能、行为）
*/
public void showData(){
System.out.println("我的名字叫" + this.name + " 性别是" + this.sex + " 年龄" + this.age);
}
}
//再创建一个测试类，用构造方法来创建Student对象并给属性赋初始值
public class Test {
public static void main(String[] args){
//创建并初始化Student对象
Student student= new Student();
student.setName("蟒蛇boy");
student.setsex("男");
student.setage(18);
//调用对象的showData方法
student.showData(); //输出：我的名字叫蟒蛇boy 性别是男 年龄18
}
}在这个`Student`类中，我们有两个私有属性name、sex和age，外部无法直接访问和修改它们。我们提供了公有方法getName()， setName()，getSex()， setSex()，getAge()，和setAge()来让外部能够间接地获取和设置这些属性的值。
四、面向对象三大特征：继承
1. 概念简述
在Java面向对象编程中，继承是一个核心概念。继承就一个类从另一个类中获取属性和方法。就像是儿子继承父亲的传家宝一样。继承是一个非常关键且强大的特性，继承允许一个类（子类）去继承另一个类（父类）的属性和方法。这为代码的组织和复用提供了极大的便利。
2.继承示例
下面是一个简单的Java类，展示了封装的基本应用：
java
//创建Person类
public class Person {
/**
创建speak方法
*/
public void speak() {
System.out.println("我是人");
}
}
//创建Student类，去继承Person类
class Dog extends Person { //使用继承关键字extends ，只能继承一个父类
/**
创建speak方法
*/
public void introduce() {
System.out.println("我还是学生");
}
}
//创建一个测试类
public class Test {
public static void main(String[] args) {
//创建Student类对象
Student stu = new Student();
//继承使用父类的方法
//语法： 对象名.父类方法();
stu.speak(); //我是人
stu.introduce(); //我还是学生
}
}在这个例子中，Student类通过继承Person类，拥有了speak方法，同时还可以在本类定义自己的introduce方法。
3.继承的特点
-
单一性：子类只能继承一个父类
-
传递性：代代相传，子类继承父类，列如：B类继承A类，C类继承B类。
4.继承的好处
继承带来了许多好处，它实现了代码的重用， 减少代码冗余(重复代码)，方便后期维护和扩展。
五、面向对象三大特征：多态
1. 概念简述
在Java面向对象编程中，多态是一个核心概念。多态意味着一个对象可以有多种形态。通过继承和方法重写，我们可以在不同的子类中对父类的方法进行特定的实现，然后在运行时根据实际的对象类型来执行相应的方法。简单的来说，就是允许不同类型的对象对同一消息作不同的响应。
2.多态示例
//创建一个Animal类作为父类
public class Animal {
/**
创建makeSound方法
*/
public void makeSound() {
System.out.println("动物发出声音");
}
}
//创建Dog类继承Animal类
public class Dog extends Animal {
@Override //重写父类的方法
public void makeSound() {
System.out.println("汪汪汪");
}
}
//创建Cat类继承Animal类
public class Cat extends Animal {
@Override //重写父类的方法
public void makeSound() {
System.out.println("喵喵喵");
}
}
//再创建一个测试类
public class Test {
public static void main(String[] args) {
Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.makeSound(); //"汪汪汪"
animal2.makeSound(); //"喵喵喵"
}
}
在这个例子中，我们定义了一个父类 Animal 和两个子类 Dog 和 Cat ，它们都重写了父类的 makeSound 方法。在 main 方法中，我们创建了 Dog 和 Cat 对象，并将它们向上转型为 Animal 类型。尽管在代码中我们使用的是 Animal 引用，但在运行时会根据实际的对象类型（ Dog 或 Cat ）执行相应的方法。
总结
通过面向对象编程，我们可以更好地组织和管理代码，实现代码的复用和扩展。它让我们能够以更贴近现实世界的方式来思考和解决问题。在实际的项目开发中，合理运用面向对象的理念和技术，能够极大地提高开发效率和代码质量。
扫一扫
3289
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
