• java面向对象(一)

    面向对象基本概念

    /**
面向过程:以步骤为单位，一步一步完成某一个具体的事情
面向对象:以对象为单位，通过调度组合不同的对象来完成某一个事情
*/
public class Test1{
    public static void main(String[] args){
    }
 }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    什么是面向对象

    面向对象是一种编程思想，是一种思考问题的思维方式。

    建立面向对象思维方式

    • 先整体，再局部
    • 先抽象，再具体
    • 能做什么，再做什么

    如何学习面向对象

    • 掌握一门面向对象语言的语法
    • 熟悉面向对象的设计原则
    • 熟悉面向对象设计模式

    类与对象

    什么是类？

    • 类是:分类、类别
    • 通过分类，我们可以区别不同的事物种类，在日常生活当中，我们常常这样做。
    • 所以，类是一组具有相同特性(属性)与行为(方法)的食物集合。

    类与对象的关系

    • 类表示一个共性的产物，是一个综合的特征，而对象，是一个个性的产物，是一个个体的特征。
    • 类由属性和方法组成
      属性:就相当于一个个的特征
      方法:就相当于人的一个个的行为，例如:说话、吃饭、唱歌、睡觉

    类和对象的定义格式

    在java中可以使用以下的语句定义一个类:
    class 类名称{
    属性名称;
    返回值类型 方法名称(){}
    }
    对象的定义:一个类要想真正的进行操作，则必须依靠对象，对象的定义格式如下:
    类名称 对象名称=new 类名称();
    按照以上的格式就可以产生对象了

    public class Test1{
    public static void main(String[] args){
      //int i=0;
      Horse h=null;//声明一个类的变量(除了八种基本数据类型以外，都是引用数据类型，包括数组)
      //创建一个Horse类型的对象，实例对象,
      h=new Horse();
      //有了对象，我们就可以调用对象的属性和方法
      h.name="赤兔马";
      h.age=350;
      h.run();//调用方法，那么方法就会被执行
      h.eat();
      //匿名对象:只能使用一次，用完后，该对象就会被释放
      new Horse().eat();
      h=null;//把对象释放
    }
  }
//自定一个类(类型)
class Horse{
    //在类中定义属性(特征)
    String name;
    int age;
    public void run(){
         System.out.println("我是"+name+"我"+age+"岁了，我还日行千里");
    public void eat(){
         System.out.println("我吃仙草，还吃得多");}
         }}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    对象与内存分析

    1.new关键字表示创建一个对象
    2.new关键字表示实例化对象
    3.new关键字表示申请内存空间

    注意:如果使用一个没有申请内存空间的对象，会报空指针异常:
    java.lang.NullPointException

    对象在内存中的结构

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    类与对象小结

    字符串是引用类型的变量，不是基本数据类型变量

    • new关键字:表示内存申请空间，也表示实例化一个对象，创建一个对象
    • 一个对象在内存中的大小，由该对象的所有属性所占的内存大小的总和。引用类型变量在32位系统上占4个字节，在64位系统上占8个字节，加上而外的对象隐性数据所占的大小
    • 相同的类型才可以赋值
    • 不同的引用，指向同一个对象，任何一个引用改变对象的值，其它引用都会反映出来
    • 编程时要注意的问题，在确定不使用对象时，要尽早释放对象:引用=null
    • 当一个堆中的对象没有被任何引用变量所指向时，该对象会被JVM的GC程序认为是垃圾对象，从而被回收。

    封装性

    封装性的概念

    • 封装性是面向对象思想的三大特征之一
    • 封装就是隐藏实现细节，仅对外提供访问接口
      封装有:
      属性的封装、方法的封装、类的封装、组件的封装、模块化封装、系统级封装…

    封装性的好处

    封装性是面向对象三大特性之一，封装的本质是隐藏细节，仅对外提供统一访问接口，一个个封装的东西又组成了另一个东西

    • 模块化
    • 信息隐藏
    • 代码重用
    • 插件化易于调试
    • 具有安全性
      封装缺点:会影响执行效率
    /**
如果属性没有封装，那么在本来之外创建对象后，可以直接访问属性
*/
//没有封装之前
public class Test2{
    public static void main(String[] args){
         Person p1 = new Person();
         p1.name='菲菲';
         p1.age=18;
         }
         }
class Person{
   //属性的封装
   String name;
   int age;
   }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    /**
封装性
private关键字：访问权限修饰符，
public 表示公有的
private表示私有的，私有的属性或方法，只能在本类中访问
公有的属性和方法，可以被类外部的其他类访问,想要在类外部访问私有属性，我们需要提供公有的方法来间接访问
通常在一个类中，属性都私有化，并对外提供getter and setter方法
*/
public class Test2{
    public static void main(String[] args){
         Person p1 = new Person();
         //强制赋值
         //p1.name='菲菲';
         //p1.age=18;
         //设置方法赋值
         p1.setName('菲菲');
         p1.setAge(18);
         }
         }
