javaSE-面向对象

已于 2024-04-20 13:54:58 修改
阅读量101 收藏
点赞数
分类专栏： Java语言必备基础知识 文章标签： jvm java 开发语言
于 2023-02-07 18:14:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62757009/article/details/128923016
版权

JavaSE基础-面向对象编程

1-初识面向对象

1.1面向过程&面向对象

1.1.1-面向过程思想：

  • 步骤清晰简单，第一步做什么，第二步做什么.......。

  • 面对过程适合处理一些简单的问题。

1.1.2-面向对象思想：

  • 物以类聚，分类的思维模式。

  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

  • 面向对象主要思想是把构成问题的各个事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙一个事物在整个解决问题的步骤中的行为。

2-对象

2.1-初识对象

2.1.1-定义

  • 对象的含义是指具体的某一个事物，即在现实生活中能够看得见摸得着的事物。

  • 在面向对象程序设计中，对象所指的是计算机系统中的某一个成分。

  • 在面向对象程序设计中，对象包含两个含义，其中一个是数据，另外一个是动作。对象则是数据和动作的结合体。对象不仅能够进行操作，同时还能够及时记录下操作结果。

2.1.2-创建

  • 使用new关键字创建对象。

new

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

2.2对象的代码详解

  • 创建类Parson（）


package Target;

public class Parson {
    String name;
    int  age;

    public Parson() {//无参构造方法
    }

    public Parson(String name, int age) {//有参构造方法
        this.name = name;
        this.age = age;
    }
}

  • 创建类Application(实现类)


package Target;

public class Application {
    public static void main(String[] args) {
        //创建一个对象 parson并往Parson类的Paerson方法传入数据
        Parson parson = new Parson("moxia", 21);
        //调用了Parson类中name属性
        System.out.println(parson.name);

    }
}

输出结果：

2.3-构造方法：

2.3.1-初识构造方法
2.3.1.1-构造方法有的分类

  • 无参构造方法

  • 有参构造方法。

2.3.1.2-构造方法的特点：

  • 必须和类名相同。

  • 必须没有返回类型，也不能写void。

  • 写有参构造方法就要写无参构造方法

注：如果一个类中没有写任何的构造方法，JVM 会生成一个默认的无参构造方法。

2.3.2-构造方法代码详解

package Target;

public class Dom1 {
    private int a; //私有属性a
    public Dom1() {//无参构造方法
    }

    public Dom1(int a) {//有参构造方法
        this.a = a;
    }
}

​

注：在不写有参构造方法时无参构造方法在类会自动生成。

3-面向对象的三大特性

3.1-封装

3.1.1-初识封装
3.1.1.1-什么是封装

  1. 在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

  1. 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

  1. 要访问该类的代码和数据，必须通过严格的接口控制。

  1. 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

  1. 适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

3.1.1.2-封装的优点

  1. 良好的封装能够减少耦合。

  1. 类内部的结构可以自由修改。

  1. 可以对成员变量进行更精确的控制。

  1. 隐藏信息，实现细节。

3.1.2-封装的代码详解

  • 修改属性的可见性来限制对属性的访问（一般限制为private）例如：


public class Person {
    //使用private将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。
    private String name;
    private int age;
}

  • 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问 例如：


package Target;

public class Encapsulation {
    private String name;
    private int  age;

    public Encapsulation() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

​

注意事项：

  1. get方法获取数据，set方法输出数据

  1. 采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

  • 实例；

  • 封装类


package Target;

public class Encapsulation {
    private String name;
    private int  age;

    public Encapsulation() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

​

  • 实现类


package Target;

public class Application {
    public static void main(String[] args) {
        //观察输出什么
        Encapsulation encapsulation = new Encapsulation("laizimoxia", 21);
        encapsulation.setName("moxia");
        encapsulation.setAge(20);
        System.out.println("姓名"+ encapsulation.getName() + 
                           "年龄"+ encapsulation.getAge());

    }
}

输出结果：

注：大家可以发现他没有输出 laizimoxia 而是输出moxia，这是因为属性私有的原因，只有通过get，set方法才能进行输出，输入。

3.2-继承

3.2.1-初识继承
3.2.1.1-什么是继承

