面向对象编程（OP）

最新推荐文章于 2023-02-16 07:45:00 发布
最新推荐文章于 2023-02-16 07:45:00 发布
阅读量960 收藏 2
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46378828/article/details/106928759
版权

面向对象编程（OP）

1.初始面向对象（OOP）

本质：以类的方式组织代码，以对象的组织（封装）数据。

三大特性：封装、继承、多态

2.方法回顾和加深

方法的定义：

break 跳出循环

return 结束

package com.OOP;

import java.io.IOException;

//Demo01 类
public class Demo01 {
    //main 方法
    public static void main(String[] args) {

    }
    /*
    修饰符 返回值类型 方法名（……）{
    //方法体
    return 返回值；
    }
    */
    //return 结束方法，返回一个结果
    public static String sayhello(){
        return"hello world!";
    }
    public int max(int a,int b){
        return a>b?a:b;
    }
    //数组下标越界
    public  void readFile(String file)throws IOException{

    }

}

方法名：注意规范，

参数列表：（参数类型，参数名）……

异常抛出

方法的调用

静态方法

非静态方法

package com.OOP;

public class Demo02 {
    public static void main(String[] args) {
        //静态方法 static
        //实例化这个类new
        //对象类型  对象名=对象值
        Student student = new Student();

        student.say();
    }

}

package com.OOP;
//学生类
public class Student {
    //    //非静态方法
    public void say(){
        System.out.println("学生说话了");
    }

}

形参和实参

package com.OOP;

public class Demo03 {
    public static void main(String[] args) {
        int add=Demo03.add(1,2);
        System.out.println(add);
    }
    public static int add(int a, int b){
        return a+b;
    }
}

值传递和引用传递

package com.OOP;

//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);//1
        Demo04.change(a);
        System.out.println(a);//1
    }
    //返回值为空
    public static void change(int a){
        a=10;
    }
}

package com.OOP;

//引用传递：对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {

        Person person = new Person();
        System.out.println(person.name);//null
        Demo05.change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){
//person是一个对象：指向的----> Person person = new Person();这是一个具体的人，可以改变属性
        person.name="小蜜蜂";
    }
    //定义了一个Person类，有一个属性：name
    static class Person{
        String name;//NULL
    }
}

this关键字

3.对象的创建分析

使用new关键字创建对象

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

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

    1. 必须和类的名字相同
    2. 必须没有返回类型,也不能写void
    package com.OOP.Demo02;

//学生
public class Students {
   //属性 ：字段
    String name;
    int age;
    public  void study(){
        System.out.println(this.name+"在学习");
    }

}

    package com.OOP.Demo02;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象
        //students对象就是一个Students类的具体实例
        Students xiaoming = new Students();
        Students xiaohong = new Students();
        xiaoming.name="小明";
        xiaohong.name="小红";
        xiaoming.age=3;
        xiaohong.age=3;
        System.out.println(xiaoming.name);
        System.out.println(xiaohong.name);
        System.out.println(xiaoming.age);
        System.out.println(xiaohong.age);
    }
}

    构造器必须掌握

    package com.OOP.Demo02;

//java……>class
public class Person {
    //一个类即使什么都不写，也会存在一个方法
    String name;
    //显示的定义构造器

    //实例化初始值
    //1.使用new关键字，必须要有构造器
   /* public Person(){
        this.name="小蜜蜂";
    }
    */
    public  Person(){

    }


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

    //alt+insert   生产构造器
/*
构造器
1.和类名相同
2.没有返回值
作用：
1.new本质在调用构造函数
2.初始化对象值
注意点：
1.定义有参构造之后，想要使用无参构造，显示的定义的一个无参的构造

Alt+Insert
 this.=
 */
}


package com.OOP.Demo02;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //new 实例化的一个对象
        //Person person= new Person();
       Person person= new Person("小蜜蜂");
        System.out.println(person.name);
    }
}

package com.OOP.Demo03;

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

    //无参构造
    public void shout(){
        System.out.println("叫了一声");
    }
}

package com.OOP;

import com.OOP.Demo03.Pet;

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);
    }
}
/*
1.类与对象
类是一个模板，抽象对象是一个具体的实例
2.方法
定义，调用！
3.对应的引用
引用类型：基本类型（8）
对象是通过引用来操作的：栈--->堆
4.属性：字段Field 成员变量
默认初始化
数字：0  0.0
char：u0000
Boolean：false
引用：NUll
修饰符   属性类型  属性名=属性值！
5.对象的创建和使用
必须使用new 关键字创造对象，构造器  Person xiaoming=new  Person
对象的属性xiaoming.name
对象的方法：xiaoming.sleep()
6.类
静态的属性   属性
动态的行为   方法
*封装、继承、多态*
 */

