趣解面向对象

最新推荐文章于 2022-05-13 21:16:17 发布
最新推荐文章于 2022-05-13 21:16:17 发布
阅读量288 收藏
点赞数 1
分类专栏： 技术专栏 文章标签： java 面向对象 内部类 继承 接口
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_40775402/article/details/117696720
版权

【小白自述】

  • 过去就听说，到面向对象的时候即使没有女朋友，都可以new好多个，啥时候我也能想new多少new多少？
  • 面向对象听了很多老师的课，感觉好绕啊！！！这个类套那个类，怎么套的也是一头雾水！！！怎么才能学好了面向对象嘛？？？！！！
  • 好多人都说面向对象是java的核心，都说工作几年的都不能真正领悟面向对象思想，像我们刚开始学能够掌握吗？要不要放弃？

        ······

面向对象，我来了

目录

【小白自述】

初识面向对象

（OOP即object-oriented programming）

对象的创建分析

类与对象的关系：

构造器

面向对象三大特征

封装

继承

格式：

注意：

super关键字：

this关键字：

方法重写：

继承中成员变量的用法

多态

抽象类和接口

抽象类：单继承

表现形式：

接口

内部类及面向对象实战

内部类概念

内部类分类

致歉：

作为一个资深的小白翻身专家，今天就给大家倒倒我的面向对象学习史以及一些有趣的学习认知。

初识面向对象

（OOP即object-oriented programming）

与面向对象相对的就是面向过程，接下来我们区分一下面向对象和面向过程。

面向过程特点：

  • 步骤清晰简单，第一步、第二步、第三步···只要按照步骤做就能完成
  • 面向过程适合处理一些较为简单的问题。如我们想用电脑听歌需要先打开电脑，找到酷狗音乐，选择相应歌曲，点击播放，即完成了电脑听歌的需求。

面向对象特点：

  • 物以类聚，分类的思维模式，思考问题的方法是首先解决该问题需要做哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
  • 炒一盘菜，我们考虑食材选择、佐料准备、厨具准备、菜谱等，有这些就能做出来，这是面向对象编程；而具体如何去做，划分到每个细节里是面向过程编程了。

总结：

        对于描述复杂事物，为了从宏观上把握，我们要运用面向对象的思想从整体上合理分析整个系统；但具体到微观操作，仍需要用面向过程的思路去处理。

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

从认识角度考虑先有对象后有类。对象是具体的，类时抽象的，类是对象的抽象

从代码运行角度考虑是仙有泪后有对象。类是对象的模板

对象的创建分析

类与对象的关系：

  • 类时一种抽象的数据类型，它是对某一类事物整体描述/定义，但并不能代表某一个具体的事物。如：水果、蔬菜、动物

  • 对象是抽象概念的具体实例。能够体现出特点，展现出功能的具体实例，而非一个概念。

        土豆就是蔬菜类的一个具体实例，狗也是动物类的一个具体实例，苹果也是水果类的具体实例

温馨提示：

        如果在观看代码的过程中不懂方法为何如此调用，可以详见：java中方法详解

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

构造器又名构造方法，创建对象时必须调用。
构造器特点：
    1、必须和类的名字相同；
    2、必须没有返回类型，也不能写void
*/
public class Application{
    public static void main(String[] args){

        Person p = new Person();
        System.out.println("姓名："+p.name+"证件号："+p.personID+"性别："+p.sex+"身高为"+heigt)；
        p.name = "小李子";
        p.personID=101214192830144143L;
        p.sex = '男';
        p.heigt = 172;
        System.out.println("姓名："+p.name+"证件号："+p.personID+"性别："+p.sex+"身高为"+heigt)；

        p.saySomething();
    }
}
/*
类中含属性和功能两部分，可以单独存在。
属性： 字段Field 即成员变量
功能： 成员方法
但记住事物的存在肯定是有它的形态和存在价值的！！！

*/
class Person{

    String name;
    Long personID;
    char sex;
    int heigt;

    public static void saySomething(){

        System.out.print("啊~~~");
    }
}

构造器

构造器又名构造方法，创建对象时必须调用。

