流年似水博客开通了,本站主要是写关于Web和大数据方面内容,正在更新中,欢迎大家光临!
  1. 文章:97 篇
  2. 总浏览:35,098 次
  3. 评论:22条
  4. 最后更新:2020-06-08
  5. 分类目录:39 个

Java之面向对象基础(类、对象、属性、方法)

Java l, xy 146℃ 0评论
文章目录[隐藏]

面向对象

  1. 面向对象的理解

(1)      面向过程:

1           着重考虑实现功能的细节(侧重于“怎么做”),通常是以执行者的角度来思考问题。比较适合用于小型问题(小型项目)

 

(2)      面向对象

1           着重考虑找具体的对象来做事情(侧重于“谁来做”--找到合适的对象),思考问题的时候就是找对象的过程。通常以管理者的角度思考问题;比较适合中、大型项目。

(3)      面向对象和面向过程的对比

关系:

面向过程和面向对象是相互依赖、不可分割的。一般来说宏观上使用面向对象来思考问题,微观上(具体功能的实现)使用面向过程思考问题。

 

根本上来说面向对象就是找合适的人做合适的事,而面向过程更像是自己考虑怎么做事(考虑怎么实现)。从这个层面上来说,面向对象将具体的功能分给合适的人来做,从而解放了自己。

但是功能还是没有少,实现具体功能的时候还是会使用面向过程的思想。

(4)      举例:

1           租房子

1)         面向过程

  1. 58查看住房信息
  2. 联系房东
  3. 看房
  4. 签合同
  5. 居住

2)         面向对象

  1. 找中介 ---找合适的对象
  2. 看房
  3. 签合同
  4. 居住

2           吃饭

1)         面向过程:

  1. 买菜
  2. 洗菜
  3. 炒菜
  4. 吃饭
  5. 刷盘子

2)         面向对象:

  1. 去饭店
  2. 点餐
  3. 吃饭
  4. 走人

(5)      面向对象的步骤

1           找对象:

1)         方法:名词抽取法

2           找对象的属性、行为

1)         方法:

  1. 属性:一般是对象具有的特征
  2. 行为:动作抽取法,一般是对象具有的行为

3           将找到的对象就行抽象现实生活中具体的分类

1)         是否具有相同的特定

2)         是否具有相同的行为

4           使用java来描述的抽象出来的类,对象关系

现实生活中

Java语言中

属性

成员变量

 

行为

方法|函数

 

 

5           使用类创建对象,初始化对象,并调用其行为

  1. 类和对象的理解、区别、关系

(1)      类:

1           概念:对具有相同的特性(属性)和行为(方法)的一种抽象,成为类

2           类是对现实生活中一类事物的抽象,它具备该类事物的通用的属性(成员变量)和行为(方法)。

3           类是创建对象的模板。对代码的封装

(2)      对象

1           概念:世界上存在的一切可以使用语言能够描述的事物都成为对象 --- 生活上的概念

2           注意:

1)         对象是由类创建而来,它代表实现生活中具体存在的一类事物的一个个体(实例)

2)         每个对象可能具有不同的特点可以在初始化对象(new 对象)的时候指定,或者创建出来对象再对其初始化

(3)      区别

1           类是具有相同特征和行为对象的抽象,是抽象的,相当于创建对象的模板

2           对象是具体的、实际存在的实例。

(4)      关系

1           类是通过对象抽取出来的,是对象所属的类型

2           对象是通过类创建出来的实例

  1. 类和对象的内存分配

(1)      内存分配

1           栈(java虚拟机栈):

1)         存放内容:

  1. 方法调用时在栈中执行的,执行方法相当于入栈,执行完毕相当于出栈
  2. 执行方法的时候,保存方法中定义的局部变量

2)         特点:

  1. 线程独立的,每个线程独立分配内存空间。各个线程互补影响

3)         异常:

  1. StackOverFlowError : 栈溢出错误
  2. OutOfMemoryError:   堆溢出异常

2           :

1)         存放内容:

  1. 是存放对象的场所

2)         特点:

  1. 空间大
  2. 线程共享的
  3. 垃圾回收(GC)的重要区域