class Person{
   //属性的封装
   private String name;
   private int age;
   //getter and setter
   //对外提供一个对name属性设值的方法
   public void setName(String name){
       this.name=name;
       }
      //对外提供一个获取name属性的方法
   public void getName(String name){
       return name;
       }
   //对外提供一个对age属性设值的方法
   public void setAge(int age){
       this.age=age;
       }
   //对外提供一个获取age属性的方法
   public void getAge(int age){
       return age;
       }
   }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    成员变量和局部变量

    成员变量属于类，局部变量在方法，记住规则好区分

    1. 在类中的位置不同
      成员变量：在类中定义
      局部变量：在方法中定义或方法的参数
    2. 在内存中的位置不同
      成员变量：在堆内存(成员变量属于对象，对象进堆内存)
      局部变量：在方法中定义或方法的参数(局部变量属于方法，方法进栈内存)
    3. 生命周期不同
      成员变量：随着对象的创建而存在，随着对象的销毁而消失
      局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
    4. 初始化值不同
      成员变量：有默认初始化值，引用类型默认为null
      局部变量：没有默认初始化值，必须定义，赋值，然后才能使用
      注意：局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则
    public class Test2{
    public static void main(String[] args){
         Person p1 = new Person();
         //强制赋值
         //p1.name='菲菲';
         //p1.age=18;
         //设置方法赋值
         p1.setName('菲菲');
         p1.setAge(18);
         p1.run(10);
         }
         }
class Person{
   //属性的封装
   private String name;//成员变量，在类中定义
   private int age;//成员变量，在类中定义
   //getter and setter
   //对外提供一个对name属性设值的方法
   public void setName(String name){
       this.name=name;
       }
      //对外提供一个获取name属性的方法
   public void getName(String name){
       return name;
       }
   //对外提供一个对age属性设值的方法
   public void setAge(int age){
       this.age=age;
       }
   //对外提供一个获取age属性的方法
   public void getAge(int age){
       return age;
       }
   public void run(int len){//参数也是局部变量
       int m=len;//m也是局部变量
       System.out.println("我跑了"+m+"米");
}
   }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

    在这里插入图片描述

    构造方法

    构造方法有别于普通方法，可以看作是一个特殊的方法，是类在创建对象时自动调用的方法，可为类的创建初始化数据用

    什么是构造方法

    • 构造方法就是类构造对象时调用的方法，用于对象的初始化工作
    • 构造方法是实例化一个类的对象时，也就是new的时候，最先调用的方法。
    • 构造方法的定义
      构造方法是在类中定义的，构造方法的定义格式：方法名与类名称相同，无返回值类型的声明。
    • 对象的实例化语法
      Dog dog=new Dog();//new Dog 后面有个括号，带括号表示调用了方法，此时调用的方法就是构造方法了
      构造方法有别于普通方法，可以看作是一个特殊的方法，是类在创建对象时自动调用的方法，可为类的创建初始化数据用
    /**
构造方法：构造方法是在类中定义的，构造方法的定义格式:方法名称与类名称相同，无返回值类型的声明。
*/
public class Test3{
    public static void main(String[] args){
        Dog dog=new Dog();
        Dog dog1=new Dog("wangwang",5);
    }
    }
class Dog{
//默认构造方法，通常有其它构造方法时，要保留默认构造方法
   public Dog(){
       System.out.println("构造方法执行了");
   }
   public Dog(String name,int age){
       this.name=name;
       this.age=age;
       System.out.println("带两个参数的构造方法执行了");}
   //属性的封装
   private String name;
   private int age;
   //getter and setter
   //对外提供一个对name属性设值的方法
   public void setName(String name){
       this.name=name;
       }
      //对外提供一个获取name属性的方法
   public void getName(String name){
       return name;
       }
   //对外提供一个对age属性设值的方法
   public void setAge(int age){
       this.age=age;
       }
   //对外提供一个获取age属性的方法
   public void getAge(int age){
       return age;
       }
   }
    


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    1. 构造方法就是类构造对象时调用的方法，用于对象的初始化工作
    2. 构造方法是实例化一个类的对象时，也就是new的时候，最先调用的方法
      构造方法重载
      无参构造方法:
      public Dog(){}
      带一个参数的构造方法：
      public Dog(String name){
      this.name=name;}
      带多个参数的构造方法：
      public Dog(String name,int age){
      this.name=name;
      this.age=age;}

    构造方法小结

    1. 构造方法名称与类名相同，没有返回值声明(包括void)
    2. 构造方法用于初始化数据(属性)
    3. 每一个类中都会有一个默认的无参的构造方法
    4. 如果类中有显示的构造方法，那么默认构造方法将无效
    5. 如果有显示的构造方法，还想保留默认构造方法，需要显示的写出来
    6. 构造方法可以有多个，但参数不一样，成为构造方法的重载
    7. 在构造方法中调用另一个构造方法，使用this(…),该句代码必须在第一句。
    8. 构造方法之间的调用，必须要有出口
    9. 给对象初始化数据可以使用构造方法或setter方法，通常情况下，两者都会保留
    10. 一个好的编程习惯是要保留默认的构造方法(为了方便一些框架代码使用反射来创建对象)
    11. private Dog(){},构造方法私有化，当我们的需求是为了保证该类只有一个对象时。
      什么时候一个类只需要一个对象？比如，工具类（没有属性的类，只有行为）并且该工具对象被频繁使用。权衡只用一个对象与产生多个对象的内存使用，来确定该类是否要定义为只需要一个对象。
  • 相关阅读:
    掌动智能：替代JMeter的压力测试工具有哪些
    前端网络---网络安全
    自动驾驶的法律和伦理问题
    【无标题】
    IOS常见的bug
    计算机网络（二）：物理层
    android 11及以上保存图片视频到相册
    SpringBoot + MyBatis 在 jar 中可以启动但是 Idea中无法启动的原因
    展锐平台NewGallery2内存泄露分析
    【图像分割】DeepLabV3+
  • 原文地址：https://blog.csdn.net/fanfangyu/article/details/126337265