/*
格式：
    修饰符 类名(参数列表){}

*/
public class Student{

    //与类名相同，无返回值类型，不写时，系统会默认给出构造器

    public Student(){

    }
}


特点：

  1. 必须和类的名字相同；
  2. 必须没有返回类型，连void也没有

注意：

  1. 当构造方法未定义时，系统会默认提供无参构造方法
  2. 一旦定义了有参构造，无参构造必须显示定义
  3. 构造方法是可以重载的
    /*
    以下程序报错原因：
    使用new关键字，本质实在调用构造器
    一旦定义了有参构造，系统就不会自动提供无参构造
    如果想使用无参构造，需要重新显示定义无参构造
    */

public class Application{
    public static void main(String[] args){
        
        Student st = new Student();//  此时程序会报错 

    }

}

class Student{
    String name;

/*
  //如果想要不报错，自己在定义一个无参的构造方法
    public Student(){

    }
*/

    //下面定义一个有参构造
    public Student(String name){
        this.name = name;
    }


  

}

Alt+insert-->自动生成构造方法

作用：

  1. 使用new关键字，必须要有构造器
  2. 实例化初始值

面向对象三大特征

封装

将非直接用的内容存放在盒子里，同时打开一个出口能够获取直接用的内容。即（该露的露，该藏的藏）

程序设计追求“高内聚，低耦合”，

高内聚，指类的内部数据操作细节自己完成，不允许外部干涉；

低耦合，指仅暴露少量的方法给外部使用。

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

将属性私有，使用get/set方法

  1. 提高程序到 安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口
  4. 系统可维护性增加
public class Application{
    public static void main(String[] args){

        Person p = new Person();
        System.out.println("姓名："+p.name+"证件号："+p.personID+"性别："+p.sex+"身高为"+heigt)；

        /*new出的对象不能直接调用私有的Person属性，会报错如：‘name’has private access in 'Person'
        如果想要调用Person属性，需要提供get、set方法      

         p.name = "小李子";
        p.personID=101214192830144143L;
        p.sex = '男';
        p.heigt = 172;  
*/
/*
        p.setName("小李子");
        p.setPersonID(101214192830144143L);
        p.setSex('男');
        p.setHeight(172);
*/
       
        System.out.println("姓名："+p.getName()+"证件号："+p.getPersonID()+"性别："+p.getSex()+"身高为"+ p.getHeight())；

        p.saySomething();
    }
}

class Person{

   //属性私有
   private String name;
   private  Long personID;
   private  char sex;
   private  int heigt;

    //提供一些可以操作私有属性的方法
    //提供一些public的get、set方法

    //get获得私有属性的数据
    public String getName(){

        return this.name;
    }

    //set给这个数据设置值
    public void setName(String name){

    this.name = name;
    }


     public String getPersonID(){

        return this.personID;
    }

     public void setPersonID(Long personID){

        this.personID = personID;
    }

     public String getSex(){

        return this.Sex;
    }

     public void setSex(char sex){

        this.sex = sex;
    }

     public String getHeight(){

        return this.height;
    }

     public void setHeight(int height){

        this.height = height;
    }
    public static void saySomething(){

        System.out.print("啊~~~");
    }
}

继承

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

extends：扩展。即自子类是父类的扩展，子类 is one of the 父类

格式：

class 子类 extends 父类{

}

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

java中类只有单继承，没有多继承,可以多层继承

class Person{
    String name;
    int age;
    char sex;
    int height;
    
    public static void say(){

    }
}

class Student extends Person{
    int learningID;
    double score;
    public static void learning(){

    }

}

//父类可以由多个子类继承

class Teacher extends Person{
    int teachID;
    double salary;
    public static void teaching(){

    }

}

/*
多层继承演示:
Teenager既具备Student的属性和特征，
也具备Person的属性和特征，
同时还具备object的属性和特征
*/
class Teenager extends Student{

    private int age;

    public static void setAge(int age){
        if(age>19||age<11){
            System.out.println("非法青少年");
        }else{
            this.age = age;
        }

    }
}

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

