Java中类
2021-01-15 03:12
标签：程序设计 相同 scan 声明 keyword turn span 举例 汉诺塔 类中主要包括五种结构，下面进行对这五种结构进行详细的介绍。 ? 举例对比：把大象装进冰箱。 类：对一类事物的描述，是抽象的、概念上的定义 对象：是实际存在的该类事物的每个个体，因而也称为实例(instance) 面向对象程序设计的重点是类的设计 设计类，就是设计类的成员。 二者的关系：对象，是由类new出来的，派生出来的。 创建类，设计类的成员 创建类的对象 通过“对象.属性”或“对象.方法”调用对象的结构 补充：几个概念的使用说明 典型代码： 内存解析： 编译完源程序以后，生成一个或多个字节码文件。 我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。 《JVM规范》 虚拟机栈，即为平时提到的栈结构。我们将局部变量存储在栈结构中 堆，我们将new出来的结构（比如：数组、对象）加载在对空间中。 补充：对象的属性（非static的）加载在堆空间中。 方法区：类的加载信息、常量池、静态域 我们创建的对象，没显式的赋给一个变量名。即为匿名对象 特点：匿名对象只能调用一次。 举例： 应用场景： 对比：属性 vs 局部变量 1.1 定义变量的格式：数据类型 变量名 = 变量值 1.2 先声明，后使用 1.3 变量都其对应的作用域 引用数据类型（类、数组、接口：null） 局部变量：没默认初始化值。 补充：回顾变量的分类： 方式一：按照数据类型： 方式二：按照在类中声明的位置： 方法：描述类应该具的功能。 比如：Math类：sqrt()\random() ... 权限修饰符 返回值类型 方法名(形参列表){ 方法体 } 注意：static、final、abstract 等关键字修饰的方法，后面再聊。 Java规定的4种权限修饰符：private、public、缺省、protected -->封装性 3.2.1 如果方法返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用 return关键字来返回指定类型的变量或常量：“return 数据”。 如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要 使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。 3.2.2 我们定义方法该不该返回值？ ① 题目要求 ② 凭经验：具体问题具体分析 3.4.1 格式：数据类型1 形参1,数据类型2 形参2,... 3.4.2 我们定义方法时，该不该定义形参？ ① 题目要求 ② 凭经验：具体问题具体分析 1.使用范围：使用在方法体中 2.作用： ? ① 结束方法 ? ② 针对于返回值类型的方法，使用"return 数据"方法返回所要的数据。 3.注意点：return关键字后面不可以声明执行语句。 定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。 总结："两同一不同": 不构成重载的实例： 严格按照定义判断：两同一不同。 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！ ①方法名 ---> ②参数列表 JDK 5.0新增的内容 JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量 public static void test(int a， String[ ]books)； JDK 5.0：采用可变个数形参来定义方法，传入多个同一类型变量 public static void test(int a， String ... books); 具体使用： 2.1 可变个数形参的格式：数据类型 ... 变量名 2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。 2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载 2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。 2.5 可变个数形参在方法的形参中，必须声明在末尾 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。 规则： 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。 形参：方法定义时，声明的小括号内的参数 实参：方法调用时，实际传递给形参的数据 规则： 推广： 内存解析画法要点： 1.内存结构：栈（局部变量）、堆（new出来的结构：对象（非static成员变量）、数组 2.变量：成员变量 vs 局部变量（方法内、方法形参、构造器内、构造器形参、代码块内） 举例一 举例二 递归方法：一个方法体内调用它自身。 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。 未完待续。。。 Java中类 标签：程序设计 相同 scan 声明 keyword turn span 举例 汉诺塔 原文地址：https://www.cnblogs.com/Dusin/p/12938877.html类与对象
1. 面向对象与面向过程
2. 类与对象的关系
3. 面向对象思想实现的规则
4. 对象的创建与对象的内存解析
Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。
/*说明：
*如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
*意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。
*/
5. JVM内存结构
6. 匿名对象:
new Phone().sendEmail();
new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice();//0.0
PhoneMall mall = new PhoneMall();
//匿名对象的使用
mall.show(new Phone());
其中，
class PhoneMall{
public void show(Phone phone){
phone.sendEmail();
phone.playGame();
}
}
7. "万事万物皆对象"
类的结构之一：属性
1. 相同点：
2. 不同点：
2.1 在类中声明的位置的不同
属性：直接定义在类的一对{}内
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量。
2.2 关于权限修饰符的不同
属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected --->封装性
目前，声明属性时，使用缺省就可以。
局部变量：不可以使用权限修饰符。
2.3 默认初始化值的情况：
属性：类的属性，根据其类型，都默认初始化值。
整型（byte、short、int、long：0）
浮点型（float、double：0.0）
字符型（char：0 （或‘\u0000‘））
布尔型（boolean：false）
意味着，我们在调用局部变量之前，一定要显式赋值。
特别地：形参在调用时，我们赋值即可。
2.4 在内存中加载的位置：
属性：加载到堆空间中 （非static）
局部变量：加载到栈空间
类的结构之二：方法
Scanner类：nextXxx() ...
Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...
1.举例：
public void eat(){}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){}
2.方法的声明：
3.说明：
3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
3.2 返回值类型： 返回值 vs 没返回值
3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
3.4 形参列表： 方法可以声明0个，1个，或多个形参。
3.5 方法体：方法功能的体现。
4.方法的使用中，可以调用当前类的属性或方法
特殊的：方法A中又调用了方法A:递归方法。
方法中，不可以定义方法。
return关键字
方法的重载
1.重载的概念
2.构成重载的实例：
举例一：Arrays类中重载的sort() / binarySearch()；PrintStream中的println()
举例二：
//如下的4个方法构成了重载
public void getSum(int i,int j){
System.out.println("1");
}
public void getSum(double d1,double d2){
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");
}
//如下的3个方法不能与上述4个方法构成重载
public int getSum(int i,int j){
return 0;
}
public void getSum(int m,int n){
}
private void getSum(int i,int j){
}
3.如何判断是否构成方法重载？
4.如何确定类中某一个方法的调用：
可变个数形参方法
1.使用说明
2.举例说明
public void show(int i){
}
public void show(String s){
System.out.println("show(String)");
}
public void show(String ... strs){
System.out.println("show(String ... strs)");
for(int i = 0;i ){
System.out.println(strs[i]);
}
}
//不能与上一个方法同时存在
// public void show(String[] strs){
//
// }
调用时：可变形参与数组类似
test.show("hello");
test.show("hello","world");
test.show();
test.show(new String[]{"AA","BB","CC"});
Java的值传递机制
1.针对方法内变量的赋值举例：
System.out.println("***********基本数据类型：****************");
int m = 10;
int n = m;
System.out.println("m = " + m + ", n = " + n);
n = 20;
System.out.println("m = " + m + ", n = " + n);
System.out.println("***********引用数据类型：****************");
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
2.针对于方法的参数概念
3. Java中参数传递机制：值传递机制
4.内存解析：
递归方法
1.定义：
2.如何理解递归方法？
3.举例：
// 例1：计算1-n之间所自然数的和
public int getSum(int n) {// 3
if (n == 1) {
return 1;
} else {
return n + getSum(n - 1);
}
}
// 例2：计算1-n之间所自然数的乘积:n!
public int getSum1(int n) {
if (n == 1) {
return 1;
} else {
return n * getSum1(n - 1);
}
}
//例3：已知一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
//其中n是大于0的整数，求f(10)的值。
public int f(int n){
if(n == 0){
return 1;
}else if(n == 1){
return 4;
}else{
// return f(n + 2) - 2 * f(n + 1);
return 2*f(n - 1) + f(n - 2);
}
}
//例4：斐波那契数列
//例5：汉诺塔问题
//例6：快排