  • 继承是Java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

  • 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

3.2.1.2-继承的关键字

  • extends关键字：在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

  • implements关键字：使用 implements 关键字可以变相的使Java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）

3.2.1.3-继承的特性

  • 子类拥有父类非 private 的属性、方法。

  • 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

  • 子类可以用自己的方式实现父类的方法。

  • Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

  • 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

3.2.1.4-继承在生活中实例

3.2.1.5-继承的格式

class 父类 {
}
 
class 子类 extends 父类 {
}
3.2.2-方法重写

  • 指两个方法的返回值、方法名、参数的类型和个数相同** (子类重写父类的方法)。

  • 方法的重写，不能发生在同类中，只能发生在子类中。

  • 若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。

​



public class Dom2{
    public void eat(){
        System.out.println( "正在吃");
    }

}
//继Dom2的方法
class Dom extends Dom2{
    //方法重写
    @Override
    public void eat() {
        System.out.println("zhengzaich");

    }
3.2.3-继承的代码详解

  • 继承属性


public class Person {//父类
    public Person(String name, int age) {
    }
    public Person(String name, int age, String sex) {
    }
}
//Sstudent为子类继承Person
class Student extends Person {
    public Student(String name, int age, String birth) {
        super(name, age); // 调用父类中含有2个参数的构造方法
    }
    public Student(String name, int age, String sex, String birth) {
        super(name, age, sex); // 调用父类中含有3个参数的构造方法
    }
}

  • 继承方法


package Target;

public class Dom2{
    public void eat(){
        System.out.println( "正在吃");
    }

}
class Dom extends Dom2{//继Dom2的方法
    @Override
    public void eat() {//方法重写
        System.out.println("zhengzaich");

    }
    void eatTest(){
        super.eat();//使用Dom2的方法
        this.eat();//使用自己的方法
    }

}
class Test{
    public static void main(String[] args) {
        Dom2 dom2 = new Dom2();
        dom2.eat();
        Dom dom = new Dom();
        dom.eatTest();
    }
}

​输出结果：

3.3-多态

3.3.1-初识多态

  • 动态编译 类型：可扩展性变得更强

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

  • 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。

  • 多态分为 向上转型和向下转型。

  • 多态存在的条件：

  1. 有继承关系。

  1. 子类重写分类方法。

  1. 父类引用指向子类对象。

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

向下转型时候一定要经过instanceof关键字进行判断

3.3.2-多态的代码详解

class Shape {//shape父类，可以有多个子类，
    void draw() {}
}
 
class Circle extends Shape {//子类只能由一个父类，并重写父类方法
    void draw() {
        System.out.println("Circle.draw()");
    }
}
 
class Square extends Shape {//子类只能由一个父类，并重写父类方法
    void draw() {
        System.out.println("Square.draw()");
    }
}
 
class Triangle extends Shape {//子类只能由一个父类，并重写父类方法
    void draw() {
        System.out.println("Triangle.draw()");
    }
}
3.3.3-向上转型

格式：
父类名称 对象名 = new 子类名称();

含义:
右侧创造一个子类对象，把他当作父类来看待使用。

注意事项：
向上转型一定安全，从小范围转到大范围。
3.3.4-向下转型

格式：
子类名称 对象名 = (子类名称)父类对象;

含义：
将父类对象【还原】成为原来的子类对象;

注意事项：
向下转型时候一定要经过instanceof关键字进行判断

4-super关键字

4.1-初识super关键字：

  • 由于子类不能继承父类的构造方法，因此，如果要调用父类的构造方法，可以使用 super 关键字。super 可以用来访问父类的构造方法、普通方法和属性。

  • 在子类的构造方法中显式的调用父类构造方法

