java对象

最新推荐文章于 2024-07-14 22:26:46 发布

Good_Huang_

最新推荐文章于 2024-07-14 22:26:46 发布

阅读量127

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/Good_Huang_/article/details/109404534

版权

Java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

面向过程 & 面向对象

面向过程思想
- 步骤清晰简单，第一步做什么，第二部做什么…
- 面对过程适合处理一些较为简单的问题
面向对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
对于描述复杂的事务，为了从宏观上把握、从整体上合理分析，我们需要使用面向对面的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

面向对象编程(Ovject-Oriented Programming，OOP)
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
抽象
三大特性
- 封装
- 继承
- 多态
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
- 动物，植物，手机，电脑…
- Person类，Pet类，Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例
- 张三就是人的一个具体实例，张三家里的旺财就是够的一个具体实例。
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

创建与初始化对象

使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有一下俩个特点
1. 必须和类的名字相同
2. 必须没有返回类型，也不能写void
构造器必须要掌握

package com.oop.demo02;

//学生类
public class Student {

    //属性：字段

    String name;
    int age ;


    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}


  // Perspm-->身高，体重，年龄，国家
  //学程序好？  对世界进行更高的建模！


package com.oop.demo02;

public class Application {
    public static void main(String[] args) {

        //类：抽象的，实例化

        //类实例化后会返回一个自己的对象！
        //student 对象就是一个Student类的具体实例！

        Student xiaoming = new Student();
        Student xiaohong = new Student();

        xiaoming.name="小明";
        xiaoming.age=3;

        xiaohong.name="小红";
        xiaohong.age=2;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);

        xiaohong.study();

    }
}

构造器

//java--> class
public class Person {


   //一个类即使什么都不屑，它也会存在一个方法
   //显示的定义构造器
   String name;
   int age;


   //实例化初始值
    //1.使用new  关键字，本质是在调用构造器
    //2.用来初始化值
    public Person(){
      this.name="嘿嘿";
    }

     //有参构造:
    // 一旦定义了有参构造，无参就必须显式定义
    public Person(String name ,int  age){
     this.name=name;
     this.age=age;

    }




}

/*
public static void main(String[] args) {
        Person person = new Person("嘿嘿","10");

        //new  实例化了一个对象
        System.out.println(person.name);

    }


    构造器：
    1.和类名相同
    2.没有返回值

    作用：
    1.new 本质在调用构造方法
    2.初始化对象的值

    注意点:
    1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

    //alt+insert

    this.  =               当前类的
 */

内存分析

在这里插入图片描述

public class Pet {
     public String  name ;
     public  int age ;

     //无参构造


    public  void shout(){
        System.out.println(name+"叫了一下");

    }
}

/*
 public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name="旺财";
        dog.age=1;
        dog.shout();

        System.out.println(dog.name);
        System.out.println(dog.age);

         Pet cat=new Pet();

    }
 */

小结

 /*
       1.类与对象
       类是一个模板：抽象，对象是一个具体的实例
       2.方法
       定义、调用！

       3.对应的引用
       引用队形： 基本类型（8);
       对象是通过引用来操作的：栈-->堆

       3.属性：字段 Field成员变量
       默认初始化：
       数字 ： 0  0.0
       char ：u0000
       boolean： false
       应用： null
       修饰符 属性类型  属性名 =属性值

       5.对象的创建和使用
       - 必须使用new  关键字创造对象，构造器 Person ha = new Person;
       - 对象的属性  ha.name；
       - 对象的方法 ha.sleep()
       
       6.类；
       静态的属性   属性
       动态的行为   方法
       
       
       封装、继承、多态

     */

封装

该露的露，该藏的藏
- 我们程序设计要追求”高内聚，低耦合“。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
属性私有 .get/set

//类  private:私有
public class Student {

    //属性私有
    private String name;  //姓名
    private  int id;    //年龄
    private  char sex;  //性别
    private  int age;

