面向对象

最新推荐文章于 2024-04-13 14:08:13 发布
最新推荐文章于 2024-04-13 14:08:13 发布
阅读量186 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46334360/article/details/117653399
版权

文章目录

1.概述

面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。
面向对象是相对于面向过程来讲的，指的是把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

  • 面向过程到面向对象思想层面的转变：
    面向过程关注的是执行的过程，面向对象关注的是具备功能的对象。
    面向过程到面向对象，是程序员思想上从执行者到指挥者的转变。
  • 三大思想
    OOA：面向对象分析（Object Oriented Analysis）
    OOD：面向对象设计（Object Oriented Design）
    OOP：面向对象程序（Object Oriented Programming
  • 三大特征
    封装性：所有的内容对外部不可见
    继承性：将其他的功能继承下来继续发展
    多态性：方法的重载本身就是一个多态性的体现

2.类与对象

2.1两者关系

类表示一个共性的产物，是一个综合的特征，而对象，是一个个性的产物，是一个个体的特征。 （类似生活中的图纸与实物的概念。）
类必须通过对象才可以使用，对象的所有操作都在类中定义。
类由属性和方法组成：
· 属性：就相当于人的一个个的特征
· 方法：就相当于人的一个个的行为，例如：说话、吃饭、唱歌、睡觉

2.2类的定义格式

class 类名称{ 
	成员属性 
	成员方法 
}

类必须编写在.java文件中
一个.java文件可以存在N个类，但是只能存在一个public修饰的类（对外的公用类）
.java文件的文件名称必须与public修饰的类名完全一致

2.3对象创建的内存细节

/**
 * 对象创建的内存细节
 *
 */
public class Demo3 {
	public static void main(String[] args) {
		Book b1 = new Book();
		b1.name = "金苹果";
		b1.info = "讲述了果农辛勤种植金苹果的过程。";
		b1.say();
		
		Book b2 = b1;
		b2.name = "嘿嘿嘿";
		
		b1.say();
	}
}

class Book{
	String name;
	String info;
	
	void say() {
		System.out.println("书名："+name+"，简介："+info);
	}
}

对象就是对象，名称就是名称，这里的b2还是上面的那个对象，只不过换了名称。

  • 栈

Java栈的区域很小 , 大概2m左右 , 特点是存取的速度特别快 栈存储的特点是, 先进后出
存储速度快的原因:
栈内存, 通过 ‘栈指针’ 来创建空间与释放空间
指针向下移动, 会创建新的内存, 向上移动, 会释放这些内存
这种方式速度特别快 , 仅次于PC寄存器
但是这种移动的方式, 必须要明确移动的大小与范围, 明确大小与范围是为了方便指针的移动 , 这是一个对于数据存储的限制, 存储的数据大小是固定的 , 影响了程序 的灵活性 ~
所以我们把更大部分的数据 存储到了堆内存中

存储的是: 基本数据类型的数据 以及 引用数据类型的引用!
例如:

int a =10; 
Person p = new Person();

10存储在栈内存中 , 第二句代码创建的对象的引用§存在栈内存中。

  • 堆

存放的是类的对象

Java是一个纯面向对象语言, 限制了对象的创建方式:
所有类的对象都是通过new关键字创建
new关键字, 是指告诉JVM , 需要明确的去创建一个新的对象 , 去开辟一块新的堆内存空间
堆内存与栈内存不同, 优点在于我们创建对象时 , 不必关注堆内存中需要开辟多少存储空间 , 也不需要关注内存占用时长
堆内存中内存的释放是由GC(垃圾回收器)完成的
垃圾回收器 回收堆内存的规则:
当栈内存中不存在此对象的引用时,则视其为垃圾 , 等待垃圾回收器回收
例如:

Person p0 = new Person(); 
Person p1 = p0; 
Person p2 = new Person();

将上面的代码在图中演示：
在这里插入图片描述

public class Demo3 {

