面向对象
面向对象的思想概述
程序员从面向过程的执行者转化成了面向对象的指挥者
面向对象分析方法分析问题的思路和步骤：
1.根据问题需要，选择问题所针对的现实世界中的实体。
2.从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类
3.把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义
4.将类实例化成计算机世界中的的对象。对象是计算机世界中解决问题的最终工具。
###面向对象两个要素：类和对象
类(class)和对象(Object)是面向对像的核心概念.
类是对一类事物的描述，是抽象的，概念上的定义
对象是实际存在的该类事物的每个个体，因而也称为实例(instance)
对象的功能完全取决于类的设计
面向对象程序设计的重点是类的设计
设计类，就是设计类的成员
万事万物皆对象
1.在Java语言范畴中，我们将功能，结构等封装到类中，通过类的实例化来调用具体的功能结构
Scanner,String等
文件：File
网络资源：URL
2.涉及到Java语言与前端Html，后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类，对象。
Java类及类的成员
生活中描述事物无非就是描述事物的属性和行为。如：人有身高，体重等属性，有说话，打球等行为。
属性
————类的结构之一
属性=成员变量=field=域，字段
属性（成员变量） vs 局部变量
1.相同点：
-
1定义变量的格式： 数据类型 变量名=变量值
-
2先声明，后使用
-
3 变量都有其对应的作用域
2.不同点
- 1在类中声明的位置不同
属性：直接定义在类的一对{}内
局部变量：声明在方法内，方法形参，代码块内，构造器形参，构造器内的变量
- 3关于权限修饰符的不同
属性：可以声明属性时，指明其权限，使用权限修饰符
常用的权限修饰符：private,public,缺省(不加权限修饰 符),protected
权限修饰符放在数据类型的前面
局部变量：不可以使用权限修饰符
-
4默认初始化值的情况
属性：类的属性，根据其类型，都有默认初始化值
整型(byte, short,int,long) ：0
浮点型(float,double)：0.0
字符型(boolean)：false
引用数据类型(类，数组，接口)：null
局部变量：没有默认初始化值。（局部变量都放在栈中）
意味着，我们在调用局部变量之前，一定要先赋值
特别的，形参在调用时，我们赋值即可
-
5在内存中加载的位置
属性：加载到堆空间中（非static）
局部变量：加载到栈空间中
方法（行为）
————类的结构之二
方法=成员方法=函数=method
类中方法的声明和使用
方法：描述类应该具有的功能,例如
```java
Math类：sqrt() \ random() \.....
Scanner类：nextXxx()......
Arrays类：sort()\binarySearch()\toString()\equals()\.......
```
方法的分类：按照是否有形参及返回值
| 无返回值 | 有返回值 | |
|---|---|---|
| 无形参 | void 方法名(){} | 返回值的类型 方法名(){} |
| 有形参 | void 方法名(形参列表){} | 返回值的类型 方法名(形参列表){} |
-
举例：
public void eat(){ } public void sleep(int hour){ } public String getName(){ } public String getNation(String nation){ } -
方法的声明：权限修饰符 返回值类型 方法名(形参列表){}
-
说明：
3.1关于权限修饰符：
java规定的4种权限修饰符：private,public,缺省，protected (封装性再讲)
3.2返回值类型：有返回值vs没有返回值
- 2.1如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量：“return 数据”
如果方法没有返回值，则声明方法时，使用void来表示。通常没有返回值的方法中，就不使用return，但是，如果使用的话，只能"return;"表示结束此方法的意思。
- 2.2 我们定义方法该不该有返回值
①看题目要求
②凭经验，具体问题具体分析
3.3方法名：属于标识符，遵循标识符的规则和规范。“见名知意”
3.4 形参列表：方法可以声明0个，1个或者多个形参
-
4.1格式：数据类型1 形参1(变量)，数据类型2 形参2，…
-
4.2 我们定义方法时，该不该定义形参？
①看题目要求
②凭经验，具体问题具体分析
-
方法体：方法功能的体现
-
return 关键字的使用：
-
1使用范围：使用在方法体中
-
2作用：①结束方法
-
②针对有返回值类型的方法，使用“return 数据”返回所要的数据
注意点：return关键字后面不可以声明执行语句。
- 方法的创建中，可以调用当前类的属性或方法
特殊的：方法A中又调用了方法A,这叫递归方法
注意：方法中不可以定义方法。
-
方法的重载(overload)
-
1定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可
“两同一不同”：同一个类，相同方法名
参数列表不同：参数个数不同，参数类型不同
-
2判断是否是重载：
跟方法的权限修饰符，返回值类型，形参变量名，方法体都没有关系
-
3在通过对象调用方法时，如何确定某一个指定的方法
方法名和参数列表来确定
public class OverLoadTest{ public static void main(String[] args){ } //如下的4个方法构成了重载 public void getSum(int i,int j){ System.out.println("1"); } public void getSum(double i,double j){ System.out.println("2"); } public void getSum(String s,int i){ System.out.println("3"); } public void getSum(int i,String s){ System.out.println("4"); } //下面这个与上面的方法不构成重载 private int getSum(int m,int n){ System.out.println("5"); } }
-
-
可变个数形参的方法
1.jdk 5.0新增的内容
2.具体使用：
-
1 可变个数形参的格式：数据类型 … 变量名
-
2 当调用可变个数形参的方法时，传入的参数的个数可以是：0个，1个，2个。。。。。
-
3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
-
4可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载，换句话说二者不能共存。
-
5 可变个数形参在方法的形参中，必须声明在末尾
-
6 可变个数形参在方法的形参中，最多只能声明一个可变形参。
public class MethodArgsTest{ public static void main(String[] args){ MethodArgsTest test=new MethodArgsTest(); test.show(12); test.show("hellow"); test.show("hellow","world"); } public void show(int i){ } public void show(String s){ System.out.println("show(String)"); } public void show(String ... str){ System.out.println("show(String ... str)"); for(int i=0;i<str.length;i++){ System.out.println(str[i]); } } } -
-
关于变量的赋值：
如果变量是基本数据类型，此时赋值的是变量所保存的数据值
如果是变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
-
方法的形参的传递机制：值传递
1.形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据
2.值传递机制：
如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值
如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
public class ValueTransferTest2 { public static void main(String[] args) { Data data = new Data(); data.m=10; data.n=20; System.out.println("m =" +data.m+",n="+data.n); ValueTransferTest2 test=new ValueTransferTest2(); test.swap(data); System.out.println("m =" +data.m+",n="+data.n); } public void swap(Data data){ int temp=data.m; data.m=data.n; data.n=temp; } } class Data{ int m; int n; }
-
递归方法的使用
1.递归方法：一个方法体内调用他自身。
2.方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似死循环
public class RecursionTest2 { public static void main(String[] args) { int sum=0; //计算1~100之间所有自然数的和 for(int i=0;i<=100;i++){ sum+=i; } System.out.println(sum); RecursionTest2 test=new RecursionTest2(); System.out.println(test.getSum(100)); System.out.println(test.getSum1(4)); // int value=test.f(10); System.out.println(test.f(10)); } //求1~n之间的自然数的和 public int getSum(int n){ if(n==1){ return 1; }else{ return n+getSum(n-1); } } //求1~n之间所有自然数的成绩 public int getSum1(int n){ if(n==1){ return 1; }else{ return n*getSum1(n-1); } } public int f(int n){ if(n==0){ return 1; }else if(n==1){ return 4; }else{ return 2*f(n-1)+f(n-2); } } }
构造器
————类的结构之三
构造器(constructor)的使用
一，构造器的作用
- 创建类的对象:new +构造器
Person p=new Person();
- 初始化对象的信息
二，说明
-
如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器
-
定义构造器的格式：权限修饰符 类名(形参列表){}
-
一个类中定义的多个构造器，彼此构成重载
-
一旦我们显示的定义了类的构造器之后，系统就不再提供默认的空参构造器
-
一个类中，至少会有一个构造器
总结：属性赋值的先后顺序
①默认初始化
②显示初始化
③构造器初始化
④通过"对象.方法"或"对象.属性"的方式。赋值
类和对象的创建和使用
-
创建类，设计类的成员
-
创建类的对象
-
通过“对象.属性”或“对象.方法”调用对象的结构
如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static）
类的创建
class Person{
//属性
String name;
int age=1;
bollean isMale;
//方法
public void eat(){
System.out.println("人可以吃饭");
}
public void sleep(){
System.out.println("人可以睡觉");
}
public void talk(String language){
System.out.println("人可以说话，使用的是："+language);
}
}
对象的创建和调用
如何使用类？
类的实例化，即创建类的对象
创建类的对象=类的实例化=实例化类
public class PersonTest{
public static void main(String[] args){
//创建Person类的对象
Person p1 = new Person();
//调用对象的结构：属性，方法
//调用属性:“对象.属性"
p1.name="Tom";
p1.isMale=true;
System.out.println(p1.name);
//调用方法："对象.方法"
p1.eat();
p1.sleep();
p1.talk("chinese")
}
}
匿名对象
-
理解：我们创建的对象，没有显示的赋给一个变量名，即为匿名对象
-
特征：匿名对象只能调用一次
例如：new Phone().price=1999;
new Phone().showPrice();
####内存解析
堆(Heap)：此内存区域存放对象实例
栈(Stack):存放局部变量
代码块
类的成员之四：代码块（或初始化块）
-
代码块的作用：用来初始化类，对象
-
代码块如果有修饰的话，只能使用static
-
分类：静态代码块 Vs 非静态代码块
-
静态代码块
4.1 内部可以有输出语句
4.2 随着类的加载而执行，而且只执行一次
4.3 作用：初始化类的信息
4.4 如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
4.5静态代码块的执行要优先于非静态代码块的执行
4.6静态代码块内只能调用静态的属性，静态的方法，不能调用非静态的结构
-
非静态代码块
5.1 内部可以有输出语句
5.2 随着对象的创建而执行
5.3 每创建一个对象，就执行一次非静态代码块
5.4 作用：可以在创建对象时，对对象的属性等进行初始化
5.5 如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
5.6 非静态代码块内可以调用静态的属性，静态的方法，或非静态的属性，非静态的方法
-
代码块，方法，构造器的执行顺序
由父类到子类，静态代码块先执行，然后回到从父类到子类，先执行普通初始化代码块，再执行构造器
例1：
class Root{ static{ System.out.println("Root的静态初始化块"); } { System.out.println("Root的普通初始化块"); } public Root(){ System.out.println("Root的无参数的构造器"); } } class Mid extends Root{ static{ System.out.println("Mid的静态初始化块"); } { System.out.println("Mid的普通初始化块"); } public Mid(){ System.out.println("Mid的无参数的构造器"); } public Mid(String msg){ //通过this调用同一类中重载的构造器 this(); System.out.println("Mid的带参数构造器，其参数值：" + msg); } } class Leaf extends Mid{ static{ System.out.println("Leaf的静态初始化块"); } { System.out.println
最低0.47元/天 解锁文章
867
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