    //提供一些可以操作这个属性的方法！
    //提供一些public 的get.set方法

    //get 获得这个数据

    public  String getName(){
        return this.name;
    }

    // set 给这个数据设置值

    public void  setName(String name){
        this.name=name;
    }

    //alt+insert

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
         if(age >120 || age<=0){
            this.age=3;
        }else{
            this.age = age;
        }
    }
}


/*
1.提高程序的安全性：保护诗句
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加了
 */


/*
public class Application {
    public static void main(String[] args) {


        Student a = new Student();
        a.setName("张三");

        System.out.println(a.getName());

        a.setAge(999);  //不合法
        System.out.println(a.getAge());
    }



}
*/

继承

继承的本质是对某一批类的抽象，从而实现对显示世界更好的建模。
***exends***的意思是”扩展“。子类是父类的扩展。
Java中类只有单继承，没有多继承！（一个儿子只能由一个爸爸，但是一个爸爸可以有多个儿子）
继承是类与类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有”is a“的关系。

//在Java中：所有的类，都默认直接或者间接继承Object
// Person 人 ：父类
public class Person /*extends Object*/{

    //  public   最高权限
    //protected   受保护的
    //default   默认的
    //private   私有的
     private int money=10_0000_0000;


     public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney(){
         return  money;
    }
    public  void setMoney(int money){
         this.money=money;
    }
}


/*
//学生  is  人 ：派生类：子类
//子类继承了父类，就会拥有父亲的全部方法！
public class  Student extends  Person {

    //Ctrl+h

}

 */


/*

public class Application {
     public static void main(String[] args) {

          Student student = new Student();
          student.say();
          student.setMoney(10000);
          System.out.println(student.getMoney());

          Person person = new Person();



     }
     
}


//Ctrl+h

 */

object类

super

public class Person /*extends Object*/{


    public Person(String name){
        System.out.println("Person无参构造执行");
    }


    protected  String  name="haha";


    public   void print(){
        System.out.println("Person");
    }


}
/*
public class  Student extends  Person {


    public Student(){
        //隐藏代码：调用了父类的无参构造
        //调用父类的构造器，必须要在子类的第一行


        super("name");


        System.out.println("Stundet无参构造执行");
    }




    private String name="嘿嘿 ";



    public void Print(){
        System.out.println("Student");
    }

    public void  test1(){

        Print();   //Student

        this.Print();   //Student

        super.print();  //Person

    }



    public  void text(String name){

        System.out.println(name);
        System.out.println(this.name);  //  嘿嘿
        System.out.println(super.name);   // 哈哈
    }



}


public class Application {
     public static void main(String[] args) {

        Student student=new Student();


       student.text("嘻嘻");

        //student.test1();



     }
}

 */

super注意点：
         1.super调用父类的构造方法，必须在构造方法的第一个
         2.super 必须只能出现在子类的方法或者构造方法中
         3.super 和 this 不能同时调用构造方法！

VS  this
         代表的对象不同：
         this : 本身调用者这个对象
         super : 代表父类对象的应用

         前提
         this ：没有继承也可以使用
         super ： 只能在继承条件才可以使用

         构造方法
         this(); 本类的构造方法
         super(); 父类的构造方法

方法重写 —> 多态

//重写都是方法的重写，和属性无关
public class B {

    public  void test(){
        System.out.println("B==>test()");
    }
}

/*
public class A extends B{


    //Override 重写
    @Override  //注解：有功能的注释！
    public void test() {

        System.out.println("A----> ");
    }
}


public class Application {
    //静态的方法和非静态方法区别很大！
    //静态方法：  //方法的调用只有左边，定义的数据类型有关
    // 非静态： 重写

    public static void main(String[] args) {

         //方法的调用只和左边，定义的数据类型有关
      A a=new A();
      a.test();   //A


      //父类的应用指向了子类
      B b= new A();  //子类重写了父类的方法
      b.test();   //B


重写：需要有继承关系，子类重写父类的方法！
         1.方法名必须相同
         2.参数列表必须相同
         3.修饰符：范围可以扩大：    public> Perotected> Default>private
         3.抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException-->Exception（大）


         重写,子类的方法和父类必须要一致：方法体不同！

         为什么需要重写：
         1.父类的功能，子类不一定需要，或者不一定满足！

         AlT + Insert :override;



     }
}

 */

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多(父类，有关系的类)
多态存在的脚尖
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
注意：多态是方法的多态，属性没有多态性。


