面向对象的三条主线
(1)类及类的成员:属性、方法、构造器、代码块、内部类
(2)面向对象的三大特征:封装、继承、多态
(3)其他关键字:this 、super、、、、、、
面向对象的编程思想
(类、对象;卖你想对象的三大特征;。。。)
理解万事万物皆对象
1.在Java中,我们都将功能呢给、结构等封装到类中,通过类的实例化,来具体调用的功能结构
2.涉及到Java语言与前端Html、后端的数据库交互时,前后端的结构在Java层面交互时,都体现为类、对象。
内存解析的说明
1.引用类型的变量,只可能存储两类值:null 或地址值(含变量的类型)
练习题:
定义类students;包含三个属性:学号number(int),年级state(int),成绩score(int)
创建20个学生对象,学号为1到20,年级和成绩都由随机数确定。
问题一:打印出三年级(state值为3)的学生信息
问题二:使用冒泡排序按学生的成绩进行排序,并输出学生信息
提示:
(1)生成随机数:
生成区间[m,n]的一个随机数 (Math.radom()*(m-n+1)+m),返回值类型double;
(2)四舍五入取整: Math.roud (double d),返回值类型long。
public class StudentTest1 {
public static void main(String[] args) {
//声明Student类型的数组
Student1[] stus = new Student1[20];
for(int i = 0;i < stus.length;i++){
//给数组元素赋值
stus[i] = new Student1();
//给Student对象的属性赋值
stus[i].number = (i + 1);
//年级:[1,6]
stus[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
//成绩:[0,100]
stus[i].score = (int)(Math.random() * (100 - 0 + 1));
}
StudentTest1 test = new StudentTest1();
//遍历学生数组
test.print(stus);
System.out.println("********************");
//问题一:打印出3年级(state值为3)的学生信息。
test.searchState(stus, 3);
System.out.println("********************");
//问题二:使用冒泡排序按学生成绩排序,并遍历所有学生信息
test.sort(stus);
//遍历学生数组
test.print(stus);
}
public void print(Student1[] stus){
for(int i = 0;i <stus.length;i++){
System.out.println(stus[i].info());
}
}
public void searchState(Student1[] stus,int state){
for(int i = 0;i <stus.length;i++){
if(stus[i].state == state){
System.out.println(stus[i].info());
}
}
}
public void sort(Student1[] stus){
for(int i = 0;i < stus.length - 1;i++){
for(int j = 0;j < stus.length - 1 - i;j++){
if(stus[j].score > stus[j + 1].score){
//如果需要换序,交换的是数组的元素:Student对象!!!
Student1 temp = stus[j];
stus[j] = stus[j + 1];
stus[j + 1] = temp;
}
}
}
}
}
class Student1{
int number;//学号
int state;//年级
int score;//成绩
//显示学生信息的方法
public String info(){
return "学号:" + number + ",年级:" + state + ",成绩:" + score;
}
}
匿名对象的使用
1.理解:创建的对象,没有显示的赋给一个变量名
2.特征:匿名对象只能调用一次
重载的概念:
在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数或者参数 类型不同即可。
"两同一不同":同一个类、相同方法名
参数列表不同:参数个数不同,参数类型不同
重载的特点:
判断是否是重载:
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系,只看参数列表,且参数列表必须不同。(参数个数或参数类 型)。调用时,根据方法参数列表的不同来区别。
重载示例:
//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
返回两个小数的和
double add(double x,double y){return x+y;}
可变个数形参的方法
具体使用:
1 可变个数形参的格式:数据类型 ... 变量名
2 当调用可变个数形参的方法时,传入的参数个数可以是:0个,1个,2个,。。。
3 可变个数形参的方法与本类中方法名相同,形参不同的方法之间构成重载
4 可变个数形参的方法与本类中方法名相同,形参类型也相同的数组之间不构成重载。换句话说,二者不能共存。
5 可变个数形参在方法的形参中,必须声明在末尾
错误的使用方法
public void show(String ...strs,int i)
6 可变个数形参在方法的形参中,最多只能声明一个可变形参。
方法参数的值传递机制
关于变量的赋值:
如果变量是基本数据类型,此时赋值的是变量所保存的数据值。
如果变量是引用数据类型,此时赋值的是变量所保存的数据的地址值。
形参:方法定义时,声明的小括号内的参数
实参:方法调用时,实际传递给形参的数据
System.exit(0);//终止当前程
递归方法的使用(了解)
1.递归方法:一个方法体内调用它自身。
2. 方法递归包含了一种隐式的循环,它会重复执行某段代码,但这种重复执行无须循环控制。
递归一定要向已知方向递归,否则这种递归就变成了无穷递归,类似于死循环。
public class RecursionTest {
public static void main(String[] args) {
// 例1:计算1-100之间所有自然数的和
// 方式一:
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
System.out.println(sum);
// 方式二:
RecursionTest test = new RecursionTest();
int sum1 = test.getSum(100);
System.out.println(sum1);
System.out.println("*****************");
int value = test.f(10);
System.out.println(value);
}
// 例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);
}
}