Java面向对象（持续更新--未写完）

转x33g5p2x  于2021-11-23 转载在 Java  
字(6.1k)|赞(0)|评价(0)|浏览(448)

面对对象编程思想

面向对象思想就是将生活客观存在的事物，通过代码的形式将其描述出来。当我们再看到这些对象的时候，就联想到他应该具有什么样的功能

比如：

洗衣机可以洗衣服，甩干，烘干

学生可以吃饭，睡觉，学习

核心

1.类

可以描述生活中所有的事物

**   类的组成**

              属性：指事物的特征。例如：狗事物（品种、价格、年龄等）

              行为（方法）：指事物能执行的操作，例如：狗事物（吃东西、睡觉、看家）

在代码中，属性是通过成员变量体现的。行为是通过成员方法来体现的。

2.对象

概念：

     就是真实世界中的实体，现实世界中每个实体都是一个对象，是一种具体都概念

特点：

对象具有属性和行为。

对象具有变化的状态。

对象具有唯一性。

对象都是某个类别的实例。

一切皆为对象，真实世界中的所有事物都可以视为对象。

类和对象的关系

  • 类：类是对现实生活中一类具有共同属性和行为的事物的抽象
  • 对象：是能够看得到摸的着的真实存在的实体
  • 简单理解：类是对事物的一种描述，对象则为具体存在的事物

成员方法的定义与调用

定义格式

 

  1. //普通
  2. public void 方法名() {  
  3.     // 方法体
  4. }
  6. //带参数
  7. public void 方法名 ( 数据类型 变量名) {
  8.      // 方法体
  9. }
  11. //带返回值
  12. public 数据类型 方法名() {
  13.     // 方法体
  14.     return 返回值;
  15. }
  17. //及带参数又带返回值
  18. public 数据类型 方法名 (数据类型 变量名1，数据类型 变量名2...) {
  19.     //方法体
  20.     return 返回值;//将方法的运行结果返回给调用者
  21. }
  23. //方法的通用格式（掌握）
  24. public static 返回值类型 方法名(参数) {
  25.    方法体; 
  26.    return 数据 ;
  27. }
  29. /*
  30. 格式详解：
  31.     public static 	修饰符，目前先记住这个格式
  32.     返回值类型	方法操作完毕之后返回的数据的数据类型,如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
  33.     方法名		调用方法时候使用的标识
  34.     参数		由数据类型和变量名组成，多个参数之间用逗号隔开
  35.     方法体		完成功能的代码块
  36.     return		如果方法操作完毕，有数据返回，用于把数据返回给调用者
  38. 定义方法时，要做到两个明确
  39.     明确返回值类型：
  40.         主要是明确方法操作完毕之后是否有数据返回。
  41.         如果没有，写void。
  42.         如果有，写对应的数据类型。
  43.     明确参数：
  44.         主要是明确参数的类型和数量
  45.         调用方法时的注意：
  46.         void类型的方法，直接调用即可
  47.         非void类型的方法，推荐用变量接收调用
  48. * */

注：

1.可以带多个参数用逗号隔开

2.返回值类型可以为：

a;基本类型

b.数组

c.字符串

d.自定义的类

调用方法

对象名.方法名();

  1. public class Student {
  2.     //属性
  3.     String name;
  4.     int age;
  6.     //行为 --- 学习
  7.     public void study(){
  8.         System.out.println(name + "学生学习Java");
  9.     }
  11.     //行为 --- 吃饭
  12.     public void eat(){
  13.         System.out.println(name + "学生吃饭");
  14.     }
  16.     //行为 --- 睡觉
  17.     public void sleep(){
  18.         System.out.println(name + "学生睡觉");
  19.     }
  21. }
  23. public class Lianxi {
  24.     /*
  25.         成员方法的调用格式:
  26.             对象名.方法名();
  27.      */
  28.     public static void main(String[] args) {
  29.         Student stu = new Student();
  30.         stu.name = "张三";
  31.         stu.age = 23;
  32.         System.out.println(stu.name + "今年：" + stu.age + "岁");
  34.         stu.sleep();
  35.         stu.eat();
  36.         stu.study();
  37.     }
  38. }

对象名.方法名(参数);

参数有形参和实参：

形参：全称形式参数，是指在定义方法时，所声明的参数

实参：全称实际参数，调用方法时，所传入的参数