	public static void main(String[] args) {
		Book b1 = new Book();
		b1.name = "金苹果";
		b1.info = "讲述了果农辛勤种植金苹果的过程。";
		
		Book b2 = new Book();
		b2.name = "银苹果";
		b2.info = "讲述了果农辛勤种植银苹果的过程。";
		
		b2 = b1;
		b2.name = "铜苹果";
		b1.say();
	}

}

class Book{
	String name;
	String info;
	
	void say() {
		System.out.println("书名："+name+"，简介："+info);
	}
}

这里的b2被当做垃圾回收了：
在这里插入图片描述

2.4构造方法

用于对象初始化，在创建对象时调用
如手机游戏在刚打开，加载进度的时候，就是在调用构造方法进行初始化

所有的Java类中都会至少存在一个构造方法
如果一个类中没有明确的编写构造方法, 则编译器会自动生成一个无参的构造方法, 构造方法中没有任何的代码；
如果自行编写了任意一个构造器, 则编译器不会再自动生成无参的构造方法。

2.5方法重载

2.5.1普通方法的重载

public class Demo5 {

	public static void main(String[] args) {
		Math m = new Math();
		int num = m.sum(100, 500);
		System.out.println(num);
		
		double num2 = m.sum(10.5, 20.6);
		System.out.println(num2);
	}
}
// 命名规范 见名知意
class Math{
	/**
	 * 一个类中定义的方法， 是允许重载的（相同的方法名称）
	 * 限制：
	 * 1、方法名称相同
	 * 2、参数列表长度 或 参数列表类型 或 （参数类型顺序不同）
	 * 
	 * 注意： 与返回值类型无关
	 * 
	 */
	int sum(int x,int y) {
		int z = x+y;
		return z;
	}
	
	double sum(double x,double y) {
		double z = x+y;
		return z;
	}
	
	double sum(int x,double y) {
		double z = x+y;
		return z;
	}
	
	double sum(double y,int x) {
		double z = x+y;
		return z;
	}	
}

方法名称相同, 参数类型或参数长度不同, 可以完成方法的重载
方法的重载与返回值无关
方法的重载 ,可以让我们在不同的需求下, 通过传递不同的参数调用方法来完成具体的功能。

2.5.2构造方法重载

public class Demo6 {

	public static void main(String[] args) {
		Person3 p = new Person3("张三",18);
		p.say();
		
		Person3 p2 = new Person3("李四");
		p2.say();
	}
}
class Person3{
	
	Person3(String name2,int age2){
		name = name2;
		age = age2;
	}
	
	Person3(String name2){
		name = name2;
	}
	
	String name;
	int age;
	
	void say() {
		System.out.println("自我介绍： 姓名："+name+", 年龄："+age);
	}
}

一个类可以存在多个构造方法
参数列表的长度或类型不同即可完成构造方法的重载
构造方法的重载 ,可以让我们在不同的创建对象的需求下, 调用不同的方法来完成对象的初始化

2.6匿名对象

public class Demo7 {

	/**
	 * 匿名：没有名字
	 */
	public static void main(String[] args) {
		int num = new Math2().sum(100, 200);
		System.out.println(num);
	}
}

class Math2{
	
	int sum(int x,int y) {
		return x+y;
	}
}

没有对象名称的对象 就是匿名对象。
匿名对象只能使用一次，因为没有任何的对象引用，所以将称为垃圾，等待被G·C回收。
只使用一次的对象可以通过匿名对象的方式完成，这一点在以后的开发中将经常使用到。

2.7this关键字

this指的是当前对象
this可以调用属性和方法

2.8static关键字

static修饰的属性在方法区中，不需要依赖对象来访问，直接通过类来访问：
静态修饰的属性为类的属性
非静态修饰的属性为对象的属性

调用static构造方法的代码，必须写在子类构造方法的第一行

无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )

静态修饰的方法被调用时，有可能对象还未创建，因此，在访问时，静态资源不能访问非静态（因为非静态需要对象创建），而非静态可以访问静态

2.9包

通常由多个单词组成， 所有单词的字母小写， 单词与单词之间使用.隔开 ，一般命名为“com.公司名.项目 名.模块名…”。

