首页 > 编程语言 >Java面向对象学习

Java面向对象学习

时间：2022-12-11 17:35:30浏览次数：43  
标签：Java name System 学习 面向对象 println 方法 public out

P60 什么是面向对象

面向过程&面向对象

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

什么是面向对象

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

P61 回顾方法的定义

回顾方法及加深

  • 方法的定义
    • 修饰符
    • 返回类型
    • break：跳出switch、跳出循环 和return的区别
    • 方法名：注意规范就OK，见名知意
    • 参数列表：（参数类型，参数名）...
    • 异常抛出：疑问，后面讲解

P62 回顾方法的调用

  • 方法的调用

    • 静态方法

    • 非静态方法

    • 形参和实参

    • 值传递和引用传递

    • this关键字

P63 类于对象的创建

类与对象的关系

  • 类是一种抽象的数据类型，它是对某-类事物整体描述/定义，但是并不能代表某一个具体的事物。

    • 动物、植物、手机、电脑....

    • Person类、 Pet类.、Car类等， 这些类都是用来描述/定义某- 类具体的事物应该具备的特点和行为

  • 对象是抽象概念的具体实例

    • 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
    • 能够体现出特点展现出功能的是具体的实例，而不是-个抽象的概念。

创建与初始化对象

  • 使用new关键字创建对象
  • 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
package com.chen.oop;

/**
 * ClassName:Student
 * Description:学生类
 *
 * @Date:2022-12-11 11:28
 * @Author:chenfp
 */
public class Student {
    //属性：字段
    String name;
    int age;

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

package com.chen.oop;

/**
 * ClassName:Application
 * Description:一个项目应该只存在一个main方法
 *
 * @Date:2022-12-11 11:28
 * @Author:chenfp
 */
public class Application {
    public static void main(String[] args) {
        //类：是抽象的，实例化
        //类实例化后会放回自己的对象！
        //student对象就是一个Student类的具体实例！
        Student xm = new Student();
        Student xh = new Student();
        xm.name = "小明";
        xm.age = 3;

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

        xh.name = "小红";
        xh.age = 3;
        System.out.println(xh.name);
        System.out.println(xh.age);

    }
}

P64 构造器详解

  • 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点：

    1. 必须和类的名字相同

    2. 必须没有返回类型，也不能写void

  • 构造器必须要掌握。

package com.chen.oop;

/**
 * ClassName:Person
 * Description:
 *
 * @Date:2022-12-11 11:42
 * @Author:chenfp
 */
public class Person {
    //一个类即使什么都不屑，也会存在一个默认的构造方法
    //显示的定义构造器
    String name;
    int age;
    //实例化初始值
    //1. 使用new关键字，本质是在调用构造器
    //2. 用来初始化值
    public Person(){
        this.name = "chenfp";
    }
    //有参构造：一旦定义了有参构造，无参必须显示定义
    public Person(String name){
        this.name=name;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

package com.chen.oop;

/**
 * ClassName:Application
 * Description:一个项目应该只存在一个main方法
 *
 * @Date:2022-12-11 11:28
 * @Author:chenfp
 */
public class Application {
    public static void main(String[] args) {
        //使用news 关键词实例化了一个对象
        Person person = new Person("shuaixiaoge",23);
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

P65 创建对象内存分析

package com.chen.oop;

/**
 * ClassName:Pet
 * Description:
 *
 * @Date:2022-12-11 11:55
 * @Author:chenfp
 */
public class Pet {
    public String name;
    public int age;
    //无参构造
    public void shout(){
        System.out.println("叫了两声！");
    }
}

package com.chen.oop;

/**
 * ClassName:Application
 * Description:一个项目应该只存在一个main方法
 *
 * @Date:2022-12-11 11:28
 * @Author:chenfp
 */
public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);

        Pet cat = new Pet();
    }
}

P66 简单小结类于对象