例：

  1. public class Phone {
  2.     String brand;
  3.     int price;
  5.     //定义带有参数的方法
  6.     public void call(String name){//String name就是形参
  7.         System.out.println("给" + name + "打电话");
  8.     }
  10.     //定义没有参数的方法
  11.     public void sendMessage(){
  12.         System.out.println("群发短信");
  13.     }
  14. }
  17. public class Lianxi {
  18.     public static void main(String[] args) {
  19.         Phone p = new Phone();
  20.         //有参数的方法调用格式: 对象名.方法名(参数);
  21.         p.call("张三");  //张三就是实参
  22.         p.call("李四");  //李四也是实参
  23.         
  24.         //没有参数的方法调用格式： 对象名.方法名();
  25.         p.sendMessage();
  26.     }
  27. }

注意事项：

方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错

方法定义时，多个参数之间使用逗号分隔

方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错

数据类型 变量名 = 对象名.方法名(参数...);//相当于就是拿一个变量接收一下方法的运行结果。

  1. public class Phone {
  2.     String brand;
  3.     int price;
  5.     //有参有返回值的方法
  6.     public int add(int a, int b){
  7.        int c = a + b;
  8.        return c;
  9.     }
  10. }
  12. public class TestPhone {
  13.     public static void main(String[] args) {
  14.         Phone p = new Phone();
  15.         //调用有参有返回值的方法。
  16.         //必须拿一个变量接收一下方法的运行结果。
  17.         int result = p.add(10,20);
  19.         System.out.println(result);
  20.     }
  21. }

方法的作用和注意事项

作用

提高代码的复用性

提高代码的可阅读性

 注意事项

方法必须先创建才可以使用，该过程称为方法定义

方法不调用就不执行

方法与方法之间是平级关系，不能嵌套定义

方法的定义顺序和执行顺序无关

方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写如果要编写return，后面不能跟具体的数据。

return语句下面，不能编写代码，因为永远执行不到，属于无效的代码 

this关键字

this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）。
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

注：在这个重名问题中就引出了一个就近原则

在方法中调用变量，谁离调用者越近，那么方法中就会调用谁。

this关键字就是解决这个问题的

例：

  1. public class Student {
  2.     String name;
  3.     int age;
  5.     public void hello(String name){
  6.         // 就近原则 --- 访问局部变量
  7.         System.out.println("局部变量" + name);
  8.         // 利用this --- 访问成员变量
  9.         System.out.println("成员变量" + this.name);
  10.     }
  11.     
  12.     public void unm(){
  13.         System.out.println("unm方法中的this" + this);
  14.     }
  15. }
  17. public class Lianxi {
  18.     public static void main(String[] args) {
  19.         Student stu = new Student();
  20.         stu.name = "张三";
  21.         stu.age = 12;
  22.         stu.hello("李四");
  23.     }
  24. }

this内存图

this代表当前类的对象引用（地址值）

哪个对象调用this所在的方法，this就代表哪一个对象。

作用：用于区分局部变量和成员变量重名的问题。

方法的相互调用

this 可以用于调用本类的成员变量和成员方法。

调用成员变量：

如果跟局部变量没有重名，this可以省略。

调用成员方法：

this 可以直接省略。

例：

  1. public class Student {
  2.     String name;
  3.     int age;
  5.     public void study() {
  6.         System.out.println("学习");
  7.     }
  9.     public void sleep() {
  10.         System.out.println("睡觉");
  11.     }
  13.     public void eat() {
  14.         System.out.println("吃饭");
  15.     }
  17.     public void show(){
  18.         //如果不存在重名，这里的this可以省略
  19.         System.out.println(this.name);
  20.         System.out.println(this.age);
  21.         //调用其他成员方法，this可以省略。
  22.         this.study();
  23.         this.sleep();
  24.         this.eat();
  25.     }
  26. }
  28. public class Lianxi {
  29.     public static void main(String[] args) {
  30.         Student s = new Student();
  31.         s.show();
  32.     }
  33. }

权限修饰符

可以修饰类、类成员（包括成员变量和成员方法）

 分类：

private ：只能在本类当中进行访问。使用对象：变量、方法。

（default）默认： 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

protected： 对同一包内的类和所有子类可见。使用对象：变量、方法。 

public ：权限最大，可在任意位置进行访问。使用对象：类、接口、变量、方法

方法重载

方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载。

多个方法在同一个类中。

多个方法具有相同的方法名。

多个方法参数的数量不同、类型不同或者数据类型的顺序不相同。