2.10代码块

  • 普通代码块 在执行的流程中出现的代码块， 我们称其为普通代码块。
  • 构造代码块 在类中的成员代码块，我们称其为构造代码块，在每次对象创建时执行，执行在构造方法之前。
  • 静态代码块 在类中使用static修饰的成员代码块，我们称其为静态代码块，在类加载时执行。 每次程序启动到关闭，只会执行一次的代码块。
  • 同步代码块 在后续 多线程 技术中学习。

面试题：
构造方法 与 构造代码块 以及 静态代码块的执行顺序：
静态代码块 --> 构造代码块 --> 构造方法

3.继承

和C++相比，Java只有单继承，没有多继承，也就是一个子类只能有一个父类；
但是可以多重继承，比如A继承B，B又继承C

3.1super

  • 通过super，可以访问父类构造方法、属性、方法
  • 调用super构造方法的代码，必须写在子类构造方法的第一行（与static相同，一个构造函数不能同时调用super和static）

3.2重写

  • 参数列表、返回类型必须与被重写方法相同
  • 访问权限不能比被重写方法的权限更低
  • 父类的成员方法只能被子类重写
  • 声明为static和private的方法不能被重写

Java中重写（Override）和重载（Overload）的区别：

类型重载重写
发生的位置一个类中子父类中
参数列表限制必须不同必须相同
返回值类型与返回值类型无关返回值类型必须一致
访问权限与访问权限无关子的访问权限不能小于父的方法权限
异常处理与异常无关异常范围可以更小，但不能抛出新的异常

3.3final关键字

3.3.1final修饰属性、变量

  • 变量成为了常量，无法对其再次进行赋值
  • final修饰的局部变量只能赋值一次（可以先声明再赋值）
  • final修饰的成员属性，必须在声明时赋值

全局常量 public static final
常量的命名规范：

  • 由一个或多个单词组成，单词与单词之间必须使用下划线隔开，单词中所有字母大写

3.3.2final修饰类

  • final修饰的类，不可以被继承

3.3.3final修饰方法

  • final修饰的方法，不能被子类重写

4.抽象类

4.1概述

抽象类所描述的行为是模糊的
在抽象类的使用中有几个原则：
抽象类本身是不能直接进行实例化操作的（不能创建对象），即：不能直接使用关键字new完成。
一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须覆写（重写）抽象类中的全部抽象方法。

继承抽象类的类可以是抽象的，或者实现父类的方法。

4.2常见问题

1、 抽象类能否使用final声明？
不能，因为final属修饰的类是不能有子类的，而抽象类必须有子类才有意义，所以不能。

2、 抽象类能否有构造方法？
能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默认是无参的），之后再调用子类自己的构造方法。
（不能由我们创建，但是能被Java虚拟机创建）

1、抽象类必须用public或protected修饰（如果为private修饰，那么子类则无法继承，也就无法实现其抽象方法）。 默认缺省为 public
2、抽象类不可以使用new关键字创建对象， 但是在子类创建对象时， 抽象父类也会被JVM实例化。
3、如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必须定义为 abstract类。

5.接口

接口可以多实现：

class 子类 implements 父接口1,父接口2...{

}

以上的代码称为接口的实现。那么如果一个类即要实现接口，又要继承抽象类的话，则按照以下的格式编写即可：

class 子类 extends 父类 implements 父接口1,父接口2...{ 

}
  • 面向接口编程思想
  • 这种思想是接口是定义（规范，约束）与实现（名实分离的原则）的分离。
  • 优点：
    1、 降低程序的耦合性
    2、 易于程序的扩展
    3、 有利于程序的维护

接口中都是全局常量，因此在定义变量时可以省略public static final，但是要给它赋值；
接口中都是抽象方法，因此在定义方法时可以省略public abstract。

6.多态

6.1概述

对象的多态性：对象的多种表现形式

方法的重载 和 重写 也是多态的一种， 不过是方法的多态（相同方法名的多种形态）。
重载： 一个类中方法的多态性体现
重写： 子父类中方法的多态性体现。

6.2对象类型的转换