3)         异常:

  1. StackOverFlowError : 栈溢出错误
  2. OutOfMemoryError:   堆溢出异常

 

3           方法区:

1)         存放内容:

  1. 类的元信息
  2. 静态变量、静态方法
  3. 常量
  4. 字符串常量池

(2)      加载过程

1           加载

2           验证

3           准备

4           解析

5           初始化

  1. 类的成员变量(属性)

(1)      定义语法:

Class  类名{

//属性

 

//方法

}

(2)      成员变量的的类型可以是任意的

(3)      属性不赋值默认有默认值,同数组。

(4)      不同对象的属性是相互独立的

(5)      属性可以又称为成员变量或者全局变量

1           作用域:变量的作用(有效使用)范围,取决于包含定义变量的最近的大括号(for循环除外),

2           分类:根据不同的作用域划分

1)         全局变量

2)         局部变量

3           全局变量和局部变量的比较

1)         作用域不同:

  1. 全部变量的的作用域为本本类
  2. 局部变量的作用域一般为最近的一对大括号(一般是方法、分支、循环),for循环中的语法中定义的变量作用域为for循环

2)         赋值:

  1. 全部变量可以不赋初值,因为在创建的对象的时候JVM会自动初始化默认值。如果有显示初始化,则会覆盖JVM默认的初始化
  2. 局部变量使用前之前要初始化,否则回报编译错误;

3)         重名:

  1. 在同一个类中全局变量和局部变量可以同名,但是默认遵循作用域的原则(就近原则)。除非特别指明(可以使用this  类名.全局变量名)
  2. 在不同的作用域中,局部变量可以重名,互不影响

4)         存储位置

  1. 全局变量跟随对象存储在堆内存中,每个对象都有独立的成员变量,修改一个对象的成员变量,不会影响到另外对象的成员变量
  2. 局部变量一个是方法调用的时候在栈内存中存储,方法调用结束以后也顺之消失

5)         生命周期

  1. 成员变量:随着对象的创建而创建,随着对象的回收而消亡
  2. 局部变量:随着方法的执行而创建,随着方法执行完毕,局部变量消失

6)         方法修饰符

修饰符

作用域

作用

Public

所有(不同包也可以)

Java9之前,所有的地方都能方法

Private

本类

只能本类中有效

Protected

子类

只能在子类中有效

默认(不写)

本包

最大作用域为同一包下

 

 

 

Static

静态

静态,不能在静态中调用非静态方法和变量

Abstract

抽象

抽象,用来被使用

Final

最终

方法不能被重写

Synchronized

加锁

线程安全

strictfp

精度

浮点数精度提高

native

本地

调用操作系统内部方法,没有方法实现,用JVM实现

 

  1. 类的方法(函数)

(1)      方法的理解和好处

1           定义:方法是用于描述对象的动作(行为)或者功能的

1)         一定定义在类中

2)         非静态方法(成员方法)可以通过对象名.方法名()调用。

3)         静态方法还可以使用类名.静态方法名() 直接调用。

4)         注意:对象名.静态方法() 也可以调用;但是不推荐

2           好处:

1)         提高代码的复用性(重用性)

2)         实现了代码的封装,隐藏了功能的具体实现细节。

 

(2)      方法的五要素

[修饰符]返回类型  方法名(参数列表){

//方法体

}

  1. 修饰符,可选
  2. 返回类型

(1)      一个方法醉倒只能有一个返回值

(2)      返回类型可以为任意类型(包括基本类型、引用类型)

(3)      如果方法有返回值,则方法体必须要有return语句,并且return 后跟的类型必须和返回值类型一致或者能只能转换为返回值类型

(4)      如果方法没有返回值,则return后面什么都用写;此时返回值应该写成void

  1. 方法名

(1)      遵循驼峰命名

(2)      见名知意

  1. 参数列表

(1)      一个方法可以没有参数、也可以有多个参数;多个参数应该使用隔开例如 :(类型  参数名1,类型 参数名2

(2)      参数类型可以是任意类型

(3)      调用方法的时候,一定对应参数列表传入相同类型或者兼容类型(自动转换)的参数。

(4)      注意:

  1. 方法内不能在定义方法
  1. 方法体

(1)      可以写任意代码

  1. 分支、循环、顺序、方法调用、调用自己等等

 

(3)      方法的声明

1           无参无返回值

2           无参有返回值

3           有参无返回值

4           有参有返回值

 

(4)      方法的调用

1           同一类中方法调用:

1)         直接写方法名调用