注意：

  • 用private修饰的变量和方法是不能被继承的。
  • 子类不能继承父类的构造方法，但是可以通过super关键字访问父类构造方法
  • 不要为了部分功能而去继承

super关键字：

  • super调用父类的构造方法，必须在构造方法的第一行
  • super必须只能出现在子类的方法或者构造方法中
  • super和this不能同时调用构造方法

this关键字：

  • this为了区分类中的成员变量和局部变量
  • 当子类中继承的父类中的成员变量和成员方法，实际调用时，既可以用this关键字，也可以用super关键字；
/*
this.name指成员变量
赋值的name是局部变量

*/


public class Student{

    private String name;

    public static void getName(String name){

        this.name = name;

    }

}

this VS super：

  • 代表的对象不同：

                  this：代表本类对象的应用 

                  super：代表父类对象的应用

  • 前提：

                   this：   无继承关系（本类中）即可使用

                   super：只能在继承前提下方（即子类中）可使用

  • 构造方法

                   this() : 本类的构造

                   super()：父类的构造

                   注意必须要放在构造方法中的第一行

/*
    子类中的构造方法会默认调用父类中无参的构造方法
    虽然没有直接写super（），但默认有super()
    如果父类中没有无参的构造方法，子类的构造方法必须要直接或者间接调用到父类中的构造方法
    简而言之，子类中的构造方法必须要用到父类中的构造方法

*/
public class Application{

    public static void main(String[] args){
        
       // Person p = new Person();// 打印：我是父类人类的构造方法

       // 先打印我是父类人类的构造方法，然后打印我是子类学生类构造方法

         Student st = new Student();
    }
}

class Person{
    
  /*  public Person(){

         System.out.println("我是父类人类的构造方法");

    }
    */

    public Person(String p){

         System.out.println("我是父类人类的构造方法");

    }
}

class Student extends Person{
   
    public Student(){
       super("调用有参构造方法");

       System.out.println("我是子类学生类的构造方法");

    }

}

思考：为什么子类构造方法必须调用父类构造方法

子类构造方法调用父类构造方法目的是为了完成父类中数据的初始化。

方法重写：

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

/*
方法的重写一定是仅针对方法，跟属性无关

方法的调用仅和左侧定义的数据类型有关，会根据引用数据类型中的方法决定调用结果

静态方法和非静态方法区别很大

方法的重写只与非静态方法有关系

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


        Student st = new Student();
        st.say();//打印：我是学生类中的静态方法

        Person st1 = new Student();//父类的引用指向子类
        st1.say();//打印：我是人类中的静态方法

     
        st.cry();//打印：啊~~，我是学生类中的非静态方法

        st1.cry();  //打印：啊~~，我是学生类中的非静态方法

        st.smile();//哈哈哈，我是人类中的非静态方法

        st1.smile();//哈哈哈，我是人类中的非静态方法     哈哈哈，我是学生类中的非静态方法

    }

}


class Student extends Person{

     public static void say(){

           System.out.println("我是学生类中的静态方法");
    }

   

    public void cry(){

        System.out.println("啊~~，我是学生类中的非静态方法");
    }

    @Override
	public void smile() {
		// TODO Auto-generated method stub
		super.smile();
		System.out.println("哈哈哈，我是学生类中非静态方法");
	}

}

class Person{

     public static void say(){

        System.out.println("我是人类中的静态方法");
    }
   

    public void cry(){

        System.out.println("我是人类中的非静态方法");
    }

     public void smile() {
	    	
	    	System.out.println("哈哈哈，我是人类中的非静态方法");
	 }
}
  • 方法名必须相同，方法体不同
  • 参数列表必须相同>
  • 修饰符：范围可以扩大但不能缩小； public>protected>default>private
  • 抛出异常：范围可以被缩小但不能扩大：ClassNotFoundException-->Exception(大)

思考：为什么要重写？

父类的功能，子类不一定需要，活着不一定满足

继承中成员变量的用法

继承中的成员变量的关系：

  • 先在子类中找，子类中如果没有就去父类中找，父类中如果没有就报错
public Application{
    public static void main(String[] args){
        Student st = new Student();
        
        System.out.println(st.country);//打印结果为 USA,如果Student类中没有，则为China

        st.show("India");//打印结果依次为India、USA、China
    }
}

class Person{
    String name;
    int age;
    double weight;
    String country = "China"；

    public void say(){


    }
}

class Student extends Person{
    String name;
    int grade;
    int score;
    String country = "USA";

    public void test(){

    }
    public void show(String country){
        System.out.println(country);//就近原则
        System.out.println(this.country);//this关键字的应用指向成员变量
        System.out.println(super.country);//super关键字的应用指向父类中的成员变量
       
    }
}
  • 父类对象无法调用子类中的成员变量

多态

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


        Student st = new Student();
        Student.say();//打印：我是学生类中的静态方法

        Person st1 = new Student();//父类的引用指向子类
        Person.say();//打印：我是人类中的静态方法

     
        st.cry();//打印：啊~~，我是学生类中的非静态方法
/*
        父类不可以调子类中独有的方法，如果想要调用需要强制转换((Student)st1).cry()

        st1.cry();  //报错：ClassCastException    

*/

        st.smile();//哈哈哈，我是人类中的非静态方法

        st1.smile();//哈哈哈，我是人类中的非静态方法     哈哈哈，我是学生类中的非静态方法

    }

}