类似于基本数据类型的转换：

  • 向上转型：将子类实例变为父类实例
  • 格式：父类 父类对象 = 子类实例 ；
  • 向下转型：将父类实例变为子类实例（强转）
  • 格式：子类 子类对象 = （子类）父类实例 ；

6.3instanceof

作用：判断某个对象是否是指定类的实例，则可以使用instanceof关键字
格式：实例化对象 instanceof 类
此操作返回boolean类型的数据
例如：

if(p instanceof Student){
	Student s = (Student)p;
	s.say();
}else {
	System.out.println("必须传入学生形态，才可以执行");
}

7.Object类

7.1概念

Object类是所有类的父类（基类），如果一个类没有明确的继承某一个具体的类，则将默认继承Object类。
例如我们定义一个类：

public class Person{

}

其实它被使用时是这样的：

public class Person extends Object{ 

}

7.2方法

7.2.1toString()

建议重写Object中的toString方法。
此方法的作用：返回对象的字符串表示形式。
Object的toString方法， 返回对象的内存地址。

7.2.2equals()

equals调用的是==，它比较的是内存地址
按顺序比较
在eclipse中快捷键Alt+shift+s可以自动生成equals代码。

8.内部类

8.1概念

在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。
广泛意义上的内部类一般来说包括这四种：
1、成员内部类
2、局部内部类
3、匿名内部类
4、静态内部类

内部类的应用很少

8.2成员内部类

成员内部类是最普通的内部类，它的定义为位于另一个类的内部，形如下面的形式：

class Outer { 
	private double x = 0; 
	public Outer(double x) { 
		this.x = x; 
	}
	
	class Inner { //内部类 
		public void say() { 
			System.out.println("x="+x);	 			    
		} 
	} 
}

特点： 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问 的是成员内部类的成员。

如果要访问外部类的同名成员，需要以下面的形式进行访问：
外部类.this.成员变量
外部类.this.成员方法

外部使用成员内部类：

Outter outter = new Outter(); 
Outter.Inner inner = outter.new Inner();

8.3局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或 者该作用域内。 例如：

class Person{ 
	public Person() { 

	} 
}
class Man{ 
	public Man(){ 

	}

	public People getPerson(){ 
		class Student extends People{ //局部内部类 
		int age =0; 
		}
		return new Student(); 
	} 
}

注意:局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

8.4匿名内部类

匿名内部类由于没有名字，所以它的创建方式有点儿奇怪。创建格式如下：

new 父类构造器（参数列表）|实现接口（） {
//匿名内部类的类体部分 
}

在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一 个接口。
同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用，当然这个引用是隐式的。

匿名内部类 / 局部内部类 只能访问final型的局部变量
平时是默认省略了final（java 1.8之后）
因为 内部类被编译成了一个单独的字节码文件，单独的文件中变量与外部的值绝对是一致的。

8.5静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。
静态内部类是不需要依赖于外部类对象的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法。

9.包装类

9.1概述

在Java中有一个设计的原则“一切皆对象”，那么这样一来Java中的一些基本的数据类型，就完全不符合于这种设计思 想，因为Java中的八种基本数据类型并不是引用数据类型，所以Java中为了解决这样的问题，引入了八种基本数据类型 的包装类。
在这里插入图片描述

八种包装类也是分为两种大的类型的：

  • Number：Integer、Short、Long、Double、Float、Byte都是Number的子类表示是一个数字。
  • Object：Character、Boolean都是Object的直接子类。

9.2装箱和拆箱操作

以下以Integer和Float为例进行操作
将一个基本数据类型变为包装类，那么这样的操作称为装箱操作。
将一个包装类变为一个基本数据类型，这样的操作称为拆箱操作。

装箱操作：
在JDK1.4之前 ，如果要想装箱，直接使用各个包装类的构造方法即可，例如：

int temp = 10 ; // 基本数据类型 
Integer x = new Integer(temp) ; // 将基本数据类型变为包装类

在JDK1.5，Java新增了自动装箱和自动拆箱，而且可以直接通过包装类进行四则运算和自增自建操作。例如：

