当前位置：首页 > news >正文

java面向对象(一)

news 来源：原创 2024/5/3 17:26:13

面向对象基本概念

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

什么是面向对象

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

建立面向对象思维方式

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

如何学习面向对象

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

类与对象

什么是类？

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

类与对象的关系

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

类和对象的定义格式

在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.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;
   }

/**
封装性
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;
       }
   }

成员变量和局部变量

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

在类中的位置不同
成员变量：在类中定义
局部变量：在方法中定义或方法的参数
在内存中的位置不同
成员变量：在堆内存(成员变量属于对象，对象进堆内存)
局部变量：在方法中定义或方法的参数(局部变量属于方法，方法进栈内存)
生命周期不同
成员变量：随着对象的创建而存在，随着对象的销毁而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同
成员变量：有默认初始化值，引用类型默认为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+"米");
}
   }

在这里插入图片描述

构造方法

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

什么是构造方法

构造方法就是类构造对象时调用的方法，用于对象的初始化工作
构造方法是实例化一个类的对象时，也就是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;
       }
   }
    
*/

构造方法就是类构造对象时调用的方法，用于对象的初始化工作
构造方法是实例化一个类的对象时，也就是new的时候，最先调用的方法
构造方法重载
无参构造方法:
public Dog(){}
带一个参数的构造方法：
public Dog(String name){
this.name=name;}
带多个参数的构造方法：
public Dog(String name,int age){
this.name=name;
this.age=age;}

构造方法小结

构造方法名称与类名相同，没有返回值声明(包括void)
构造方法用于初始化数据(属性)
每一个类中都会有一个默认的无参的构造方法
如果类中有显示的构造方法，那么默认构造方法将无效
如果有显示的构造方法，还想保留默认构造方法，需要显示的写出来
构造方法可以有多个，但参数不一样，成为构造方法的重载
在构造方法中调用另一个构造方法，使用this(…),该句代码必须在第一句。
构造方法之间的调用，必须要有出口
给对象初始化数据可以使用构造方法或setter方法，通常情况下，两者都会保留
一个好的编程习惯是要保留默认的构造方法(为了方便一些框架代码使用反射来创建对象)
private Dog(){},构造方法私有化，当我们的需求是为了保证该类只有一个对象时。
什么时候一个类只需要一个对象？比如，工具类（没有属性的类，只有行为）并且该工具对象被频繁使用。权衡只用一个对象与产生多个对象的内存使用，来确定该类是否要定义为只需要一个对象。