class Student extends Person{
    //含static的方法是静态的方法，类名直接调用，尽量不适用对象调用

     public static void say(){

           System.out.println("我是学生类中的静态方法");
    }

   

    public void cry(){

        System.out.println("啊~~，我是学生类中的非静态方法");
    }

    @Override
	public void smile() {
		// TODO Auto-generated method stub
		super.smile();
		System.out.println("哈哈哈，我是学生类中非静态方法");
	}

}

class Person{
    //含static的方法是静态的方法，类名直接调用，尽量不适用对象调用
     public static void say(){

        System.out.println("我是人类中的静态方法");
    }
   

   

     public void smile() {
	    	
	    	System.out.println("哈哈哈，我是人类中的非静态方法");
	 }
}

多态是方法的多态，属性没有多态

父类和子类有继承关系，如果想让父类的对象调用子类的方法，需要进行强制转换

容易出现类型转换异常  ClassCastException

存在条件：继承关系，方法需要重写@Override，

父类引用指向子类对象 Person p= new Student();         

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

//如果A与B存在继承关系，那么结果为true，否则为false。

System.out.println(A instanceof B);

          子类继承父类，向上转型直接转，向下转型需要用强转，过程中可能会损失精度。                    

public class Student{
    public static void main(String[] args){
        Student st = new Student();
        /* 执行结果依次为：

            我是静态代码块
            我是匿名代码块
            我是构造代码块

        通过打印结果我们能够得出执行速度：静态代码块>匿名代码块>构造代码块
        */

        Student st1 = new Student();
          /* 执行结果依次为：

            我是匿名代码块
            我是构造代码块

       静态代码块只执行1次
        */
}

    //代码块（匿名代码块）可以赋初始值
    {
    
    System.out.println("我是匿名代码块");
    }
     //静态代码块
    static{
   
    System.out.println("我是静态代码块");
    }
    //构造方法
    public Student(){
        System.out.prinln("我是构造方法");

    }

}

执行速度：静态代码块>匿名代码块>构造代码块 

抽象类和接口

抽象类：单继承

表现形式：

/*
抽象类也是单继承
格式：public abstract class 类名{}
抽象类不能new只能靠子类去实现它：约束
抽象方法必须在抽象类中
抽象类中可以写普通的方法

*/

public abstract class Description{

    /*
    抽象方法须有关键字abstract
    抽象方法只有方法名没有方法实现,需要被实现，因此引入继承

    */
    
    public abstract void sayStory();
}

思考： 抽象类中有构造器吗？

             无法创建对象，那是没有构造器的。

             抽象类存在的意义是什么？

             抽象出来，提高开发效率

接口

约束和实现分离：面向接口编程

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是~~则必须能做~~”

