• java面向对象（上）

    一、java面向对象学习的三条主线
    1.java类以及类的成员：属性、方法、构造器；代码块、内部类。
    2.面向对象的三大特征：封装性，继承性，多态性，（抽象性）。
    3.其他关键字：this，super，static，final，abstract，interface，package，import。

     

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

    1. /*
    2. 理解面向过程和面向对象的区别
    3. 例子：人把大象装进冰箱
    4.     1.面向过程：强调的是功能性为，以函数为最小单位，考虑怎么做。
    5.         1）把冰箱打开
    6.         2）抬起大象，塞进冰箱
    7.         3）把冰箱门关闭
    8.     2.面对对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
    9.         人{
    10.             打开(冰箱){
    11.                 冰箱.打开门();
    12.             }
    13.             抬起(大象){
    14.                 大象.进入(冰箱)；
    15.             }
    16.             关闭(冰箱){
    17.             冰箱.关门();
    18.         }
    20.         冰箱{
    21.             打开门(){}
    22.             关门(){}
    23.         }
    25.         大象{
    26.             进入(冰箱){}
    27.         }
    29.  */

    ——

    类和对象

    面向对象程序设计的重点是类的设计，在一个就是设计类的成员。

    • 类：类是对一类事物的描述，是抽象的、概念上的定义。
    • 对象：对象时实际存在的该类事物的每个个体，因而也称为实例。

    可以理解为：类=抽象概念的人；对象=实实在在存在的某个人。

    常见的类的成员有：

                            属性：对应类中的成员变量。

                            行为：对应类中的成员方法。

    • 属性和方法：

    属性=成员变量=field=域或字段。

    方法=成员方法=函数=method。

    例如生活中如：人有身高和体重的属性，有说话和打球等行为。

    1. /*
    2. 类和对象的使用：
    3.     1.创建类，设计类的成员。
    4.     2.创建类的对象。
    5.     3.通过对象.属性/方法 来调用对象的结构。
    6. */
    7. public class OOPTest {
    8.     public static void main(String[] args) {
    9.         Person p1 = new Person();
    10.         p1.name = "Tom";
    11.         p1.Male = true;
    12.         System.out.println(p1.name);
    13.         p1.eat();
    14.         p1.sleep();
    15.         p1.talk("Chainese");
    16.     }
    17.  
    18. }
    19.  
    20. class Person{
    21.     //属性
    22.     String name;//姓名
    23.     int age;//年龄
    24.     boolean Male;//性别
    25.  
    26.     //方法
    27.     public void eat(){
    28.         System.out.println("吃饭");
    29.     }
    30.     public void sleep(){
    31.         System.out.println("睡觉");
    32.     }
    33.     public void talk(String language){
    34.         System.out.println("说话，说的语言是："+language);
    35.     }
    36.  
    37. }

    ——————————

    对象的内存解析

    ————

    •  堆(Heap)：此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都是在这里分配内存。这一点在java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
    • 栈(Stack)：是指虚拟机栈。虚拟机栈用来存储局部变量。局部变量表存放了编译期可知长度的各种基本数据类型、对象引用。方法执行完，自动释放。
    • 方法区(Method Area)：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

    属性与局部变量

    1. /*
    2. 类中属性的使用：属性(成员变量) 与 局部变量
    3.     1.相同点：
    4.         1.1 定义变量的格式都一样。
    5.         1.2 先声明，后使用。
    6.         1.3 变量都有其对应的作用域。
    8.     2.不同点：
    9.         2.1 在类中声明的位置不同
    10.             属性直接配置在{}内
    11.             局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量。
    12.         2.2 关于权限修饰符的不同
    13.             属性：可以在声明属性时 指明其权限修饰符，使用权限修饰符。
    14.             常用的权限修饰符：private,public,缺省(就是不写),protected
    15.             局部变量：不可以使用权限修饰符。
    16.         2.3 默认初始化值的情况：
    17.             属性：类的属性，根据其类型都有默认初始化值。
    18.             局部变量：没有默认初始化值，所以调用之前一定要设置其值。
    19.         2.4 在内存中加载的位置：
    20.             属性：堆空间中。(static除外)
    21.             局部变量：栈空间中。
    23.  */
    24.  
    25. public class UserTest {
    26.  
    27. }
    28. class User{
    29.     //属性
    30.     int a;
    31.     int b;
    32.     int c;
    33.     public void talk(int lange){
    34.         System.out.println(lange); //lange就是方法形参，局部变量。
    35.         int d; //d是在方法内声明的，也是局部变量。
    36.     }
    37.  
    38. }

    ————————

    方法的使用

    1. /*
    2. 类中方法的声明和使用
    4.     方法：描述类应具有的功能。
    5.     例如：Scanner类,sort类......
    6.     1. 举例：
    7.         public void eat(){}
    8.         public void sleep(int hour){}
    9.         public String getName(){}
    10.         public String getNation(String nation){}
    12.     2. 方法的声明：权限修饰符 返回值类型 方法名(形参列表){
    13.            方法体
    14.     }
    15.     3.1 权限修饰符：
    16.         private:私有,public：公共,缺省,protected
    17.     3.2 返回值类型：
    18.         有返回值：
    20.         无返回值：
    21.     return关键字的使用：
    22.     1. 使用范围：使用在方法体中
    23.     2. 作用：
    24.         结束方法体；
    25.         对于偶遇返回值类型的方法，使用return可以结束方法并返回所要的数据。
    26.     3. return 关键字后面不可以声明执行语句。
    27.     方法的使用中，可以调用当前类的属性或方法
    28.         特殊的：方法a中调用方法a，这就是递归，但是一定要注意无限循环，这样会栈溢出。
    29.     方法中不可以定义方法
    31.  */

    ——————

    对象数组的内存解析

    过程图

     匿名对象的使用

    1. /*
    2. 匿名对象：
    3.     理解：创建的对象没有显式的赋给一个变量名，则是匿名对象
    4.     特征：匿名对象只能调用一次，一次性的
    5.  */
    6. public class Cussaa {
    7.     public static void main(String[] args) {
    8.         Phone p = new Phone();
    9.         System.out.println(p);
    10.         p.sendEmail();
    11.         p.playGame();
    12.  
    13.         //匿名对象
    14.         new Phone().sendEmail();
    15.         new Phone().playGame();
    16.  
    17.  
    18.         new Phone().price = 2999;
    19.         new Phone().showPrice();//0.0
    20.         //所以说上面算new了两个对象
    21.  
    22.  
    23.         //匿名对象的使用
    24.         PhoneMall mall = new PhoneMall();
    25.         mall.show(new Phone());//匿名对象的使用
    26.  
    27.  
    28.     }
    29.  
    30. }
    31.  
    32. class PhoneMall{
    33.     public void show(Phone phone){
    34.         phone.showPrice();
    35.         phone.playGame();
    36.     }
    37. }
    38.  
    39. class Phone{
    40.     double price;
    41.     public void sendEmail(){
    42.         System.out.println("发送邮件");
    43.     }
    44.     public void playGame(){
    45.         System.out.println("玩游戏");
    46.     }
    47.     public void showPrice(){
    48.         System.out.println("手机价格："+price);
    49.     }
    50. }

    ——————

    方法的重载

    重载的概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数
    类型不同即可。

    “两同一不同”：同一个类，同一个方法名；参数不同（参数列表，参数个数，参数类型）

    重载的特点：与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类
    型)。调用时，根据方法参数列表的不同来区别。

    示例：

    1. //返回两个整数的和
    2. int add(int x,int y){return x+y;}
    3. //返回三个整数的和
    4. int add(int x,int y,int z){return x+y+z;}
    5. //返回两个小数的和
    6. double add(double x,double y){return x+y;}

    ————

    • 判断是否是重载：根方法的权限修饰符，返回值类型，形参变量名，方法体都没有关系！
    • 在通过对象调用方法时，如何确定某一个指定的方法：

            方法名-->参数列表-->

    可变个数形参的方法

    1. package day01;
    2.  
    3.  
    4. /*
    5. 可变个数形参的方法：
    6.     1. jdk 5.0后新增的内容
    7.     2. 具体使用
    8.         2.1 可变个数形参的格式：数据类型 ... 变量名
    9.         2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0,1,2...等等任意个
    10.         2.3 可变个数形参方法与本类中方法名相同，形参不同的方法之间构成重载
    11.         2.4 public void show(String[] strs),会与这种方法冲突，不可共存
    12.         2.5 可变个数形参在方法的形参中，必须声明在末尾
    13.         2.6 可变个数形参当中最多只能声明一个可变形参
    15.  */
    16. public class a2 {
    17.  
    18.     public static void main(String[] args) {
    19.         a2 test = new a2();
    20.         test.show(12);
    21.         test.show("hello");
    22.         test.show("sss","sss");
    23.         test.show();
    24.  
    25.     }
    26.  
    27.     public void show(int i){
    28.         System.out.println(i);
    29.     }
    30.     public void show(String s){
    31.         System.out.println(s);
    32.     }
    33.  
    34.     public void show(String ... strs){
    35.         //类似于：public void shouw(String[] strs){}
    36.         System.out.println(3);
    37.         //把若干个参数当做数组来遍历调用就行
    38.         for(int i=1;i
    39.             System.out.println(strs[i]);
    40.         }
    41.     }
    42. //    public void show(String[] strs){
    43. //        与可变个数形参冲突，不可共存
    44. //    }
    45.     //2.5 可变个数形参在方法的形参中，必须声明在末尾，例如下面的就不对
    46. //    public void show(String ... strs,int i){
    47. //
    48. //    }
    49. }

    值传递机制

    1. 形参：方法定义时，声明的小括号内的参数

    实参：方法调用时，实际传递给形参的数据

    2. 值传递机制：

            如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。

            如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

    递归方法

    有限循环，一定要注意防止陷入死循环。

    封装和隐藏

    1. package day01;
    2.  
    3. /*
    4. 封装与隐藏
    5. 1. 问题的引入
    6.     当我们创建一个类的对象以后，我们可以通过“对象.属性”的方式，对对象的属性进行赋值，
    7.     这里，赋值操作要受到属性的数据类型和存储范围的制约，除此之外，没有其他制约。
    8.     但是，在实际为题当中我们需要给属性赋值加入额外的限制条件，这个条件不能在
    9.     属性声明时体现，我们只能通过方法进行限制条件的添加。
    10.     同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的（private）。
    11.     以上，就是体现了属性的封装性。
    12. 2. 封装性的体现
    13.     我们将类的属性私有化，同时，提供公共的（public）方法来获取（getxxx）和设置（setxxx）。
    14.     
    15. 3. 拓展
    16.     不对外暴露的私有方法
    17.     单例模式
    18.     
    19.  */
    20.  
    21. public class a3 {
    22.     public static void main(String[] args) {
    23.         Animal a = new Animal();
    24.         a.name = "猫猫";
    25.         a.age = 1;
    26. //        a.legs = 4;
    27.         a.setLegs(4);
    28.         a.show();
    29.     }
    30.  
    31. }
    32.  
    33. class Animal{
    34.     String name;
    35.     int age;
    36.     private int legs;
    37.     //对属性的设置：set
    38.     public void setLegs(int l){
    39.         if(l>=0&&l%2==0){
    40.             legs = l;
    41.         }else{
    42.             legs = 0;
    43.         }
    44.     }
    45.     //对属性的获取
    46.     public int getLegs(){
    47.         return legs;
    48.     }
    49.  
    50.     public void eat(){
    51.         System.out.println("动物进食");
    52.     }
    53.     public void show(){
    54.         System.out.println("name = "+name+",age = "+age+",legs = "+legs);
    55.     }
    56. }

    四种权限修饰符

    封装性的体现需要权限修饰符的配合。

    java规定了四种权限（从小到大排列）：private，缺省（什么也不写），protected，public。

     

     四种权限可以用来修饰类及类的内部结构：属性，方法，构造器，内部类。

    四种权限都可以用来修饰类的内部结构。

    修饰类只能有缺省和public。

    构造器（构造方法）

    任何一个类都有构造器

    1. package day01;
    2.  
    3. /*
    4. 类的结构：构造器的使用（constructor）
    5. 比如：new Person();
    6. new后面的Person()就是一个默认构造器。
    7. 注意：构造器不等同于方法
    8. 1. 说明
    9.     1.1 如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器。
    10.     1.2 定义构造器的格式：权限修饰符 类名(形参列表){}
    11.     1.3 一个类中可以定义多个构造器
    12.     1.4 一个类中定义的多个构造器可以重载
    13.     1.5 一旦我们显式的定义了类的构造器之后，系统就不在提供默认的空参的构造器
    14.     1.6 一个类中至少有一个构造器
    16. 2. 构造器的作用：
    17.     构造器的作用就是创建对象。
    18.     构造器可以给对象进行初始化。
    19.  */
    20.  
    21. public class a4 {
    22.     //new一个构造器
    23.     Parsonn p = new Parsonn();
    24.     Parsonn p1 = new Parsonn("tom");
    25. }
    26.  
    27. class Parsonn{
    28.     String name;
    29.     int age;
    30.  
    31.     //构造器
    32.     public Parsonn(){
    33.  
    34.     }
    35.     public Parsonn(String n){
    36.         name = n;
    37.     }
    38.  
    39.     public void eat(){
    40.         System.out.println(111);
    41.     }
    42. }

    补充：默认构造器的权限和类的权限相同。

    JavaBean

    JavaBean是一种java语言写成的可重用组件。

    所谓JavaBean是指符合如下标准的Java类：

    • 类是公共的
    • 有一个无参的公共的构造器
    • 有属性，且有对应的get、set方法

    用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关
    心任何改变。

    UML图

     

    this关键字的使用

    1. package java1;
    2.  
    3. /*
    4. this关键字的使用
    5. 1. this可以用来修饰属性、方法、构造器
    6. 2. this来修饰属性和方法：
    7.     this理解：代表当前对象或当前正在创建的对象
    8.     2.1 this理解为当前对象
    9.         在类的方法中，我们可以使用”this.属性“或者“this.方法”的方式，调用当前对象的属性方法。
    10.         但是，通常情况下省略“this.”。
    11.         特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用“this.”来表明此变量是属性而非形参。
    12.     2.2 构造器同2.1一样
    13. 3. this调用构造器
    14.     3.1 我们在类的构造器中，可以显式的使用“this(形参列表)”方式来调用本类中指定的其他构造器。
    15.     3.2 构造器中不能通过“this(形参列表)”的方式调用自己
    16.     3.3 如果一个类中有n个构造器，则最多有n-1个构造器中使用了“this(形参列表)”
    17.     3.4 规定：“this(形参列表)”必须声明在当前构造器的首行
    18.     3.5 构造器内部：最多只有一个“this(形参列表)”，用来调用其他构造器
    21.  */
    22.  
    23. public class PersonTest {
    24.     public static void main(String[] args) {
    25.         Person pp = new Person();
    26.         pp.setAge(1);
    27.         System.out.println(pp.getAge());
    28.         pp.eat();
    29.  
    30.     }
    31. }
    32.  
    33. class Person{
    34.     private String name;
    35.     int age;
    36.  
    37.     public void setName(String name){
    38.         //name = name;//这样写用的都是参数中的name，服从就近原则，参数的name优先级高
    39.         this.name = name;//this相当于代表的当前对象
    40.     }
    41.     public String getName(){
    42.         return name;
    43.     }
    44.     public void setAge(int age){
    45.         this.age = age;
    46.     }
    47.     public int getAge(){
    48.         return age;
    49.     }
    50.     public void eat(){
    51.         System.out.println("人吃饭");
    52.         this.sleep();
    53.     }
    54.     public void sleep(){
    55.         System.out.println("人睡觉");
    56.     }
    57.     public Person(){
    58.         this.eat();
    59.     }
    60.     public Person(String name){
    61.         this(); //表示调用无参的构造器：public void Person(){}
    62.  
    63.         this.name = name;
    64.     }
    65.     public Person(int age){
    66.  
    67.         this.age = age;
    68.  
    69.     }
    70.     public Person(String name,int age){
    71.         this(age); //同理，调用构造器
    72.         this.name = name;
    73.         //this.age = age;
    74.     }
    75.  
    76. }

    package关键字的使用

    用来导包。

    1. 为了更好的实现项目中的管理，提出了包的概念
    2. 使用package声明类或接口所属的包，声明在源文件的首行
    3. 包属于标识符，遵循标识符的命名规则
    4. 每“.”一次就代表一层文件目录

    补充：

    • 同一个包下，不能命名同名的接口和类
    • 不同的包下，可以命名同名的接口和类

     import关键字的使用

    1. 在源文件中使用import显式的导入指定包下的类或接口
    2. 声明在包的声明和类的声明之间
    3. 如果需要导入多个类或接口，那么就并列的显式多个import语句即可
    4. 举例：可以使用java.util.*的方式，一次性导入util下所有的类或接口
    5. 如果导入的类或接口是java.long包下的，或者是当前包下的，则可以省略此import语句
    6. 如果在代码中使用不同包下的同名的类，那么就需要使用类的全类名的方式指明调用的是哪个类
    7. 如果已经导入java.a包下的类，那么如果需要使用a包下的子类的话，仍然需要导入
    8. import static组合的使用：调用指定类或接口下的静态的属性或方法
  • 相关阅读:
    C#落选，Python“连庄”年度编程语言，TIOBE 1月编程语言排行榜出炉
    react-native在模拟器调试时不能连接开发服务器：Could not connect to development server.
    6种MySQL数据库平滑扩容方案剖析
    正则化提高神经网络的泛化能力
    Java与其他编程语言比较分析，编程语言选择与优点、缺点和适用场景详解
    网络——网络协议总结
    Windows ObjectType Hook 之 SecurityProcedure
    K8s上的监控系统(Grafana)使用和理解说明
    mac 编译安装php7.4 后 开启openssl扩展错误记录
    SpringCloud Alibaba系列——17Seata AT模式源码分析
  • 原文地址：https://blog.csdn.net/qq_53914420/article/details/127561293