4.面向对象三大特性

封装

“高内聚，低耦合”：高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合仅暴露少量的方法给外部使用

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

属性私有，get/set

package com.OOP.Demo04;

/*
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.提高系统的可维护性
 */
public class Application {
    public static void main(String[] args) {
       Student s1= new Student();
       s1.setName("小蜜蜂");

        System.out.println(s1.getName());
        s1.setAge(-1);//不合法
        System.out.println(s1.getAge());
    }
}

package com.OOP.Demo04;

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

继承

继承本质是对某一批类的抽象，从而实现对现实世界更好的建模

extends的意思是“扩展”，子类是父类的扩展

Java中类只有单继承，没有多继承！

继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等

继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends来表示

子类和父类之间，从意义上讲应该具有“is a”的关系

object类

package com.OOP.Demo05;

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

    //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;
    }
}

package com.OOP.Demo05;

//Teacher是人：派生类，子类
public class Teacher extends Person{
}

package com.OOP.Demo05;

//学生 is 人：派生类，子类
//子类继承了父类，就会拥有父类和全部方法
public class Student extends Person{
    //ctrl+H

}

package com.OOP.Demo05;

public class Application {
    public static void main(String[] args) {
       Student student= new Student();
       student.say();
        System.out.println(student.money);
    }
}

super

package com.OOP.Demo05;

//在Java中，所有的类，都默认直接或者间接继承Object
//Person 人:父类
public class Person/*extends Object*/ {
    protected String name="小蜜蜂";

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




}

package com.OOP.Demo05;

//学生 is 人：派生类，子类
//子类继承了父类，就会拥有父类和全部方法
public class Student extends Person{
    //ctrl+H

    private  String name="大蜜蜂";

    //私有的东西无法被继承
    //隐藏代码：调用了父类的无参构造
    //super（）；调用父类的构造器，必须要在子类构造器的第一行
    //this（）；调用父类的构造器，必须要在子类构造器的第一行
    public void print(){
        System.out.println("Student");
    }

    public  void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }
    public void test(String name){
        System.out.println(name);//xiaomifeng
        System.out.println(this.name);//大蜜蜂
        System.out.println(super.name);//小蜜蜂
    }
}

package com.OOP.Demo05;

public class Application {
    public static void main(String[] args) {
       Student student= new Student();
      //student.test("xiaomifeng");
      student.test1();
    }
}

package com.OOP.Demo05;

//Teacher是人：派生类，子类
public class Teacher extends Person{
}

super注意点：
   1.super调用父类的构造方法，必须在构造方法的第一个
   2.super必须只能出现在子类的方法或者构造方法中！
   3.super和this不能同时调用构造方法
Vs this：
代表的对象不同：
   this:本身调用者这个对象
   super：代表父类对象的引用
前提：
    this：没有继承也可以使用
    super：只能在继承条件下才能使用
构造方法:
     this();本类的构造
     super()；父类的构造

方法重写

package com.OOP.Demo05;

import com.sun.xml.internal.ws.addressing.WsaActionUtil;

public class A extends B {
   /* public void test(){
        System.out.println("A=>test()");
    }

    */

    //Override 重写
    @Override//注释：有功能的注释！
    public void test() {
        System.out.println("A>=test()");
    }
}

package com.OOP.Demo05;

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

    //非静态方法：重写
    public static void main(String[] args){

    A a=new A();
    a.test();//A

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

package com.OOP.Demo05;

//重写都是方法的重写，和属性无关
public class B {
    public void test() {
        System.out.println("B=>test()");
    }
}


重写：需要有继承关系，子类重写父类的方法！
     1.方法名必须相同
     2.参数列表必须相同
     3.修饰符：数值可以扩大但是不能缩小：public>Protected>Default>private
     4.抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundExcetion--->Exception(大)
重写，子类的方法和父类的方法必须要一致，方法体不同
为什么需要重写？
     1.父类的功能子类不一定需要或者不一定满足！
     ALt+Insert： override；

多态

动态编译：类型：可扩展性

即同一方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）

多态存在的条件：

有继承关系

子类重写父类方法

父类引用指向子类对象

package com.OOP.Demo06;

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

}

package com.OOP.Demo06;

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

    public void eat(){
        System.out.println ("eat");
    }
}
/*注意事项
    1.多态是方法的多态
    2父类和子类，有联系，类型转换异常！ ClassCastException
    3.存在条件：继承关系需要重写，父类引用指向子类对象！ father f1=new Son（）；
      不能重写的方法
      1.static 方法 属于类，它不属于实例
      2.final常量
      3.private方法
 */