接口的本质是契约，就想法律一样，一旦制定，在大环境下都需要遵守

面向对象（OO）的精髓，是对对象的抽象，最能体现这一点的是接口。

  • 只有规范方法，自己无法写方法~专业的约束！
  • 类可以实现接口，
  • 表现形式：class A implements interface B
  • 只要实现了接口的类就需要重写接口中的方法
  • 接口是可以实现多继承的
/*
类可以实现接口，表现形式：A implements B
只要实现了接口的类就需要重写接口中的方法

接口是可以实现多继承的

*/
public class UserImpl implements UserService,TimeService{
    public void add(String name) {
		// TODO Auto-generated method stub
		
	}

	public void delete(String name) {
		// TODO Auto-generated method stub
		
	}

	public void update(String name) {
		// TODO Auto-generated method stub
		
	}

	public void quary(String name) {
		// TODO Auto-generated method stub
		
	}

	public void timer() {
		// TODO Auto-generated method stub
		
	}
    


}
//接口都需要有实现类，定义的关键字是interface
public interface UserService{
    
    //静态常量 public static final可以不写
    public static final int AGE = 15;

    //接口中所有定义其实都是抽象的 public abstract

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

public interface TimeService{

    void timer();

}

内部类及面向对象实战

内部类概念

在一个类的内部再定义一个类，如A类中定义一个B类，那么B类相对A类来说就成为内部类

class OutClass{

    System.out.println("我是外部类");

    class InnerClass{

        System.out.println("我是内部类");

    }


}

内部类分类

  • 成员内部类

/**
成员内部类的演示效果
可以获得外部类的私有属性和私有方法
调用前要先通过外部类实例化内部类
*/

class ApplicationTest{

    public static void main(String[] args){
        //测试是否可以new内部类和外部类,如何保障正常调用
        OuterDemo od = new OuterDemo();
        //通过这个外部类来实例化内部类~
        OuterDemo.InnerDemo id = od.new InnerDemo();
        id.getID();//得到的打印结果为1012；

    }

}


public class OuterDemo{
    private int id = 1012;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    public class InnerDemo{

        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性

        public void getID(){

            System.out.println(id);
        }

    }

}
  • 静态内部类
/**
静态内部类的演示效果
不可以获得外部类的私有属性和私有方法，因为static为内存分配，在没有创建对象前已经存在
*/

class ApplicationTest{

    public static void main(String[] args){
        //测试是否可以new内部类和外部类,如何保障正常调用
        OuterDemo od = new OuterDemo();
        //通过这个外部类来实例化内部类~
        OuterDemo.InnerDemo id = od.new InnerDemo();
        // id.getID();//报错，static内存直接分配；

    }

}


public class OuterDemo{
    private int id = 1012;
    public void out(){
        System.out.println("这是外部类的方法");
    }

   public static class InnerDemo{

        public void in(){
            System.out.println("这是内部类的方法");
        }
        /*不能获得外部类的私有属性

        public void getID(){

            System.out.println(id);
        }
        */

    }

}
  • 局部内部类
/**
    局部内部类的演示效果
*/

public class ApplicationTest{
    public static void main(String[] args){
    OuterDemo od = new OuterDemo();
    


    }
}


public class OuterDemo{

    //局部内部类
    public void method(){
        class InnerDemo{
            public void in(){

            }

        }

    }


}
  • 匿名内部类
/**
    匿名内部类的展示效果

    
*/

public class Test{
    public static void main(String[] args){
        //没有名字初始化类,不用将实例保存到变量中

        new NameClass().myName();
    }

}

class NameClass{