例如: 方法名(【参数列表】);

2)         注意事项:

  1. 不能在静态方法内调用非静态的方法

2           跨类中的方法调用:

1)         成员方法:

  1. 对象名.方法名(【参数列表】);

2)         静态方法:

  1. 对象名.方法名(【参数列表】);
  2. 类名.静态方法名(【参数列表】);

(5)      方法的调用机制

(6)      方法的参数传递

1           基本类型

1)         传入的变量保存的值,相当于值拷贝

2)         方法内修改不会影响到传入的实参值,但是swap方法内确实是交换了,但是方法运行结束会出栈。


public static void main(String[] args) {
int a = 10;
int b = 5;
swap(a,b);
System.out.println(" main method's a = "+a + ", b = "+ b);
}

public static void swap(int a , int b ){
int temp = a;
a = b;
b = temp;
System.out.println(" swap method's a = "+a + ", b = "+ b);
}
打印结果:
swap method's a = 5, b = 10
main method's a = 10, b = 5

 

2           引用类型(接口、类、数组)

1)         传入的是引用类型的地址值,相当于值拷贝。只不过是保存的是引用类型在堆内存对象的地址值

2)         方法内修改传入的引用可以影响实参的值(实际上修改是的相同堆内存中的对象)


public static void main(String[] args) {
int[] ints = {1,3,5,7,8,9};
//修改引用类型
changeArray(ints);
//打印
System.out.println("main 方法内: ");
printArray(ints);
}

public static void changeArray(int[] ints){
for (int i = 0; i < ints.length; i++){
ints[i] *= 2;
}
System.out.println("changeArray 方法内: ");
printArray(ints);
}
/**
* 打印
* */
public static void printArray(int[] ints){
for (int i : ints){
System.out.print(i+"\t");
}
System.out.println();
}

打印结果:
changeArray 方法内:
2 6 10 14 16 18
main 方法内:
2 6 10 14 16 18

 

  面试题1 java到底是按什么类型传递参数?

Java是按照值传递的;基本数据类型做实参的时候,传递的实参保存的值。引用类型做实参的时候,传递的时保存的地址。

面试题2: 如果传入引用类型,在方法内有重新修改形参引用,则不会影响实参的值(前提,在修改形参引用前,没有修改属性)


public static void main(String[] args) {
Person person = new Person();
person.name = "张向杨";
changePerson(person);
System.out.println(" main 方法内: person.name = " + person.name);
}
/**
* 修改person的属性
* */
public static void changePerson(Person person){
person = new Person();
person.name = "鲁雪艳";
System.out.println(" changePerson 方法内: person.name = " + person.name);
}

class Person{
String name;
}

结果:
changePerson 方法内: person.name = 鲁雪艳
main 方法内: person.name = 张向杨

 

(7)      方法的重载、重写

1           重载

1)         概念:一般同一类中方法名相同,参数列表不同

  1. 好处:

a)         同一功能的方法同名,方便开发者调用

2)         注意事项:

  1. 方法名一定相同
  2. 参数列表不同,包括三个方面:

a)         参数类型不同

b)        参数个数不同

c)         参数顺序不同

  1. 跟返回值没有任何关系(返回值类型可以不同)
  2. 调用重载方法时,会优先寻找与传入实参类型相同的方法调用;若找不到,则找最接近兼容类型的方法(参数类型能够自动转换的)调用;若能够找到多个兼容类型,则编译错误。




public static void main(String[] args) {
//调用的时 sum(int a ,int b )方法
sum(4,6);
//调用的时 sum(double a ,double b )
sum(3.5,9);
}


public static void sum(int a ,int b ){

}
public static void sum(double a ,double b ){

}


public static void main(String[] args) {
//调用的时 sum(double a ,int b )方法
sum(4,6);
}


public static void sum(double a ,int b ){
System.out.println("....");
}
public static void sum(double a ,double b ){
System.out.println("*******");
}
结果:
....