package com.OOP.Demo06;

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 ();

        //对象能执行那些方法，主要看对象左边的类型和右边关系不大
        s2.run ();//子类重写了父类的方法，执行子类的方法
        s1.run ();
        s1.eat ();
        //s2.eat();//不能用
    }
}

注意：多态是方法的多态，属性没有多态

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

package com.OOP.Demo06;

public class Application {
    public static void main(String[] args) {
        //类型之间的转换：父  子
        //高
        Person obj=new Student ();
        //student将这个对象转换为Student类型，我们就可以使用student类型的方法了
        //子类转换为父类，可能丢失之间本来的一些方法
        Student student = ( Student ) obj;
        student.go ( );
        Person person=student;
        
        /*
        1.父类引用指向子类的时候
        2.把子类转换为父类，向上转型
        3.把父类转换为子类，向下转型，强制转换
        4.方便方法的调用，减少重复的代码
         */
        
        
    /*
        //Object>String
        //Object>Person>Teacher
        //Object>Person>Student
        Object object = new Student ( );

        //System.out.println ( x instanceof Y);
        //能不能编译通过
        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 Teacher);//false
        System.out.println (object instanceof String );//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 Teacher);//false
      // System.out.println (person instanceof String );//编译报错！
        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 (student instanceof Teacher);//编译报错
        //System.out.println (student instanceof String );//编译报错
    
    */
    }
}

package com.OOP.Demo06;

public class Person {

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

}

package com.OOP.Demo06;

public class Student extends Person {

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

}

package com.OOP.Demo06;

public class Teacher extends Person {
}

static

package com.OOP.Demo07;

//static
public class Student {
    private static int age;//静态的变量
    private double score;//非静态的变量

    public void run(){
        go ();
    }
    public static void go(){

    }

    public static void main(String[] args) {
        //run();//编译错误
    }
    /*public static void main(String[] args) {
        Student s1 = new Student ( );

        System.out.println (Student.age);
        System.out.println (s1.age);
        System.out.println (s1.score);
    }
     */
}

package com.OOP.Demo07;

public class Person {
    {
        //2:初始值
        //代码块（匿名代码块）
        System.out.println ("匿名代码块" );
    }
    //1:只执行一次
    static {
        //非静态代码块
        System.out.println ("静态代码块" );
    }
    //3
    public Person(){
        System.out.println ("构造方法" );
    }

    public static void main(String[] args) {

     Person person1 = new Person ( );
        System.out.println ("==================" );
     Person person2 = new Person ( );
    }

}

package com.OOP.Demo07;
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {
    public static void main(String[] args) {
        System.out.println (random () );
        System.out.println ( PI);
    }
}

5.抽象类和接口

抽象类

abstract修饰符

package com.OOP.Demo08;

//abstract 抽象类 ：类，extends： 单继承  （接口可以多继承）
public abstract class Action {
    //约束
    //abstract 抽象方法，只有方法名字，没有方法实现
    public abstract void doSomething();
    
    //1.不能new这个抽象类只能靠子类去实现它：约束！
    //2.抽象类中可以写普通方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象：约束
}

package com.OOP.Demo08;

//抽象类的所有方法，继承了它的子类，都必须实现它的方法
public class A extends Action {
    @Override
    public void doSomething() {

    }
}

接口

只有规范！

约束和实现分离

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

接口的本质是契约

package com.OOP.Demo09;

//抽象的思维

// interface 定义的关键字,接口都需要是实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的 public abstract

    //常量 publi static final
    int AGE=99;
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

package com.OOP.Demo09;

//抽象类：extens
//类 可以实现接口 implements 接口
//实现接口的类，就需要实现接口的方法
//多继承  利用接口实现多继承
public class UserServiceImpl implements  UserService,TimeService{

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

package com.OOP.Demo09;

public interface TimeService {
   void  timer();
}

作用：
    1.约束
    2.定义一些方法，让不同的人实现
    3.public abstract
    4.publi static final
    5.接口不能被实例化，接口中没有构造方法
    6.implements可以实现多个接口
    7.必须重写接口中的方法

6.内部类及OOP实战

