JavaSE_11 面向对象

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了JavaSE_11 面向对象，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含7898字，纯文字阅读大概需要12分钟。

内容图文

JavaSE_11 面向对象

文章目录

• JavaSE_11 面向对象
• 1.面向过程和面向对象
• • 面向过程思想
  • 面向对象思想
  • 小结
• 2.什么是面向对象
• 3.类和对象的关系
• 4.创建与初始化对象
• 5.构造器
• 6.封装
• • 概念
  • 优点
  • 使用
• 7.继承
• • 概念
  • super 详解
  • • super 和 this
    • • super
      • this
  • 方法重写
  • • 概念
    • 特点
    • 为什么需要重写
    • 总结
• 8.多态
• • 概念
  • 优点
  • 多态实现的必要条件
• 9.static关键字
• • 概念
  • 使用
  • static注意事项
• 10.抽象类
• 11.接口
• • 概念
  • 语法
• 12.内部类
• • 概念
  • 分类
  • 使用

1.面向过程和面向对象

面向过程思想

分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。线性思维。

面向对象思想

在解决问题的时候不再是一步一步的过程了，而是先考虑在这个问题里面具有那些对象，给问题分类。然后在给分类后的问题进行单独思考。

小结

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

2.什么是面向对象

• 面向对象编程（OOP）。

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

• 抽象

• 三大特性

  ? 封装

  ? 继承

  ? 多态

• 从认识论角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象。

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

3.类和对象的关系

• 类是一种抽象的数据类型，它是对某一类事务整体描述和定义，但是并不能代表某一个具体的事务。类是一个模板。
• 对象是抽象概念的具体实例。能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

4.创建与初始化对象

• 使用new关键字。

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

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

  ? 必须和类的名字相同

  ? 必须没有返回类型,也不能写void

//创建老师类
public class Teacher{
    //属性
    String name;
    int age;
    
    //方法
    //……
}

//创建老师对象
public class Dome{
    public static void main(String [] args){
        // 使用new关键字创建老师对象
        Teacher teacher = new Teacher();
        System.out.println(teacher.name); //打印null
        System.out.println(teacher.age); //打印0
        
        teacher.name="小红";
        teacher.age=15;
        System.out.println(teacher.name); //打印小红
        System.out.println(teacher.age); //打印15
            
    }
}

5.构造器

• 一个类即使什么也不写，也会存在一个默认的方法，而这个方法就是构造器。

• 构造器的名称与类名相同。

• 如果定义了有参构造，那么无参构造就会被默认回收，这个时候使用new关键字的时候就会报错。除非显示定义一个无参构造。或者你在new的时候给他传递参数。

• 构造器可以给参数赋值，因为每次new一个类的时候会先执行一次构造器。（使用new的时候必须要有构造器）

public class Dome{
    //无参构造器
    public Dome(){
        
    }
    
    //有参构造
    public Dome(String name){
        
    }
}

6.封装

概念

将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来对隐藏的信息进行操作和访问。

优点

• 只能通过规定的方法访问数据，提高程序安全性。

• 隐藏方法中的实现细节。

• 高内聚，低耦合。

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

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

使用

属性私有，get/set 。

7.继承

概念

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
• extands 的意思是 “扩展” 。子类是父类的扩展。
• Java中只有单继承，没有多继承。
• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
• 继承关系的俩个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends来表示。
• 子类和父类之间，从意义上讲应该具有"is a"的关系。
• 在Java中所有的类都继承Object类。
• 私有的方法和属性无法被继承。

super 详解

? 可以用来调用父类非私有的属性和方法。

super 和 this

super

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

this

• 代表的对象不同：

  this：本身调用者这个对象。

  super：代表父类对象。

• 前提：

  this：没有继承也能使用。

  super：只能在继承 条件才能使用。

• 构造方法

  this()：本类的构造。

  super()：父类的构造。

? 子类new的时候，子类的无参构造会默认先调用父类的无参构造，使用 super()调用。必须在构造方法的第一行

? super和this不能同时调用构造方法。

方法重写

概念

? 在子类中创建了一个与父类中名称相同、返回值类型相同、参数列表的方法相同，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写（override），又称为方法覆盖、方法复写。需要有继承关系，子类重新父类的方法。

特点

• 方法名必须相同，方法体可以不同。
• 参数列表必须相同。
• 修饰符：范围可以扩大，但是不能缩小。
• 抛出的异常：可以被缩小，但不能被扩大。