public static void main(String[] args) {
//编译报错,在相同的兼容性上,有两个方法,不能确定是哪一个
sum(4,6);
}

public static void sum(double a ,int b ){
System.out.println("....");
}
public static void sum(int a ,double b ){
System.out.println("*******");
}

public static void 可变参数(int ... ints){
System.out.println(ints);
}

 

 

2           重写

1)         概念:在继承或者实现中重写父类或者接口中的方法。

2)         必要条件:

  1. 一定要存在继承或者实现关系

3)         注意事项:

  1. 一般子类中使用注解@override修饰,表示是重写(覆盖)的方法
  2. 重写时子类方法的返回值、方法名、参数列表必须和父类或者接口中原方法完全相同
  3. 重写时子类方法的修饰符一定要大于或者等于父类的修饰符

(8)      构造方法

1           概念:方法的名称和类型相同,没有返回值的方法

2           作用:

1)         可以创建对象

2)         创建对象的时候,对象进行初始化
 

3           特点:

1)         构造方法没有返回值

2)         构造方法的方法名和类名相同

3)         构造方法可以创建对象

4)         构造方法的默认修饰符与类的修饰符相同

5)         构造方法内可以调用其他构造方法、或者成员方法

6)         构造方法在一行隐式有一条super() 语句

 

 

4           注意事项:

1)         当一个类中没有显示的声明构造方法的时候,编译器会自动创建一个修饰符类的修饰符相同的无参构造方法。当我们显示的声明构造方法以后,默认的构造方法将不存在。

2)         如果父类中显示的定义了有参的构造方法(没有定义无参的构造方法),子类的构造方法中如果没有显示调用父类有参构造方法,将会编译报错。

 

(9)      可变参数

1           概述:

1)         JDK5出来的特性,可以在同一类中对具有相同功能的重载方法(形参类型相同,但是个数不同)或者相同类型的参数不确定个数的情况进行封装

2           可变参数的好处

1)         可以提高代码的复用性

 

3           特点:

1)         可用参数可以和其他类型一起使用,但是可变参数只能在方法参数列表的末尾使用。否则编译报错

2)         在一个方法中的形参中,只能有一个可变参数,否则编译错误

3)         可变参数可以接受一个或者多个相同类型的参数,也可以不传入(0个参数),也可以传入可变参数类型的数组

4)         底层其实是用数组来实现的,可以使用数组的方式处理

5)         重载的时候,不能出现相同类型的数组



//可以编译通过
public static void 可变参数(int ... ints){
System.out.println(ints);
}
//可以编译通过
public static void 可变参数(int a ,int ... ints){

}

但是,使用的时候,可变参数.(1,3,4)这样调用,会出现编译错误



public static void main(String[] args) {
//编译错误,无法找到合适的方法,因为两个都可以
可变参数(1,21,6);
}

public static void 可变参数(int ... ints){
System.out.println(ints);
}

public static void 可变参数(int a ,int ... ints){

}

6)         如果可变参数类型和其对应的数组类型相同,构成重载会报错;编译错误。不能定义相同的方法,因为可变参数是使用数组实现,编译器会当成数组来处理


public class 可变参数 {

/**
两个存在出现编译错误
*/
public static void sum(int[] ints) {

}

public static void sum(int... ints) {

}


}

 

 

转载请注明:流年似水 » Java之面向对象基础(类、对象、属性、方法)

喜欢 (0)or分享 (0)

Warning: copy(https://cn.gravatar.com/avatar/?s=54&d=%2Fwp-content%2Fthemes%2Fyusi1.0%2Fimg%2Fdefault.png&r=g): failed to open stream: HTTP request failed! HTTP/1.1 400 Bad Request in /usr/share/nginx/html/timewentby/wp-content/themes/yusi1.0/functions.php on line 239

Warning: copy(/wp-content/themes/yusi1.0/img/default.png): failed to open stream: No such file or directory in /usr/share/nginx/html/timewentby/wp-content/themes/yusi1.0/functions.php on line 243
发表我的评论
取消评论

表情

Hi,您需要填写昵称和邮箱!

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址