  1. 成员内部类
  2. 静态内部类
  3. 局部内部类
  4. 匿名内部类
package com.OOP.Demo10;

public class Outer {
   private int id=10;
    public void out(){
        System.out.println ( "这是外部类的方法");
    }
    //局部内部类
    public void method(){
        class Inner{
            public void in(){
                
            }
        }
    }
    //一个java类中可以有多个class类，但是只能有一个public class
   /* class Inner{
        public void in(){
            System.out.println ("这是内部类的方法" );
        }
        //获得外部类的私有属性
        public void getID(){
            System.out.println (id );
        }
    }
    
    */
}

package com.OOP.Demo10;

public class Test {
    public static void main(String[] args) {
        //Apple apple = new Apple ( );
        //没有名字去初始化类,不用将实例保持到变量中
        new Apple ().eat ();
        //匿名内部类
       UserService userService= new UserService ( ) {
           @Override
           public void hello() {

           }
       };
    }
}
class Apple{
    public void eat(){
        System.out.println ("1" );
    }
}
interface  UserService{
    void hello();
}
得。
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Javascript oop设计模式 面向对象编程简单实例介绍
11-26
Javascript oop设计模式 面向对象编程 最初我们写js代码的时候是这么写 function checkName(){ //验证姓名 } function checkEmail(){ //验证邮箱 } function checkPassword(){ //验证密码 } 这种方式会...
c语言四则运算（op）
m0_74866121的博客
11-05 4543
题目描述 给你一个简单的四则运算表达式，包含两个实数和一个运算符，请编程计算出结果 输入 表达式的格式为：s1 op s2， s1和s2是两个实数，op表示的是运算符(+,-,*,/)，也可能是其他字符 输出 如果运算符合法，输出表达式的值；若运算符不合法或进行除法运算时除数是0，则输出"Wrong input!"。最后结果小数点后保留两位。 #include<stdio.h> #include<math.h> int main(void) { char op; dou
【编程思想】理解面向过程（OPP）、面向对象（OOP）、面向切面（AOP）
DreamSun的博客
02-16 1845
但是也有它的缺点，最明显的就是关注点聚焦时，面向对象无法简单的解决这个问题，一个关注点是面向所有而不是单一的类，不受类的边界的约束，因此OOP无法将关注点聚焦来解决，只能分散到各个类中。大多数支持面向对象的语言，同时也支持面向过程，不论是JAVA、PHP，还是JS，它们都还无法完全面向对象，因为面向过程是必然的，面向过程代表着必要的程序流程，调动对象进行组合或对象内部能力的实现，都一定会存在“过程”，它最终还是需要通过拆分步骤来指导最具体的执行细节。else的判断，这段代码，无疑是很恶心的。
简单解释op（面向过程procedure- oriented）与oo（面向对象object-oriented）
ilovepengqi的博客
10-06 2808
一句话概括： op是具体作为模块的拼凑。 oo是抽象作为模块的组合。   比如我们制作一样东西，而这样东西是用很多小东西拼在一起形成的，在这里我们如果使用一个造车的小例子来解释一下op与oo思想。 1、op的思想          比如制作一辆汽车，这两汽车首先得能跑，那么就需要轮子，光是轮子也不行，接着就有了支架，有了支架也还不行，想要动起来就得有动力才行，这时候发动机上场了，有了动
【Tensorflow】op的理解和自定义损失函数
littlemichelle
08-15 3254
tensorflow中的基本概念 本文是在阅读官方文档后的一些个人理解。 官方文档地址：https://www.tensorflow.org/versions/r0.12/get_started/basic_usage.html#basic-usage 关于tensor和op的理解 Nodes in the graph are called ops (short for operation...
计算机控制op是啥,可编程序控制器
weixin_31653131的博客
07-08 1162
OP系列是可编程序控制器的小型人机界面,以文字或指示灯等形式监视、修改 PLC内部寄存器或继电器的数值及状态，从而使操作人员能够自如地控制机器设备。系列显示器有以下特长： 通过编辑软件 OP20 在计算机上作画，自由输入汉字及设定 PLC 地址，使用串口通讯下载画面 通讯协议和画面数据一同下载到显示器，无须 PLC 编写通讯程序 对应 PLC 机种广泛，包括三菱 FX系列、欧姆龙C 系列、西...
samenvatting_op:来自鲁汶的面向对象编程总结课程
06-27
面向对象编程小结 来自鲁汶的面向对象编程总结课程 安装 Jekyll/Github 页面 为了能够在本地进行调整，您需要 Ruby 和 Jekyll。 苹果机/Linux 在 mac/linux 上，你可以只使用. 视窗 在 Windows 上，它有点复杂。 我...
toop：Tobias的面向对象库
02-09
Tobias的面向对象编程库。 该库的要点是要提出要点。 面向对象编程既有趣又令人满意。 该库旨在将JS中的所有内容包装到可在依赖项注入系统中使用或直接使用的类。 它在Typescript中实现，但在纯JavaScript中也可以...
PHP 面向对象程序设计（oop）学习笔记 (五) – PHP 命名空间
12-19
命名空间概述 ...为很长的标识符名称(通常是为了缓解第一类问题而定义的)创建一个别名（或简短）的名称，提高源代码的可读性。...定义命名空间 ...命名空间通过关键字namespace 来声明。如果一个文件中包含命名空
C#编程科学计算器.doc
11-28
9. 面向对象编程：在C#中，面向对象编程是指使用对象和类来组织代码。在本程序中，我们可以看到面向对象编程的思想，例如使用类和对象来封装数据和行为。 10. 科学计算器的实现：在本程序中，我们可以看到科学...
Op面板编程(中文)
05-22
Op27-37操作员面扳设备手册。 本手册为操作员、装配工、组态者和系统管理员提供了关于操作员面板OP27和OP37的功能性、操作和技术性能方面的信息。
The BOXSTEP Method for Large Scale Optimization
05-24
The BOXSTEP Method for Large Scale Optimization W. W. Hogan, R. E. Marsten, and J. W. Blankenship
OAOP是什么，如何理解
shocking2001的专栏
01-24 672
在一些帖子上看到OAOP的概念，不明白。到google上找找，也没找到。请那位解释下它的概念。
java中\\d是什么意思
热门推荐
evilcry2012的专栏
02-26 1万+
java中\\d是什么意思 2011-03-13 22:16freewangfeifei | 分类：JAVA相关 | 浏览4423次 分享到： 2011-03-13 23:31 提问者采纳 这个是由两部分组成的，\ 转义符 加\d 是一个正字表达式，标识所有数字及0-9 之所以要加\是因为在JAVA中一些特殊的符号如[回车]
java的op类怎么写_java 基本语法（十九）Optional类的使用
weixin_35834213的博客
02-27 862
java.util.Optional类1.理解：为了解决java中的空指针问题而生！Optional 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。2.常用方法：@Testpublic void tes...
java op
weixin_50708764的博客
12-13 527
系统学习面向对象语言设计，java是一门完全面向对象设计性语言，就连最基本的基本类型java自身也都包装了相应的类型与方法，那么什么是类，什么是对象，通俗点说 类就是对象的模板，就像工厂里面的模子，机器比对一种模板制作了一件物品，那么那件物品就是这个模子(类)，对应的一个对象，它有自己的属性以及自己的方法。说到一个类不可不说的就是他的方法，与属性，所谓属性就是类里面的一些变量或常量，而方法就是对象(类)调用这个方法可以做成什么事情，比如操作类里面的数据，又比如可以排序啊，又比如可以打印对象啊…诸如此类的方法
Java op= 运算符
wyc的专栏
11-08 2573
E1 op= E2 is equivalent to E1 = (T)((E1) op (E2)), where T is the type of E1, except that E1 is evaluated only once.
PM、RD、QA、OP英文缩写是什么意思
dfl2099的博客
10-24 8082
在外企也好，合资也罢，职场中每个人都有自己的代号，不仅仅是Peter、Mary、Jack、Rose，还有各种PM、RD、QA、OP！这些英文缩写都是什么意思？初入职场或者准备踏入职场的你是不是已经有点犯晕了？今天小编就来给大家科普一下那些听起来神秘又高端的英文职位缩写。 1.PM: Product Manager，产品经理，又称品牌经理（Brand Manager）。举凡产品从创意到上市...
java的op类怎么写_op=运算有什么格式？Java计算机等级考试笔记
weixin_39880899的博客
02-27 774
op=运算在语句中使用"op=运算符"的格式为：lhs op= rhs;这里的oP可以是+、-、*、/、%以及一些你还没有看到的运算符。上述格式是下列语句的简写形式lhs=lhs op(rhs);右侧在括号内是因为它被首先执行，然后将其结果使用运算符op与左侧数据进行结合。让我们看几个例子以便对这种运算符形式有个清楚的理解。你可以编写一条语句，给int型变量count增加5。count=5这条语句...
请综合利用本课程中C++学习的面向对象编程相关技术，如继承、派生、多态、文件处理、容器等。实现一个银行账户管理系统。银行账户管理系统中包括用户及银行职员两类人员。用户及银行职员通过简易的文字菜单式系统界面登录后进行相应操作。
最新发布
06-09
if (op == 0) { break; } switch (op) { case 1: p->show_info(); break; case 2: cout 请输入存款金额：" ; double m; cin >> m; p->deposit(m); break; case 3: cout 请输入取款金额：" ; cin >> ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

得。

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值