java面向对象浅析

Posted 2020-09-28 superficial。

1.（了解） 面向对象 vs 面向过程 例子：人开门；把大象装冰箱

2.面向对象的编程关注于类的设计！
1）一个项目或工程，不管多庞大，一定是有一个一个类构成的。
2）类是抽象的，好比是制造汽车的图纸。
而具体的一辆一辆的车，是根据图纸制造的，实际上就是类的实例化

3.完成一个项目（或功能）的思路
1）所要完成的功能对应的类的对象是否存在。
2）若存在，则通过对象直接调用对应的类中的属性或方法即可
3）若不存在，需要创建类的对象。甚至说，类都不存在，就需要设计类。

4.面向对象编程的三条主线：
1）类及类的构成成分：属性 方法 构造器 代码块 内部类
2）面向对象编程的特征：封装性 继承性 多态性 （抽象性）
3）其它的关键字：this super package import static final abstract interface ...

 

 

1.关于于类的设计

2.类的组成成分：
1） 属性（成员变量，Field）
2）方法（成员方法，函数，Method）

2.1属性：
* 成员变量 vs 局部变量
* 相同点：1.遵循变量声明的格式： 数据类型 变量名 = 初始化值
* 2.都有作用域
* 不同点：1.声明的位置的不同 ：成员变量：声明在类里，方法外
* 局部变量：声明在方法内，方法的形参部分，代码块内(main方法也是方法，所以main方法里边的变量也是)
* 2.成员变量的修饰符有四个：public private protected 缺省
* 局部变量没有修饰符，与所在的方法修饰符相同。
* 3.初始化值：一定会有初始化值。
* 成员变量:如果在声明的时候，不显式的赋值，那么不同数据类型会有不同的默认初始化值。
* byte short int long ==>0
* float double ==>0.0
* char ==>空格
* boolean ==>false
* 引用类型变量==>null
* 局部变量：一定要显式的赋值。（局部变量没有默认初始化值）
* 4.二者在内存中存放的位置不同:成员变量存在于堆空间中；局部变量：栈空间中
*
* 总结：关于变量的分类：1）按照数据类型的不同：基本数据类型（8种） & 引用数据类型
* 2）按照声明的位置的不同：成员变量 & 局部变量

2.2 方法：提供某种功能的实现 main方法也是方法，main方法里边的属性也必须要赋值。
* 1）实例：public void eat(){//方法体}
* public String getName(){}
* public void setName(String n){}
* 格式：权限修饰符 返回值类型（void:无返回值/具体的返回值） 方法名(形参){}
*
* 2)关于返回值类型：void：表明此方法不需要返回值
* 有返回值的方法：在方法的最后一定有return + 返回值类型对应的变量
* 记忆：void 与return不可以同时出现一个方法内。像一对“冤家”。
*
* 3)方法内可以调用本类的其他方法或属性，但是不能在方法内再定义方法！

3.面向对象编程的思想的落地法则一：
1）设计并创建类及类的成分
2）实例化类的对象  
3）通过“对象.属性”或"对象.方法"的形式完成某项功能

4.类的初始化的内存解析
4.1 内存划分的结构：
栈(stack):局部变量 、对象的引用名、数组的引用名
堆(heap):new 出来的“东西”（如：对象的实体，数组的实体），含成员变量
方法区:含字符串常量
静态域：声明为static的变量

4.2 理解的基础上，学会基本的创建的类的对象在内存中的运行。

 

* 方法的重载（overload）
* 要求：1.同一个类中 2.方法名必须相同 3.方法的参数列表不同（①参数的个数不同②参数类型不同）
* 补充：方法的重载与方法的返回值类型没有关系！

//如下的四个方法构成重载
//定义两个int型变量的和
public int getSum(int i,int j){
return i + j;
}
//定义三个int型变量的和
public int getSum(int i,int j,int k){
return i + j + k;
}
//定义两个double型数据的和
public double getSum(double d1,double d2){
return d1 + d2;
}

//定义三个double型数组的和
public void getSum(double d1,double d2,double d3){
System.out.println(d1 + d2 + d3);
}
//不能与如上的几个方法构成重载
// public int getSum1(int i,int j,int k){
// return i + j + k;
// }
// public void getSum(int i,int j,int k){
// System.out.println(i + j + k);
// }

//以下的两个方法构成重载。
public void method1(int i,String str){

}
public void method1(String str1,int j){

}

 

* 可变个数的形参的方法：
* 1.格式：对于方法的形参： 数据类型 ... 形参名
* 2.可变个数的形参的方法与同名的方法之间构成重载
* 3.可变个数的形参在调用时，个数从0开始，到无穷多个都可以。
* 4.使用可变多个形参的方法与方法的形参使用数组是一致的。
* 5.若方法中存在可变个数的形参，那么一定要声明在方法形参的最后。
* 6.在一个方法中，最多声明一个可变个数的形参。

//如下四个方法构成重载
//在类中一旦定义了重载的可变个数的形参的方法以后，如下的两个方法可以省略
// public void sayHello(){
// System.out.println("hello world!");
// }
// public void sayHello(String str1){
// System.out.println("hello " + str1);
// }
//可变个数的形参的方法
public void sayHello(String ... args){
for(int i = 0;i < args.length;i++){
System.out.println(args[i] + "$");
}
//System.out.println("=====");
}

public void sayHello(int i,String ... args){
//public void sayHello(String ... args,int i){
System.out.println(i);

for(int j = 0;j < args.length;j++){
System.out.println(args[j] + "$");
}
}

public void sayHello1(String[] args){
for(int i = 0;i < args.length;i++){
System.out.println(args[i]);
}
}

 

* 一、类的第三个成员：构造器(constructor 构造方法)
* constructor:建造者
* 构造器的作用：①创建对象 ②给创建的对象的属性赋值
*
* 1.设计类时，若不显式声明类的构造器的话，程序会默认提供一个空参的构造器.
* 2.一旦显式的定义类的构造器，那么默认的构造器就不再提供。
* 3.如何声明类的构造器。格式：权限修饰符 类名(形参){ }
* 4.类的多个构造器之间构成重载

* 二、类对象的属性赋值的先后顺序：①属性的默认初始化 ②属性的显式初始化③通过构造器给属性初始化
* ④通过"对象.方法"的方式给属性赋值

 

1.static:静态的，可以用来修饰属性、方法、*代码块（或初始化块）、*内部类

2.
static修饰属性（类变量）:
* 1.由类创建的所有的对象，都共用这一个属性
* 2.当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs 实例变量（非static修饰的属性，各个对象各自拥有一套副本）
* 3.类变量随着类的加载而加载的，而且独一份
* 4.静态的变量可以直接通过“类.类变量”的形式来调用
* 5.类变量的加载是要早于对象。所以当有对象以后，可以“对象.类变量”使用。但是"类.实例变量"是不行的。
* 6.类变量存在于静态域中。
*
* static修饰方法（类方法）:
* 1.随着类的加载而加载，在内存中也是独一份
* 2.可以直接通过“类.类方法”的方式调用
* 3.内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态的方法
* >静态的方法内是不可以有this或super关键字的！
* 注：静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构