为什么需要重写

• 父类的功能，子类不一定满足。

总结

override（重写）

1、方法名、参数、返回值相同。

2、子类方法不能缩小父类方法的访问权限。

3、子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。

4、存在于父类和子类之间。

5、方法被定义为private， static，final不能被重写。

overload（重载）

1、参数类型、个数、顺序至少有一个不相同。

2、不能重载只有返回值不同的方法名。

3、存在于父类和子类、同类中。

8.多态

概念

• 多态是同一个行为具有多个不同表现形式或形态的能力。
• 多态就是同一个接口，使用不同的实例而执行不同操作
• 多态是方法的多态，属性没有多态。

优点

• 消除类型之间的耦合关系
• 可替换性
• 可扩充性
• 接口性
• 灵活性
• 简化性

多态实现的必要条件

• 继承
• 重写
• 父类引用指向子类对象：Parent p = new Child();

9.static关键字

概念

• 被static修饰的变量或者方法是独立于该类的任何对象，也就是说，这些变量和方法不属于任何一个实例对象，而是被类的实例对象所共享。

• 在该类被第一次加载的时候，就会去加载被static修饰的部分，而且只在类第一次使用时加载并进行初始化，注意这是第一次用就要初始化，后面根据需要是可以再次赋值的。

• static变量值在类加载的时候分配空间，以后创建类对象的时候不会重新分配。赋值的话，是可以任意赋值的！

• 被static修饰的变量或者方法是优先于对象存在的，也就是说当一个类加载完毕之后，即便没有创建对象，也可以去访问。

使用

• 修饰成员变量
• 修饰成员方法
• 静态代码块
• 修饰类（只能修饰内部类也就是静态内部类）
• 静态导包

static注意事项

• 静态只能访问静态。
• 非静态既可以访问非静态的，也可以访问静态的。

public class Student{
    {
        System.out.println("匿名代码块");
    }
    
    static{
        System.out.println("静态代码块");
    }
    
    public Student(){
        System.out.println("构造方法")
    }
    
    public static void main(String [] args){
        Student s1 = new Student();  //输出：静态代码块、匿名代码块、构造方法
        System.out.println("===============");
        Student s2 = new Student();  //输出：匿名代码块、构造方法
    }
}

10.抽象类

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

11.接口

概念

• 就是一种特殊的类。抽象层次比抽象类更高。

• 接口中定义的都是抽象方法。

• 接口的本质就是定义规范。

• 接口中可以没有任何的成员。只是作为标记，称为标记型接口

• jdk1.8以前接口中所有的方法都必须是public abstract的。但是jdk1.8以后

• 接口中可以有带有方法体的方法了。

  • 静态方法：用static修饰的
  • 默认方法：用default修饰的

• 接口中除了以上三种方法，不能有其他方法，包括构造方法

• 属性全部是public static final修饰的。

• 不能创建对象。

• 所以接口就是一套规范。用来实现的

• 一个类要实现接口，通过关键字implements

• 一个类可以实现多个接口。接口之间用逗号隔开就可以了

• 接口与实现类之间的关系就是 like a 的关系

• 接口跟接口之间是多继承的关系，一个接口可以继承其他多个接口

语法

public interface 接口名{
    public abstract 返回值类型 方法名(参数……);
}

12.内部类

概念

内部类就是在一共类的内部在定义一个类。

分类

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

使用

public class Outer{
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    
    //成员内部类
    public class Inner1{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        
        public void getId(){
            System.out.println("可以获取外部类私有的属性："+id); //打印10
        }
    }
    
    //静态内部类
    public static class Inner2{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        
        public void getId(){
            System.out.println("静态内部类中不能访问非静态的属性："+id); //编译报错
        }
    }
    
    public void method(){
        //局部内部类
        class Inner3{
            public void innerMethod(){
                System.out.println("这是局部内部类的方法");
            }
        }
    }
}


public class Test(){
    public static void main(String [] args){
        Outer outer = new Outer();
        // 通过外部类来创建内部类
        outer.Inner1 inner = outer.new Inner1();
        inner.getId();
        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();
    }
}

class Apple{
    public void eat(){
        System.out.println("这是匿名内部类的方法");
    }
}

内容总结

以上是互联网集市为您收集整理的JavaSE_11 面向对象全部内容，希望文章能够帮你解决JavaSE_11 面向对象所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端