Float f = 10.3f ; // 自动装箱 
float x = f ; // 自动拆箱 
System.out.println(f * f) ; // 直接利用包装类完成 
System.out.println(x * x) ; // 直接利用包装类完成

10.可变参数

一个方法中定义完了参数，则在调用的时候必须传入与其一一对应的参数，但是在JDK 1.5之后提供了新的功能，可以根据需要自动传入任意个数的参数。

int…num：表示的是可变参数，调用时可以传递0-n个数字；
在方法内部，可变参数以数组作为载体体现

语法：

返回值类型 方法名称(数据类型…参数名称){ 
//参数在方法内部 ， 以数组的形式来接收 
}

注意： 可变参数只能出现在参数列表的最后。

11.递归

11.1概述

递归，在数学与计算机科学中，是指在方法的定义中使用方法自身。也就是说，递归算法是一种直接或者间接调用自身方法的算法。
在这里插入图片描述

11.2递归实现阶乘

int fact(int n){
	if(n == 1){
		return 1;
	}else {
		return n*fact(n-1);
	}
}

在这里插入图片描述
递归效率很低，能用循环就不用递归。

12.异常处理

12.1 try-catch

在这里插入图片描述
受检异常：JVM在程序未执行时可发现，会划红线
非受检异常：只有程序执行时才可以发现的异常

加了异常处理之后，程序可以正常往下执行，而不会崩

public class Test1 {
    public static void main(String[] args) {
        int num = menu();
        System.out.println("你输入的是:"+num);
    }
    public static int menu(){
        System.out.println("请根据提示,选择功能序号:");
        System.out.println("1. 增加XX");
        System.out.println("2. 删除XX");
        System.out.println("3. 修改XX");
        System.out.println("0. 退出");

        Scanner input = new Scanner(System.in);
        int num = -1;
        try{
            num = input.nextInt();
            if(num<0 || num>3){
                //程序有问题 , 输入有误
                System.out.println("功能序号必须是: 0/1/2/3");
                return menu();
            }
            return num;
        }catch(InputMismatchException e){
            //System.out.println("哈哈哈, 程序出错了.");
            //补救
            System.out.println("必须输入数字哦");
            return menu();
        }
    }
}

异常处理不是只打印出异常，最好要进行补救。

在进行异常的处理之后，在异常的处理格式中还有一个finally语句，那么此语句将作为异常的统一出口，不管是否产生了异常，最终都要执行此段代码。

 public static void main(String[] args) {

        haha();
    }
    public static void haha(){
        try{
            int a = 10;
            int b = 0;
            System.out.println(a/b);
        }catch(Exception e){
            //退出JVM
            System.out.println("出现了异常");
            System.exit(0);
        }finally {
            System.out.println("锄禾日当午,汗滴禾下土");
        }
    }

上述代码未执行finally，停电了、电脑被关机等也不会执行finally。

public static void main(String[] args) {
        Person p = haha();
        System.out.println(p.age);
    }
    public static Person haha(){
        Person p = new Person();
        try{
            p.age = 18;
            return p;
        }catch(Exception e){
            return null;
        }finally {
            p.age = 28;
        }
    }
    static class Person{
        int age;
    }

打印结果是28，因为在try中return p准备好返回但还未返回的时候，执行了finally中的语句，改为了28。

12.2 throws

此关键字主要在方法的声明上使用，表示方法中不处理异常，而交给调用处处理。
格式：返回值 方法名称()throws Exception{ }

  • 如果是传参导致异常，应该通过throws抛出去

12.3 throw

throw关键字表示在程序中人为的抛出一个异常，因为从异常处理机制来看，所有的异常一旦产生之后，实际上抛出的就是一个异常类的实例化对象，那么此对象也可以由throw直接抛出。
代码： throw new Exception(“抛着玩的。”) ;

此关键字用的很少。

12.4自定义异常

编写一个类， 继承Exception，并重写一参构造方法 即可完成自定义受检异常类型。
编写一个类， 继承RuntimeExcepion，并重写一参构造方法 即可完成自定义运行时异常类型。