  1. 类与对象
    • 类是一个模板：抽象，对象是一个具体的实例
  2. 方法
    • 定义、调用
  3. 对应的引用
    • 引用类型：基本类型
    • 对象是通过引用来操作的：栈——>堆
  4. 属性：字段Field 成员变量
    • 默认初始化
      • 数字：0，0.0
      • char：u0000
      • boolean：false
      • 引用：null
    • 修饰符 属性类型 属性名 = 属性值！
  5. 对象的创建和使用
    • 必须使用new关键字创造对象，构造器 Person shuaixiaoge = new Person();
    • 对象的属性 shuaixiaoge.name;
    • 对象的方法 shuaixiaoge.sleep();
  6. 类：
    • 静态的属性 属性
    • 动态的行为 方法

P67 封装详解

封装

  • 该露的露，该藏的藏

    • 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

  • 封装(数据的隐藏)

    • 通常，应禁止直接访问-个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

  • 记住这句话就够了：属性私有，get/set

package com.chen.oop.demo04;

/**
 * ClassName:Student
 * Description:
 *
 * @Date:2022-12-11 12:17
 * @Author:chenfp
 */
//类 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 getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

package com.chen.oop;

import com.chen.oop.demo04.Student;

/**
 * ClassName:Application
 * Description:一个项目应该只存在一个main方法
 *
 * @Date:2022-12-11 11:28
 * @Author:chenfp
 */
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("帅小哥");
        System.out.println(student.getName());
        student.setAge(-1);
        System.out.println(student.getAge());
    }
}
  1. 提高程序的安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口
  4. 系统可维护增加了

P68 什么是继承

继承

  • 继承的本质是对某一批类的抽象, 从而实现对现实世界更好的建模。
  • extends的意思是“扩展”。子类是父类的扩展。
  • JAVA中类只有单继承，没有多继承！
  • 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
  • 继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。 子类继承父类，使用关键字extends来表示。
  • 子类和父类之间，从意义上讲应该具有"is a"的关系。
  • object类：在Java钟，所有的类，都默认直接或间接继承Object类。
  • super
  • 方法重写：重写——多态

P69 Super详解

super注意点

  1. super调用父类的贡藕早方法，必须在构造方法的第一个；
  2. super 必须只能出现在子类的方法或者构造方法中！
  3. super和this不能同事调用构造方法！

VS this

  • 代表的对象不同：
    • this：本身调用者这个对象
    • super：代表父类对象的应用
  • 前提：
    • this：没有继承也可以使用
    • super：只能在继承条件才可以使用
  • 构造方法：
    • this(); 本类的构造
    • super(); 父类的构造

P70 方法重写

重写：需要有继承关系，子类重写父类的方法！

  1. 方法名必须相同；
  2. 参数列表必须相同；
  3. 修饰符：范围可以扩大：public>protected>default>private；
  4. 抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException（小）-->Exception（大）

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

为什么需要重写：

  1. 父类的功能，子类不一定需要，或者不一定满足；
  2. Alt + Insert：override；

P71 什么是多态

多态

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

多态注意事项：

  1. 多态是方法的多态，属性没有多态
  2. 父类和子类，有联系 类型转换异常！ClassCastException！
  3. 存在条件：继承关系，方法需要重写。父类引用指向子类对象！
    • static方法，属于类，他不属于实例
    • final 常量：不能重写
    • private方法，不能重写

P72 instanceof和类型转换

instanceof

package com.chen.oop;

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

/**
 * ClassName:Application
 * Description:一个项目应该只存在一个main方法
 *
 * @Date:2022-12-11 11:28
 * @Author:chenfp
 */
public class Application {
    public static void main(String[] args) {
        Object object = new Student();
        System.out.println(object instanceof Student);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof Teacher);
        System.out.println(object instanceof String);
        System.out.println("=====================================");
        Person person = new Student();
        System.out.println(person instanceof Student);
        System.out.println(person instanceof Person);
        System.out.println(person instanceof Object);
        System.out.println(person instanceof Teacher);
        //System.out.println(person instanceof String);
        System.out.println("=====================================");
        Student student = new Student();
        System.out.println(student instanceof Student);
        System.out.println(student instanceof Person);
        System.out.println(student instanceof Object);
        //System.out.println(student instanceof Teacher);
        //System.out.println(person instanceof String);
    }
}

类型转换

  1. 父类引用只想子类的对象
  2. 把子类转换为父类，向上转型：不用强制转换
  3. 把父类转换为子类，向下转型：强制转换
  4. 方便方法的调用，减少重复的代码，有效提升利用率！简洁

P73 static关键字详解