好处：
在编写代码时，不需要起那么多方法名了，相同功能的方法，名字可以一样。

在调用方法时，不用记忆过多繁琐的方法名字。

注意事项：

重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式

重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

例：

  1. public class Lianxi {
  2.     public int unm(int a, int b) {
  3.         return a + b;
  4.     }
  6.     public double unm(double a, double b) {
  7.         return a + b;
  8.     }
  10.     public int unm(int a, int b, int c) {
  11.         return a + b + c;
  12.     }
  14.     public double unm(double a, double b, double c) {
  15.         return a + b + c;
  16.     }
  17. }

注：数据类型的顺序不同可以构成重载，但是不建议

构造方法

格式：

方法名与类名相同，大小写也要一致

没有返回值类型，连void都没有

没有具体的返回值（不能由retrun带回结果数据）

作用：

用的于给对象的数据（属性）进行初始化

什么时候执行：

创建对象的时候调用，每创建一次对象，就会执行一次构造方法

不能手动调用构造方法

例：

注：当没有写构造函数的时候有默认空参构造函数

构造方法的注意事项：

构造方法的创建 :

​    如果没有定义构造方法，系统将给出一个默认的无参数构造方法。

​    如果定义了构造方法，系统将不再提供默认的构造方法。

构造方法的重载：

​    如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法。

建议 :

​    无论是否使用，都手动书写无参数构造方法，和带参数构造方法。

封装

隐藏实现细节，仅对外暴露公共的访问方式

常见的体现：
将代码抽取到方法中，这是对代码的一种封装

将属性抽取到类当中，这是对数据的一种封装

例：

  1. /*不封装数据，那么3个学生信息需要操作6个数据。
  2. 把姓名和年龄封装成一个Student对象再进行操作。这样我们只要操作3个数据即可。
  3. 那如果1个学生对象有10个属性呢？
  4. 如果不封装，3个学生对象要操作30个数据。
  5. 如果封装，3个学生对象依旧只要操作3个数据即可。*/
  7. //把属性抽取到类当中，这是对数据的一种封装
  8. public class Student {
  9.     String name;
  10.     int age;
  11. }
  13. public class Lianxi{
  14.     public static void main(String[] args){
  15.         //情况一：不封装数据
  16.         //第一组学生信息
  17.         String name1 = "张三";
  18.         int age1 = 23;
  19.         //第二组学生信息
  20.         String name2 = "李四";
  21.         int age2 = 24;
  22.         //第三组学生信息
  23.         String name3 = "王五";
  24.         int age3 = 25;
  26.         //情况二：把姓名和年龄封装成一个Student对象再进行操作
  27.         Student stu1 = new Student();
  28.         stu1.setName("张三");
  29.         stu1.setAge(23);
  31.         Student stu2 = new Student();
  32.         stu2.setName("李四");
  33.         stu2.setAge(24);
  35.         Student stu3 = new Student();
  36.         stu3.setName("王五");
  37.         stu3.setAge(25);
  38.     }
  39. }

这样提高了代码的复用性

标准JavaBean类

一个标准的JavaBean类包含以下几个部分：

成员变量：使用 private 修饰

构造方法：

​    提供一个无参构造方法

​    提供一个带多个参数的构造方法

成员方法 ：

​    提供每一个成员变量对应的 setXxx() / getXxx()

使用JavaBean类：

利用无参构造创建对象，使用 setXxx() 赋值
利用带参构造方法直接创建带有属性值的对象

例：

  1. class Dog{
  2.     private String name;
  3.     private long phone;
  4.     private char sex;
  6.     public Dog(String name, long phone, char sex) {
  7.         this.name = name;
  8.         this.phone = phone;
  9.         this.sex = sex;
  10.     }
  12.     public Dog(){}
  14.     public String getName() {
  15.         return name;
  16.     }
  18.     public void setName(String name) {
  19.         this.name = name;
  20.     }
  22.     public long getPhone() {
  23.         return phone;
  24.     }
  26.     public void setPhone(long phone) {
  27.         this.phone = phone;
  28.     }
  30.     public char getSex() {
  31.         return sex;
  32.     }
  34.     public void setSex(char sex) {
  35.         this.sex = sex;
  36.     }
  37. }
  39. public class lianxi {
  40.     public static void main(String[] args) {
  41.         Student student = new Student();
  43.     }
  44. }

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/zhjjly/article/details/121451766

内容来源于网络，如有侵权，请联系作者删除！

Java开发语言

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com