  • 访问父类的成员方法和变量.

4.2-super关键字代码详解:

4.2.1-super访问父类成员

super.类名;
4.2.2-super调用成员属性

package Target;

public class Application {
    
     public static void main(String args[]) {
        Student student = new Student();
        student.test();
    }
}
class Person {
    int age = 12;
}
class Student extends Person {
    int age = 18;
    void test() {
        System.out.println("学生年龄：" + super.age);
    }
}

输出结果：

4.2.3-super调用成员方法

package Target;

public class Application {

    public static void main(String args[]) {
        Student student = new Student();
        student.nameTest();
    }
}

class Person {
    void name() {
        System.out.println("person");
    }
}

class Student extends Person {
    void name() {
        System.out.println("student");
    }

    void nameTest() {
        name();
        super.name();
    }
}

​

输出结果：

5-this关键字：

5.1-初识this关键字

  • this 关键字是Java常用的关键字，可用于任何实例方法内指向当前对象，也可指向对其调用当前方法的对象，或者在需要当前类型对象引用时使用。

  • 大部分时候，普通方法访问其他方法、成员变量时无须使用 this 前缀，但如果方法里有个局部变量和成员变量同名，但程序又需要在该方法里访问这个被覆盖的成员变量，则必须使用 this 前缀。

  • this关键字的使用：

  1. this.属性名

  1. this.方法名

  1. this( )访问构造方法

5.2-this关键字的代码详解

5.2.1-this.属性名

package Target;

public class Application {

    public static void main(String args[]) {
        Student student = new Student();
        student.test();
    }
}class Person {
    int age = 12;
}
class Student extends Person {
    int age = 18;
    void test() {
        System.out.println("学生年龄：" + this.age);
    }
}

输出结果：

5.2.2-this.方法名

package Target;

public class Dom2{
    public void eat(){
        System.out.println( "正在吃");
    }

}
class Dom extends Dom2{
    @Override
    public void eat() {
        System.out.println("this关键字");

    }
    void eatTest(){
        super.eat();
        this.eat();
    }

}
class Test{
    public static void main(String[] args) {
        Dom2 dom2 = new Dom2();
        dom2.eat();
        Dom dom = new Dom();
        dom.eatTest();
    }
}

​

输出结果：

5.2.3-this( )访问构造方法

package Target;

public class Dom3 {
        String name;
        // 无参构造方法（没有参数的构造方法）
        public Dom3() {
            this("魔匣");
        }
        // 有参构造方法
        public Dom3(String name) {
            this.name = name;
        }
        // 输出name
        public void print() {
            System.out.println("姓名：" + name);
        }
        public static void main(String[] args) {
            Dom3 dom3 = new Dom3();
            dom3.print();
        }
    }

​

输出结果：

6-final 关键字

6.1-初识final关键字

  • final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。

  • final 含义为 "最终的"。

  • 使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写；

6.2-final关键字的代码详解

  • 声明类：


final class 类名 {//类体}

  • 声明方法：


修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注：final 定义的类，其中的属性、方法不是 final 的。

7-抽象类

7.1-初识抽象类

  • 在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类

  • 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

  • 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

  • 父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

  • 在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

7.2-抽象类的代码详解


public abstract class Action{
    //约束 
    //abstract 抽象方法，只有方法名字，没有方法实现。
    public absteact void doSomething();
    //抽象类的所有方法，继承了它的子类，都必须实现他的方法
}

8-接口

8.1-初识接口

  • 普通类：只有具体实现

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

  • 接口：只有规范

  • 接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

  • 接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念：

  1. 类描述对象的属性和方法。

  1. 接口则包含类要实现的方法。

  1. 除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

  • 接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

8.2接口与类的区别：

  • 接口不能用于实例化对象。

  • 接口没有构造方法。

  • 接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。

  • 接口不能包含成员变量，除了 static 和 final 变量。

  • 接口不是被类继承了，而是要被类实现。