    public void myName(){

        System.out.println("我的名字叫测试匿名内部类");
    }


}

致歉：

因工作比较忙，更新的不够及时，望小伙伴们海涵。

作品会及时更新，更多内容也可以观看www.51doit.cn

小白程序员的翻身之旅
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第十章：面向对象分析（此章完结）
zhhzc的博客
03-30 4924
10.4.4建立活动图 活动具体表现为由一系列动作组成的执行过程，将各种活动及不同活动之间的转换，用图形进行表示就构成了活动图，作用是对系统的行为建模 1、活动图与流程图 活动图描述系统使用的活动，判定点和分支、活动图本质是一种流程图借鉴了工作流建模，Petri网等领域的相关概念，其表达能力比流程图更强、应用范围也更宽。 活动图与流程图的区别：不能将两个概念混淆，首先流程图着重描述处理过程，它的主要控制结构是顺序、选择和循环各个处理过程之间有严格的顺序和时间关系，活动图描述的是对象活动的顺序关系所遵
Head First Java 第2版 中文版.pdf
03-25
《HeadFirstJava》(中文版)(第2版)是本完整的面向对象(object-oriented，OO)程序设计和Java的学习指导。此书是根据学习理论所设计的，让你可以从学习程序语言的基础开始一直到包括线程、网络与分布式程序等项目。最...
趣味解读Python面向对象编程 (类和对象)
pdcfighting的博客
07-16 321
点击上方“IT共享之家”，进行关注回复“资料”可获赠Python学习福利一、面向对象简介 考虑现实生活中，我们的思维方式是放在学生这个个人上，是学生做了自我介绍。而不是像我们刚刚...
面向对象的趣味解释
上冰子里的博客
07-28 204
面向对象的趣味解释 1、面向过程 面向对象 想吃煎饼 面向过程:拿着钱，从宿舍到煎饼摊。 面向对象：找个对象 帮你做事儿。 面向过程：面向的是这件事儿的过程，强调是做这件事儿的动作。 面向对象：面向的是对象。 用面向过程的思想：将大象塞进冰箱里 把大象塞进冰箱里 软件系统 1、打开冰箱门 2、把大象塞进去 ，亲下大象的屁股 //3、关闭冰箱门 杨浩然 高大 浑身都是肌肉 杨浩然可以自己打开冰箱门 杨浩然自己也可以把大象塞进去，亲下大象的屁股 //杨浩然可以自己关闭冰箱门 苏雷 130cm 30KG
一个有趣的例子带你看面向对象编程与面向过程编程的主要区别
weixin_45561357的博客
05-22 1022
一个有趣的例子带你看面向对象编程与面向过程编程的主要区别。该篇文章通过一个实际问题展开，分别用面向对象跟面向过程两种思路进行分析与代码实现，直观感受面向对象的优势。
趣读面向对象编程
weixin_41949434的博客
05-14 180
前言 ​ 现在的高级程序设计语言大致可以分为两种： ​ 面向过程的编程语言 ​ 面向对象的编程语言 ​ 现在基本上常用的就一种面向过程的语言，就是C语言。今天我说的重点不是C语言，而是说说面向对象的编程语言。现在基本上除了C语言外的高级主流的程序设计编程语言都属于面向对象的编程语言，比如我们常讨论的Java、Python等都属于面向对象的编程语言。 ​ **那么什么是面向对象的编程语言的呢？*...
Ecuacion2-Grado_Android:用于求解二次方程的 Android 应用程序
06-30
整个应用程序在单个类 - Activity (MainActivity.java) 中实现，因为它很简单，但对于复杂的项目，理想的是应用面向对象并将其分解为几个类。 Deitel 教授为我提供指导的一本书，有几个完整的项目，可以从这里下载...
leetcode中文版-New2ComputerScience:新计算机科学
06-29
leetcode中文版谷歌面试大学 它是什么？ 我使用这个最初创建的列表来研究一些与 CS 相关的材料。 目录 面试流程和一般面试准备 视频： ...他提到的你需要知道的所有事情都列在下面 ...面向对象编程 STL 函子： 谷歌的
HeadFirstJava 深入简出java第二版
02-19
《深入浅出Java 第二版》是完整的面向对象程序设计和Java的学习指导。此书是根据学习理论所设计的,它让你可以从学习程序语言的基础开始一直到掌握线程、网络编程与分布式程序设计等高级特性。最重要的，你将学会如何...
基于JAVA的俄罗斯方块游戏设计与实现【开题报告】.pdf
05-30
面向对象 Java 是面向对象的编程语言。面向对象技术较好地适应了当今软件开发过程中新出现的种种 传统面向过程语言所不能处理的问题，包括软件开发的规模扩大、升级加快、维护量增大经及开发 分工日趋细化、专业化和...
面向过程和面向对象的联系和区别
撬动未来的支点的专栏
04-30 1611
初认识
面向对象与面向过程区别与联系深入浅出解析
awenwenwen123的博客
02-20 3458
作为一个在电商行业混迹多年的产品经理，对面向对象的理解一直模棱两可，有的时候觉得自己知道什么是面向对象，有的时候又说不出来，经过这几天的整理思考，把对面向对象与面向过程的思考给大家分享下： 首先，我们要认识什么是面向对象，先要了解向对象怎么来的，编程技术一开始是没有面向对象的概念的，最早都是面向过程，后来经过一定时间段的发展，逐渐抽象出面向对象，这里用人类社会举一个例子： 最早在...
面向过程与面向对象的区别与联系
向诸位大佬虚心学习
05-13 726
我们要了解两个知识点间的区别，首先需要明确知识点的内容，其次对二者做出对比，之后看二者是否有联系，最后对知识进行拓展及总结。
从面向对象的四大特性说起
Blues的专栏
05-13 600
说到面向对象（OOP）的特性很多人首先就想到了，封装、继承和多态，其实在维基百科的解释里“抽象”也应该被包含在内，自然而然本文的标题就变成了“从面向对象的四大特性说起”了。 为了描述得足够系统，对于基本概念的描述大部分来源于维基百科。 什么是封装？ 封装是一种可以使类中的字段私有并能通过公有方法来访问私有字段的技术。如果一个字段被声明为私有，它就不能在类的外部被访问，从而隐藏了类内部的字段。基于这...
面向对象：佛系大龄少女，喜欢有趣的灵魂
程序员的那些事
02-18 386
各位男生如果看到合适的女生，但自己 “下不了手”，请可劲地介绍给你还单着的亲朋好友 ^_^ 小帖士 1）单身男生和女生都有机会加入面向对象，点击 “阅读原文” 可以开始试...
几道有意思的面向对象面试题
最可爱的草莓酱兔兔
05-22 190
1 let obj = { 2: 3, 3: 4, length: 2, push: Array.prototype.push } obj.push(1); obj.push(2); console.log(obj); 2 a等于什么值会让下面条件成立 var a = ?; if (a == 1 && a == 2 && a == 3) { console.log('OK'); } 3 function Fn(n,m) {
面向对象编程--两个有趣的例子
飞鱼
11-27 2681
package demo1; public class Description { /** * 描叙： * 一个球，从一根绳子的一段滚到另一端 */ } package demo1; import java.awt.Point; public class Rope { private Point start; //起点 private Point end; //终点
有趣的面向对象技术
Technology Space
12-04 697
       大一下学期，我第一次接触到高级语言程序设计——C语言。完成了几次作业以后，我学会了定义全局变量，就是把一些经常使用的参数定义在所有函数体外，以免在编程过程中频繁地在函数体之间传递指针，从而使得程序设计变得“容易”了（只能说编程，还谈不上设计）。这就是我们习惯称呼的面向过程的程序设计（Procedure－Oriented Programming，POP）。，不久后，我们几个同学自学
29.面向对象的有趣玩法
Mint周的文章
07-14 95
题型1、 a等于什么值会让下面条件成立 var a = ?; if (a == 1 && a == 2 && a == 3) { console.log(‘OK’); } 解析： 先理解运行机制 == 相等VS === 绝对相等 1.左右数据值类型不同，三个等号不能转换数据类型，直接返回false，但是两个等于号会默认先转换为一致的数据类型再进行比较 NaN == NaN ：NaN和谁都不相等（包括自己） null == undefined：null和undefined
oracle 面向对象
最新发布
12-21
Oracle 是一个面向对象的关系数据库管理系统。它具有强大的面向对象的特性，可以支持面向对象的数据建模和开发。 首先，Oracle 支持对象关系型数据库（ORDBMS）的建模和开发。宗旨是将面向对象的概念融合到传统的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值