P74 抽象类

抽象类

  • abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果
    修饰类，那么该类就是抽象类。
  • 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
  • 抽象类，不能使用new关键字来创建对象它是用来让子类继承的。
  • 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
  • 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
package com.chen.oop.demo08;

/**
 * ClassName:Action
 * Description:
 *
 * @Date:2022-12-11 16:35
 * @Author:chenfp
 */
//abstract 抽象类：类  extends  单继承~   （接口可以多继承）
public abstract class Action {
    //约束~有人帮我们实现~
    //abstract，抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();
    //1. 不能new抽象类，只能靠子类实现它；约束！
    //2. 抽象方法必须在抽象类中
    //3. 抽象方法必须在抽象类中
    //抽象的抽象：约束~
}

P75 接口的定义与实现

接口

  • 普通类：只有具体实现

  • 抽象类：具体实现和规范（抽象方法）都有!

  • 接口：只有规范！

  • 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能...的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人；如果你是坏人，则必须欺负好人。

  • 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

  • 00的精髓，是对对象的抽象，最能体现这一点的就是接口。 为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

声明类的关键字是class，声明接口的关键字是interface

作用

  1. 接口是约束；
  2. 定义一些方法，让不同的人实现~
  3. 接口访问默认修饰：pulic abstract
  4. 接口常量默认修饰：pullic static final
  5. 接口不能被实例化，接口中没有构造方法
  6. implements可以实现多个接口
  7. 必须要重写接口中的方法

P76 N种内部类

内部类

  • 内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
  • 1.成员内部类
  • 2.静态内部类
  • 3.局部内部类
  • 4.匿名内部类

标签：Java,name,System,学习,面向对象,println,方法,public,out
From： https://www.cnblogs.com/chen516067656/p/16973941.html

相关文章

  • 深度学习量化原理之-Python程序说明
    本文则以一个程序来说明量化的具体计算过程：importnumpyasnpdefquantization(x,s,z,alpha_q,beta_q):x_q=np.round(1/s*x+z,decimals=0)x_q=np.c......
  • Springboot学习——配置
    一、注意事项1、配置是关联相关技术的，只有引用了相关starter，配置项才会生效。2、配置的文档可以在springboot官网查看。3、配置格式是键值对二、三种配置文件格式1.ya......
  • 深度学习炼丹-不平衡样本的处理
    目录​​前言​​​一，数据层面处理方法​​​1.1，数据扩充​​​1.2，数据（重）采样​​​数据采样方法总结​​​​1.3，类别平衡采样​​​二，算法（损失函数）层面处理方法​​​2.1，Fo......
  • IDEA创建Java Web项目
    ✅作者简介：热爱国学的Java后端开发者，修心和技术同步精进。......
  • JAVA实现爬虫
    1.项目搭建2.导入相关依赖<dependency><!--jsoup只能解析网页tika能解析视频网站--><groupId>org.jsoup</groupId><artifactId>jsoup</artif......
  • 第十一周学习回顾
    目录JS学习JS基础JS中的变量与常量js基本数据类型js之bomDOM操作js的查找标签事件jQuery类库标签对象与jquery对象jquery查找标签jquery事件python主流web框架Django版本简......
  • java基础-定义和调用方法
    java基础-定义和调用方法定义静态无参方法publicstaticvoidplayGame(){System.out.println("aaaa");}定义静态无参方法publicstaticv......
  • 2022-2023-1 20221322《计算机基础与程序设计》第十五周学习总结
    20221322《计算机基础与程序设计》课程总结作业信息这个作业属于哪个课程<班级的链接>（2022-2023-1-计算机基础与程序设计）这个作业要求在哪里<作业要求的链接>(......
  • Javascript的预解析机制
    JS的预解析机制想要理解js的解析机制，不妨先了解两个概念：变量声明提升与函数声明提升。声明提升：函数声明和变量声明总是会被解释器悄悄地被"提升"到方法体的最顶部。变量......
  • 2022-2023-1 20221414《计算机基础和程序设计》第15周学习总结
    基本信息这个作业属于哪个课程2022-2023-1-计算机基础与程序设计这个作业要求在哪里2022-2023-1计算机基础与程序设计第15周作业作业正文https://www.cnbl......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99