  • 接口支持多继承。

8.3抽象类和接口的区别：

  • 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

  • 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。

  • .接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

  • 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

8.4-接口特性

  • 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。

  • 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。

  • 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

8.5-接口的代码详解

8.5.1-接口的声明语法格式如下：

[可见度] interface 接口名称 [extends 其他的接口名] {        
    // 声明变量        
    // 抽象方法
}
8.5.2--接口声明实例：

package Target;

interface  Dom4{
    public void eat();
    public void cat();
}
8.5.3-接口的实现：

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

8.5.4-接口实现的实例;

package Target;

public class Dom5 implements Dom4{

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

    @Override
    public void cat() {
        System.out.println("吃鱼");

    }

    public static void main(String[] args) {
        Dom5 dom5 = new Dom5();
        dom5.eat();
        dom5.cat();
    }
}

​

输出结果：

8.5.5-接口的继承：

package Target;

interface  Dom4{
 public void eatDom4();
    public void catDom4();
}
//接口的继承
interface Football extends Dom4
{
    public void eatFootball();
    public void catFootball();
}

​

8.5.6-接口的多继承

package Target;

interface  Dom4{
    public void eatDom4();
    public void catDom4();
}
interface Hockey
{
    public void eatHocker();
    public void catHocker();
}
//接口的多继承
interface Football extends Dom4,Hockey
{
    public void eatFootball();
    public void catFootball();
    
}

​

9-内部类

9.1-初识内部类

  • Java 一个类中可以嵌套另外一个类，语法格式如下：


class Outer {   // 外部类
    // ...
    class Nested { // 嵌套类，或称为内部类
        // ...
    }
}

  • 要访问内部类，可以通过创建外部类的对象，然后创建内部类的对象来实现。

  • 嵌套类有两种类型：

  1. 非静态内部类

  1. 静态内部类

9.2-非静态内部类

非静态内部类是一个类中嵌套着另外一个类。 它有访问外部类成员的权限， 通常被称为内部类。

由于内部类嵌套在外部类中，因此必须首先实例化外部类，然后创建内部类的对象来实现。


class Outer {
    
  int x = 10;

  class Inner {
      
    int y = 5;
      
  }
    
}

public class My {
    
  public static void main(String[] args) {
      
    Outer myOuter = new Outer();
    Outer.Inner myInner = myOuter.new Inner();
    System.out.println(myInner.y + myOuter.x);
      
  }
    
}

以下实例执行输出结果为：


15

9.3-静态内部类


class Outer {   
    
  int x = 10;

  static class Inner {
      
    int y = 5;
      
  }
    
}

public class MyMain {
    
  public static void main(String[] args) {
      
    Outer.Inner myInner = new Outer.Inner();
      
    System.out.println(myInner.y);
      
  }
    
}

以下实例执行输出结果为：


5

9.4-从内部类访问外部类成员


class Outer {
  int x = 10;