薄雾浓^
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
面向对象（最全！！！）
weixin_51500230的博客
12-10 927
面向对象
面向对象（OOP）
天宇龙腾的博客
12-02 4122
面向对象程序设计（OOP - object oriented programming） 面向对象程序由对象组成，每个对象对用户公开特定功能并隐藏实现的部分，很多的对象来自Java标准库，也存在一部分是开发者自定义的，只要当前对象能够满足要求，就不必去关心其功能是如何实现的。 面向对象将数据放在第一位，再去考虑操作数据的算法，操作数据的过程也就被称为方法。 类便是构建对象的模板，由类构造对象的过程称为创建类的实例。创建时使用构造器（构造函数）创建新实例（对象），如果希望构造的对象可以多次使用，那么就会将对象存
【新版】系统架构设计师 - 知识点 - 面向对象开发方法
初八
04-13 1096
知识点 - 面向对象开发方法
面向对象（详解）
bu_xiang_tutou的博客
04-02 1765
java类名必须是一个或多个有意义的单词连缀而成，每个单词首字母大写，其他小写。单词与单词之间没有分隔符。构造器，成员变量，方法，初始化块，内部类。构造器，成员变量，方法。
【Java基础篇】面向对象(Object Oriented)
输入技术、输出想法
08-24 2866
面向对象(Object Oriented）1. 面向对象概念1.1 什么事面向对象1.2 理解面向对象1.3 面向对象的特点1.4 面向对象开发设计,特征2. 类与对象2.1 什么是类2.2 类与对象的关系3. 类的定义4. 成员变量与局部变量的区别4.1 成员变量4.2 局部变量4.3 成员变量初始化5. 创建对象,使用对象6. 对象内存结构6.1 对象的产生6.2 对象的生命周期7. 匿名对象 1. 面向对象概念 1.1 什么事面向对象 面向对象(Object Oriented)是一种思想，90年代以
面向对象的思维过程
03-02
本文是关于面向对象思维过程系列文章的第一部分，选择这个主题作为书籍或专栏的标题是一个重大的决定，做出这个选择并不简单，因为已经有很多面向对象主题的好书和文章了，包括面向对象分析、面向对象设计、面向对象...
C++ 面向对象示例
08-17
【C++ 语言】面向对象 ( 类定义 | 限制头文件引用次数 | 构造方法 | 析构方法 ) : https://hanshuliang.blog.csdn.net/article/details/99609557 【C++ 语言】面向对象 ( 成员函数 | 常量函数 | 友元函数 | 友元类 ...
面向对象面向对象面向对象
最新发布
07-03
面向对象面向对象面向对象
Java面向对象
07-24
包括Java高级教程中多态使用，面向对象编程
java面向对象的实例
11-09
java面向对象的实例，代码java的三大特性，封装，继承，多态以及关键字的运用！
java面向对象.pdf
02-15
Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向...
面向对象闲话
01-31
如果你要把一只猫卖给一个计算机专家，千万不要说它有多聪明多可爱，而要说，这是一只面向对象的猫。这是程序员对程序员的揶揄。面向对象渗透到软件的各个领域，既然找不到银弹，这颗铜子弹成了我们对抗人狼的最佳...
什么是面向对象？
热门推荐
weixin_61665636的博客
11-25 1万+
象原型__proto__和构造函数原型对象prototype都有一个属性，叫做constructor，称之为构造函数，主要记录该对象引用了哪个构造函数，可以让原型对象重新指向原来的构造函数，这就是为什么在实例对象中传递参数时，构造函数本身不需要写return返回结果的原因。属性是对象的状态，方法是对象的行为（完成某种任务）。即this作用域的问题。是一种特殊的函数，主要用来初始化对象，即为对象成员变量赋初始值，它总是与new一起使用，我们可以把对象中的一些公共的属性和方法抽取出来，然后封装到这个函数里面。
面向对象（JAVA）
一个很懒的人
06-29 2177
本文详细介绍了java面向对象的相关知识，包括但不限于以下知识： 1. 类与对象 2. 面向对象三大特征：封装、继承、多态 3. 面向对象三大修饰符：（final、abstract、static）

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值