public class Person {
    public void run(){
        System.out.println("run");
    }

}


/*
多态注意事项：
  1.多态是方法的多态，属性没有多态
  2.父类和子类,有联系  类型转换异常！ classCastException!
  3.存在条件，继承关系,方法需要重写,父类引用指向子类对象！  Father f1 =new Sun();


  1.static 方法，属于类，它不属于实例
  2.final  常量;
  3.private方法;

 */


/*

public class Student extends Person {

    @Override
    public void run() {
        System.out.println("Student run");
    }


    public  void  eat(){
        System.out.println("eat");
    }



}


/*

import com.oop.demo06.Person;
import com.oop.demo06.Student;

public class Application {

    public static void main(String[] args) {
//一个对象的实际类型是确定的
        //new Student
        //new  Person

        //可以指向的引用类型就不确定了,父类的引用指向子类

        //Student 能调用的方法都是自己的或者继承父类的！
        Student s1 =new Student();

        //Person 父类型 ，可以指向子类,但是不能调用子类独有 的方法
        Person s2 =new Student();
        Object s3 =new Student();


        ///对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！

        s1.eat();
        ((Student) s2).eat();  //子类重写了父类的方法，执行子类的方法



    }
}

 */

instanceof

instanceof （类型转换）引用类型，判断一个对象是什么类型


public class Student extends Person {
    public  void  go (){
        System.out.println("Student go");
    }
    /*
    public class Application {
    public static void main(String[] args) {
     //Object > Person > Student
        //Object > Person > Teacher
        //Object > String

        Object object=new Student();
        System.out.println(object instanceof Student);      //true
        System.out.println(object instanceof Person);       //true
        System.out.println(object instanceof Object);       //true
        System.out.println(object instanceof String);       //false
        System.out.println(object instanceof Teacher);      //false
        System.out.println("==========================================");

        Person person=new Student();
        System.out.println(person instanceof Student);      //true
        System.out.println(person instanceof Person);       //true
        System.out.println(person instanceof Object);       //true
        //System.out.println(person instanceof String);     编译报错
        System.out.println(person instanceof Teacher);      //false
        System.out.println("==========================================");

        Student student=new Student();
        System.out.println(student instanceof Student);      //true
        System.out.println(student instanceof Person);       //true
        System.out.println(student instanceof Object);       //true
        //System.out.println(person instanceof String);     编译报错
        //System.out.println(student instanceof Teacher);   编译报错
        System.out.println("==========================================");
        }
        }
     */
}

/*
public class Application {
    public static void main(String[] args) {
   
         1.父类引用指向子类的对象
         2.把子类转换成父类，向上转型;
         3.把父类转换成子类，向下转型; 强制转换
         4.方便方法的调用,减少重复的代码，简介

         抽象： 分装 继承 多态!  抽象类,接口
    




    //类型之间的转换 : 父         子

    //子类转换为父类，可能丢失自己的本来的一些方法
    Person a =new Student();
        ((Student)a).go();
                a.run();


                Student student=new Student();
                student.go();
                Person person =student;



                }

                }
 */

Good_Huang_

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
java对象

面向过程 & 面向对象面向过程思想步骤清晰简单，第一步做什么，第二部做什么…面对过程适合处理一些较为简单的问题面向对象思想物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题，适合处理需要多人协作的问题！对于描述复杂的事务，为了从宏观上把握、从整体上合理分析，我们需要使用面向对面的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
复制链接

扫一扫