  class Inner {
    public int myInnerMethod() {
      return x;
    }
  }
}

public class MyMain {
  public static void main(String[] args) {
    Outer myOuter = new Outer();
    Outer.Inner myInner = myOuter.new Inner();
    System.out.println(myInner.myInnerMethod());
  }
}

以下实例执行输出结果为：


10

Java魔匣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javaSE-(面向对象)
qazsefbz168的博客
03-17 295
面向对象概述面向对象思想面向过程思想与面向对象思想:面向过程: 面向过程，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。面向对象: 面向对象思想就是不断的创建对象，使用对象，指挥对象做事情。特点：面向过程: 强调的是过程，所有事情都需要自己完成面向对象:是一种更符合我们思想习惯的思想(懒人思想，我把事情自己不做，交给别人去做)可以将复杂的事情简...
JAVASE面向对象基础
weixin_47698996的博客
11-19 589
概述 面向过程是一种自上而下的程序设计方法，主要思路专注于算法的实现 自上而下的设计方法，设计者用一个main函数概括出整个应用需要做的事情，然后把main方法拆解成不同的步骤，对应不同的函数 过程式的特征是以函数为中心，用函数作为划分程序的基本单位;数据在过程式设计中处于从属的位置过程式设计的优点是易于理解和掌握，这种逐步细化问题的设计方法与大多数人的思维方式比较接近过程式设计是自上而下，这就要求设计者在开始时要对需要解决的问题有一定的理解，然而在问题比较复杂时，要做到这一点比较困难;当开发需求变化时，以
javase-面向对象
qq_30614803的博客
08-21 291
一.面向对象的基本特征 1.封装 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。 好处：将变化隔离；便于使用；提高重用性；安全性。 封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。 2.继承 javase-继承 3.多态 二.访问控制符 三.成员变量（属性）与局部变量 1.局部变量必须初始化，而没有初始化的成员变量则会自动赋一个默
javase面向对象
微风拂山岗
08-22 178
基本介绍 1. 面向（对象、过程、接口、函数） a. 过程 i. 按步骤去考虑事务发展 b. 对象 i. 先考虑事务中有哪些对象 ii. 再建立对象与对象的关系 2. 对象：真实存在的事物 a. 静态：属性（/变量/成员变量/实例变量） b. 动态：方法（/函数/成员方法/实例方法） c. 例：人 i. 属性：年龄、性别、姓名… ii. 方法：吃饭、睡觉、学习… 3. 类：多个对象抽取其共同点形成的概念 a. 现实中：先有对象后有类 b. 程序中：先有类后有对象 4. 对
面向对象一
qq_67171206的博客
08-31 128
封装：核心思想就是“隐藏细节”、“数据安全”，将对象不需要让外界访问的成员变量和方法私有化，只提供符合开发者意愿的公有方法来访问这些数据和逻辑，保证了数据的安全和程序的稳定。通过继承的上下转型、接口的回调以及方法的重写和重载可以实现多态。方法的重载本身就是一个多态性的体现。类表示一个共性的产物，是一个综合的特征，而对象，是一个个性的产物，是一个个体的特征。一个Java文件可以有多个类，但是以public修饰的只有一个，这个类的类名就是文件名。方法：就相当于人的一个个的行为，例如：说话、吃饭、唱歌、睡觉。..
JavaSE进阶-01-面向对象.pdf
09-10
在Java编程语言中，面向对象特性是其核心概念之一，本资料主要讲解了JavaSE进阶中的面向对象相关知识，包括final关键字、抽象类、接口、抽象类与接口的区别、Object类、package和import以及访问权限控制。...
Java自学视频教程-JavaSE基础-面向对象基础-01、面向对象概述.mp4
08-18
Java具有类似于C++语言的“形式和感觉”，但它要比C++语言更易于使用，而且在编程时彻底采用了一种“以对象为导向”的方式。 使用Java编写的应用程序，既可以在一台单独的电脑上运行，也可以被分布在一个网络的...
JavaSE--思维导图解析
07-26
* 面向对象（OOP 语言） * 高性能 * 分布式 * 健壮性 Java 基础 * `main` 方法：`public static void main(String[] args)` * 编译命令：`javac xxx.java` * 运行命令：`java xxx.java` * 语法习惯： + 类名大...
面向对象程序设计：JavaSE-任务71
08-08
面向对象程序设计是Java语言中的核心概念，JavaSE（Java Standard Edition）是Java平台的基础，它主要用于桌面应用程序的开发。任务71是一个基于Java的图书馆借阅系统项目，旨在锻炼学生对面向对象编程的理解和应用...
Java自学视频教程-JavaSE基础-面向对象基础-03、对象内存图.mp4
08-18
Java具有类似于C++语言的“形式和感觉”，但它要比C++语言更易于使用，而且在编程时彻底采用了一种“以对象为导向”的方式。 使用Java编写的应用程序，既可以在一台单独的电脑上运行，也可以被分布在一个网络的...
JavaSE面向对象
阿楠的博客
12-01 417
面向对象概述 （1）面向对象是一种自下而上的程序设计方法，一数据为中心，类是表现数据的单位，是划分程序的基本单位 （2）面向对象设计师自下而上的特性，允许开发者从问题的局部开始，在开发过程中逐步加深对系统的理解，需求变化会作用到系统开发本身，形成一种螺旋式的开发方式 （3）面向对象设计中，类封装了数据，而类的成员函数作为对外的接口，抽象地描述类，用类将数据和操作这些数据的函数放在一起，这就是面向对象设计方法的本质。 面向对象程序设计概述 面向对象程序设计（object-oriented-program
JavaSE---面向对象
qq_51302219的博客
07-14 213
面向对象
javaSE之面向对象
qq_37291761的博客
10-16 310
面向对象 思维导向图  心得体会  java语言开发是面向对象的，它不关心具体的底层实现。之前学C语言，要给一个数组排序，我们首先就要考虑用什么排序，什么排序效率高，如何实现这种排序等等的底层算法。而现在学了面向对象的java语言，我们应该考虑的是java底层为我们封装好了什么方法可以进行数组排序，事实上只需要仔细查阅一下API文档，这个问题便迎刃而解。例如Arrays类中提供了一个so...
【JavaSE】面向对象
LogosTR_的博客
08-09 346
JavaSE之面向对象
JavaSE之面向对象
夜雨寒霜
09-15 712
目录 一、类和对象 1.类和对象 1.1.对象 1.2.类 1.3.类和对象的关系 1.4.Java类的语法 2.属性：在类中定义的非静态变量，也被称为成员变量 2.1.属性声明 2.2.初始化初始化 2.2.和局部变量的区别？ 3.方法 3.1.方法的声明 3.2.方法的调用 3.2.方法的好处 4.参数传递 4.1.传值和传址 4.2.可变参数 4.3.ma...
JAVASE_面向对象中
天才来源于积累
03-22 397
代码块： 局部代码块：对局部变量进行初始化构造代码块：对对象的域进行初始化静态代码块：对类变量进行初始化 抽象类 方法只有声明没有实现，被abstract修饰，该方法就是抽象方法抽象类不能被实例化，因为抽象类实例化并没有意义可言抽象类必须有其子类覆盖了其所有的抽象方法后，该子类才能实例化，否则这个子类还是 抽象类。抽象类仍然可以存在构造函数，用于给子类对象提供初始化抽象类
（java学习笔记）JavaSE面向对象
陌然白（小白）的博客
04-04 1107
总：学习面向对象内容的三条主线 ​ 1.Java类及类的成员 ：属性 方法 构造器；代码块 内部类 ​ 2.面向对象的三大特征 ：封装 继承 多态 ​ 3.其它关键字 this super static final abstract interface package import… 文章目录总：学习面向对象内容的三条主线一、面向对象的两个要素1.类（Class）2.对象（O...
JAVASE基础：面向对象
yu_fu_a_bu的博客
03-01 116
面向对象 1. 面向对象与面向过程的区别（面向对象是基于面向过程的） ①面向对象将复杂的问题简单化 ②万事万物皆可对象 ③面向过程是执行者，面向对象是指挥者 2. 类和对象的关系 类：对具有相同属性和行为的事物的抽象 对象：实际存在的实体 类是对对象的描述，对象是类的实体 类和对象的使用 ①类的定义和使用 类的组成：属性和方法（成员变量和方法） public class Student { //属性:成员变量 // //方法:成员方法 int age; Strin
javase篇-第07讲--面向对象1
最新发布
09-08
在JavaSE中，我们可以通过封装、继承和多态来实现面向对象编程的目标。封装可以提高程序的可维护性和可复用性，继承可以减少重复编码的工作量，多态可以灵活地操作对象。掌握这些基本概念和关键术语，可以帮助我们更...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值