Day09
面向对象:多是难点,主要时代码会敲
1.Java类及类的成员:属性、方法、构造器；代码块、内部类
2.面向对象的三大特征:封装类、继承性、多态性(抽象类)
3.其他关键字:this、super、static、final、abstract、interface、package、import
"大处着眼,大处着手"
面向过程与面向对象
二、"人把大象装进冰箱"
1.面向过程,强调的是功能行为,以函数未最小单位,考虑怎么做。
1.把冰箱门打开
2.抬起大象,塞进冰箱
3.把冰箱门关闭
2.面向对象:强调具备了功能的对象,以类/对象最小单位,考虑谁来做。
如何将大象装进冰箱
人{
打开（冰箱){
冰箱,开开(){
}
抬起(大象){
大象,进入(冰箱);
}
关闭(冰箱){
冰箱,闭合();
}
}
冰箱{
开开(){}
闭合(){}
}
大象 {
进入冰箱{
}
}
面向对象的思想概述
Java的基本元素类和对象
类:是对一类事物的描述,是抽象的、概念上的定义
对象:是实际存在的该类事物的每个个体,因而也称为实例(instance)
面向对象程序设计的重点是类的设计
设计类,就是设计类的成员。
!!!属性:对应类中的成员变量!!!
!!!行为:对应类中的成员方法!!!
Java类的实例化:创建对象
二、类和对象的使用(面向对象思想落地的实现)
- 1.创建类,设计类的成员
- 2.创建类的对象
- 3.通过"对象.属性"或"对象.方法"调用对象的结构
小故事:公孙龙白马非马
反射
堆区:对象实体
方法:字符串、常量池、静态变量
类中属性的使用
属性(成员变量) vs 局部变量
属性 (成员变量) vs 局部变量
* 1.相同点:
* 1.1定义变量的格式:数据类型 变量名 = 变量值
* 1.2先声明,后使用
* 1.3变量都有其对应的作用域
* 2.不同点:
* 2.1在类中声明的位置的不同
* 属性:直接定义在类的一对{}内
* 局部变量:声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
*
* 2.2关于权限修饰符的不同
* 属性:可以在声明属性时,指明其权限,使用权限修饰符。
* 常用的权限修饰符:private、public、缺省、protected -->封装性
* 目前:大家声明属性时,都使用缺省就可以了
* 局部变量:不可以使用权限修饰符。
*
* 2.3 默认初始化值的情况。
* 属性:类的属性、根据其类型,都有默认初始化值
/*
* 一、设计类: 其实就是设计类的成员
*
* 属性 = 成员变量 = field = 域、字段
* 方法= 成员方法 = 函数 = method
*
* 创建类的对象 = 类的实例化 = 实例化类
*
* 二、类和对象的使用(面向对象思想落地的实现)
* 1.创建类,设计类的成员
* 2.创建类的对象
* 3.通过"对象.属性"或"对象.方法"调用对象的结构
*
* 三、如果创建了一个类的多个对象,则每个对象都独立的拥有一套类的属性。(非static)
* 意味着:如果我们修改一个对象的属性a,则不影响另外一个对象的属性a\
*
* 四、内存解析
*
* */
//测试类
public class PersonTest {
public static void main(String[] args) {
//创建Person类的对象
Person p1 = new Person();
//Scannner scanner = new Scanner(System.in);
//调用对象的结构:属性、方法
//调用属性:"对象.属性"
p1.name = "Tom";
p1.isMale = true;
System.out.println(p1.name);
//调用方法:"对象.方法"
p1.eat();
p1.sleep();
p1.talk("Chinese");
//**************************
Person p2 = new Person();
System.out.println(p2.name);//Tom?null?报错？
System.out.println(p2.isMale);
//**************************
//将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中的同一个对象实体。有意思!!!
Person p3 = p1;
System.out.println(p3.name);
p3.age = 10;
System.out.println(p1.age);
}
}
//
class Person{
//属性
String name;
int age = 1;
boolean isMale;
//方法
public void eat() {
System.out.println("人可以吃饭");
}
public void sleep() {
System.out.println("人可以睡觉");
}
public void talk(String language) {
System.out.println("人可以说话,使用的是: " + language);
}
}
//属性和方法的使用
/*
* 类中属性的使用
*
* 属性 (成员变量) vs 局部变量
* 1.相同点:
* 1.1定义变量的格式:数据类型 变量名 = 变量值
* 1.2先声明,后使用
* 1.3变量都有其对应的作用域
*
*
* 2.不同点:
* 2.1在类中声明的位置的不同
* 属性:直接定义在类的一对{}内
* 局部变量:声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
*
* 2.2关于权限修饰符的不同
* 属性:可以在声明属性时,指明其权限,使用权限修饰符。
* 常用的权限修饰符:private、public、缺省、protected -->封装性
* 目前:大家声明属性时,都使用缺省就可以了
* 局部变量:不可以使用权限修饰符。
*
* 2.3 默认初始化值的情况。
* 属性:类的属性、根据其类型,都有默认初始化值
* 整型(byte、short、int、long),0
* 浮点型(float、double),0.0
* 字符型(char),0(或'\u0000')
* 布尔型(boolean),flase
*
* 引用数据类型(类、数组、接口),null
*
*
* 局部变量:没有默认初始化值。
* 意味着,在调用之前,一定要显式赋值。
* 特别地,形参在调用时,我们赋值即可。
*
* 2.4在内存中加载的位置。
* 属性:加载到堆空间中 (非static)
* 局部变量:加载到栈空间
*
*
* */
public class UserTest {
public static void main(String[] args) {
User u1 = new User();
System.out.println(u1.name);
System.out.println(u1.age);
System.out.println(u1.isMale);
u1.talk("韩语");
u1.eat();
}
}
class User{
//属性 (或成员变量)
String name;
int age;
boolean isMale;
public void talk(String language) {//language:形参
System.out.println("我们使用" + language + "进行交流");
}
public void eat() {
String food = "烙饼";//局部变量
System.out.println("北方人喜欢吃:" + food);
}
}
// 类中方法地声明和使用
/*
* 类中方法地声明和使用
*
* 方法:描述类应该具有地功能。
* 比如:Math类:sqrt()\random()\...
* 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.方法的声明:权限修饰符 返回值类型 方法名(形参列表){
* 方法体
* }
* static、final、abstract 来修饰的方法,后买再讲。
*
* 3. 说明:
* 3.1关于权限修饰符:默认方法的权限修饰符先使用public
* Java规定的4中权限修饰符:private、public、缺省、protected -->封装性再细聊
*
* 3.2返回值类型:有返回值 vs 没有返回值
* 3.2.1如果方法有返回值,则必须在方法声明时,指定返回值的类型,同时方法中需要使用
* return关键字来返回指定类型的变量或常量。
* 如果方法没有返回值,则方法声明时,使用void来表示
* 使用return.但是,如果使用的话,只能return;"表示"
* 3.2.2我们定义方法该不该有返回值?
* ① 题目要求
* 3.3 方法名:属于标识符,遵循标识符的规则和规范,"见名知意"
*
* 3.4 形参列表:方法可以声明0个,1个,或多个形参。
* 3.4.1 格式:数据类型1 形参1,数据类型2 形参2,...
*
* 3.4.2 我们定义方法时,该不该定义形参?
* ①题目要求
* ②凭经验:具体问题具体分析
*
* 4.return关键字使用:
* 1.使用范围:使用在方法体中
* 2.作用:① 结束方法
* ② 针对于有返回值类型的方法,使用"return"数据"方法返回所要的数据"
* 3.注意点:return关键字后面不可以声明执行语句。
* 5. 方法的使用中,可以调用当前类的属性或方法
*
*
* */
public class CustomerTest {
public static void main(String[] args) {
Customer cust1 = new Customer();
cust1.eat();
//测试形参是否需要设置的问题
// cust1.sort(arr);
// int[] arr = new int[] {3,4,5,2,5,63,2,5};
}
}
//客户类
class Customer{
//属性
String name;
int age;
boolean isMale;
//方法
public void eat() {
System.out.println("客户吃饭");
return;
}
public void sleep(int hour) {
System.out.println("休息了" + hour + "个小时");
}
public String getName() {
if(age > 18) {
return name;
}else {
return "Tom";
}
}
public String getNation(String nation) {
String info = "我的国籍是:" + nation;
return info;
}
// public void sort(int[] arr) {
//
// }
// public void sort() {
// int[] arr = new int[] {3,4,5,2,5,63,2,5};
// //。。。。
// }
}
//练习题打印圆的面积
//涉及方法
public class Person {
String name;
int age;
int sex;
/**
* sex:1表明是男性
* sex:0表明是女性
*/
public void study() {
System.out.println("studying");
}
public void showAge() {
System.out.println("age" + age);
}
public int addAge(int i) {
age += i;
return age;
}
}
//测试类
/*
* 要求：(1)创建Person类的对象，设置该对象的name、
age和sex属性，调用study方法，输出字符串
“studying”，调用showAge()方法显示age值，调用
addAge()方法给对象的age属性值增加2岁。
(2)创建第二个对象，执行上述操作，体会同一个类的
不同对象之间的关系。
*
* */
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "Tom";
p1.age = 18;
p1.sex = 1;
p1.study();
p1.showAge();
int newAge = p1.addAge(2);
System.out.println(p1.name + "的新年龄为:" + newAge);
System.out.println(p1.age);//20
//********************************
Person p2 = new Person();
p2.showAge();//0
p2.addAge(10);
p2.showAge();//10
}
}
//练习二
/*
* 2.利用面向对象的编程方法,设计类Circle计算圆的面积。
*/
//测试类
public class CircleTest {
public static void main(String[] args) {
Circle c1 = new Circle();
c1.radius = 2.1;
//对应方式一:
// double area = c1.findArea();
// System.out.println(area);
//对应方式对应方式二:
//c1.findArea();
//错误的调用
// double area = c1.findArea(3.4);
// System.out.println(area);
}
}
//圆
class Circle{
//属性
double radius;
//求圆的面积
//方式一:
// public double findArea(double r) {
// double area = Math.PI * radius * radius;
// return area;
// }
//方式二:
// public void findArea() {
// double area = Math.PI * redius * redius;
// System.out.println("面积为:" + area);
// }
//错误情况:
// public double findArea(double r) {
// double area = 3.14 * r * r;
// return area;
// }
}
此代码考验的是圆的测算和方法使用
//练习三
/*
* 3.1 编写程序,声明一个method方法,在方法中打印一个10*8的*型
* */
public class Exer3Test {
public static void main(String[] args) {
Exer3Test test = new Exer3Test();
//3.1测试
// test.method();
//3.2测试
// int area = test.method();
// System.out.println("面积为: " + area);
//方式二:
// System.out.println(test.method());
//3.3测试
int area = test.method(12, 10);
System.out.println("面积为: " + area);
}
// public void method() {
// for(int i = 0;i < 10;i++) {
// for(int j = 0;j < 8;j++) {
// System.out.print("* ");
// }
// System.out.println();
// }
// }
//3.2
// public int method() {
// for(int i = 0;i < 10;i++) {
// for(int j = 0;j < 8;j++) {
// System.out.print("* ");
// }
// System.out.println();
// }
//
// return 10 * 8;
//}
//3.3
public int method(int m,int n) {
for(int i = 0;i < m;i++) {
for(int j = 0;j < n;j++) {
System.out.println("* ");
}
System.out.println();
}
return m * n;
}
}
此代码考验的是方法的使用熟练
//练习三
/*
* 4. 对象数组题目:
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩
score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示：
1) 生成随机数：Math.random()，返回值类型double;
2) 四舍五入取整：Math.round(double d)，返回值类型long。
5.声明一个日期类型MyDate：有属性：年year,月month，日day。创建2个日期
对象，分别赋值为：你的出生日期，你对象的出生日期，并显示信息。
*
* */
public class StudentTest {
public static void main(String[] args) {
// Student s1 = new Student();
// Student s1 = new Student();
// Student s1 = new Student();
// Student s1 = new Student();
// Student s1 = new Student();
// Student s1 = new Student();
//声明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)的学生信息。
for(int i = 0;i <stus.length;i++) {
if(stus[i].state == 3) {
System.out.println(stus[i].info());
}
}
System.out.println("************************");
//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
//遍历学生数组
}
/**
* @Description 遍历Student1[]数组
* @author wumengchaojunstart
* @data 2025年9月29日14:36:27
* @param stus
*/
public void print(Student1[] stus) {
for(int i = 0;i <stus.length;i++) {
System.out.println(stus[i].info());
}
}
/**
*
* @Description 查找Stduent数组中指定年级的学生信息
* @author wumengchaojunstart
* @data 2025年9月29日14:31:35
* @param stus 要查找的数组
* @param state 要找的年级
*/
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());
}
}
}
/**
*
* @Description 给Student1数组排序
* @author wumengchaojunstart
* @data 2025年9月29日14:35:25
* @param stus
*/
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.举例:
- 1.补全代码的声明：alt + /
- 2.快速修复: ctrl + 1
- 3.批量导包：ctrl + shift + o
- 4.使用单行注释：ctrl + /
- 5.使用多行注释： ctrl + shift + /
- 6.取消多行注释：ctrl + shift + \
- 7.复制指定行的代码：ctrl + alt + down 或 ctrl + alt + up
- 8.删除指定行的代码：ctrl + d
- 9.上下移动代码：alt + up 或 alt + down
- 10.切换到下一行代码空位：shift + enter
- 11.切换到上一行代码空位：ctrl + shift + enter
- 12.如何查看源码：ctrl + 选中指定的结构 或 ctrl + shift + t
- 13.退回到前一个编辑的页面：alt + left
- 14.进入到下一个编辑的页面(针对于上面那条来说的)：alt + right
- 15.光标选中指定的类，查看继承树结构：ctrl + t
- 16.复制代码： ctrl + c
- 17.撤销： ctrl + z
- 18.反撤销： ctrl + y
- 19.剪切：ctrl + x
- 20.粘贴：ctrl + v
- 21.保存： ctrl + s
- 22.全选：ctrl + a
- 23.格式化代码： ctrl + shift + f
- 24.选中数行，整体往后移动：tab
- 25.选中数行，整体往前移动：shift + tab
- 26.在当前类中，显示类结构，并支持搜索指定的方法、属性等：ctrl + o
- 27.批量修改指定的变量名、方法名、类名等：alt + shift + r
- 28.选中的结构的大小写的切换：变成大写： ctrl + shift + x
- 29.选中的结构的大小写的切换：变成小写：ctrl + shift + y
- 30.调出生成getter/setter/构造器等结构： alt + shift + s
- 31.显示当前选择资源(工程 or 文件)的属性：alt + enter
- 32.快速查找：参照选中的Word快速定位到下一个 ：ctrl + k
- 33.关闭当前窗口：ctrl + w
- 34.关闭所有的窗口：ctrl + shift + w
- 35.查看指定的结构使用过的地方：ctrl + alt + g
- 36.查找与替换：ctrl + f
- 37.最大化当前的View：ctrl + m
- 38.直接定位到当前行的首位：home
- 39.直接定位到当前行的末位：end
-
整型(byte、short、int、long),0 -
浮点型(float、double),0.0 -
字符型(char),0(或'\u0000') -
布尔型(boolean),flase -
引用数据类型(类、数组、接口),null
类中地方法地使用:
！！！搞清楚返回值:是解决问题的根本！！！
返回值类型分为:有返回值和没有返回值和有形参和没有形参
Math类：sqrt()\random() ...
Scanner类:nextXxx()...
Arrays类:sort() \ binarySearch()
属性-->方法-->形参-->方法体
/*
* 一、设计类: 其实就是设计类的成员
*
* 属性 = 成员变量 = field = 域、字段
* 方法= 成员方法 = 函数 = method
*
* 创建类的对象 = 类的实例化 = 实例化类
*
* 二、类和对象的使用(面向对象思想落地的实现)
* 1.创建类,设计类的成员
* 2.创建类的对象
* 3.通过"对象.属性"或"对象.方法"调用对象的结构
*
* 三、如果创建了一个类的多个对象,则每个对象都独立的拥有一套类的属性。(非static)
* 意味着:如果我们修改一个对象的属性a,则不影响另外一个对象的属性a\
*
* 四、内存解析
*
* */
//测试类
public class PersonTest {
public static void main(String[] args) {
//创建Person类的对象
Person p1 = new Person();
//Scannner scanner = new Scanner(System.in);
//调用对象的结构:属性、方法
//调用属性:"对象.属性"
p1.name = "Tom";
p1.isMale = true;
System.out.println(p1.name);
//调用方法:"对象.方法"
p1.eat();
p1.sleep();
p1.talk("Chinese");
//**************************
Person p2 = new Person();
System.out.println(p2.name);//Tom?null?报错？
System.out.println(p2.isMale);
//**************************
//将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中的同一个对象实体。有意思!!!
Person p3 = p1;
System.out.println(p3.name);
p3.age = 10;
System.out.println(p1.age);
}
}
//
class Person{
//属性
String name;
int age = 1;
boolean isMale;
//方法
public void eat() {
System.out.println("人可以吃饭");
}
public void sleep() {
System.out.println("人可以睡觉");
}
public void talk(String language) {
System.out.println("人可以说话,使用的是: " + language);
}
}
//属性测试方法
/*
* 一、设计类: 其实就是设计类的成员
*
* 属性 = 成员变量 = field = 域、字段
* 方法= 成员方法 = 函数 = method
*
* 创建类的对象 = 类的实例化 = 实例化类
*
* 二、类和对象的使用(面向对象思想落地的实现)
* 1.创建类,设计类的成员
* 2.创建类的对象
* 3.通过"对象.属性"或"对象.方法"调用对象的结构
*
* 三、如果创建了一个类的多个对象,则每个对象都独立的拥有一套类的属性。(非static)
* 意味着:如果我们修改一个对象的属性a,则不影响另外一个对象的属性a\
*
* 四、内存解析
*
* */
//测试类
public class PersonTest {
public static void main(String[] args) {
//创建Person类的对象
Person p1 = new Person();
//Scannner scanner = new Scanner(System.in);
//调用对象的结构:属性、方法
//调用属性:"对象.属性"
p1.name = "Tom";
p1.isMale = true;
System.out.println(p1.name);
//调用方法:"对象.方法"
p1.eat();
p1.sleep();
p1.talk("Chinese");
//**************************
Person p2 = new Person();
System.out.println(p2.name);//Tom?null?报错？
System.out.println(p2.isMale);
//**************************
//将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中的同一个对象实体。有意思!!!
Person p3 = p1;
System.out.println(p3.name);
p3.age = 10;
System.out.println(p1.age);
}
}
//
class Person{
//属性
String name;
int age = 1;
boolean isMale;
//方法
public void eat() {
System.out.println("人可以吃饭");
}
public void sleep() {
System.out.println("人可以睡觉");
}
public void talk(String language) {
System.out.println("人可以说话,使用的是: " + language);
}
}
//有参和无参有返回值和无返回值测试
/*
* 类中方法地声明和使用
*
* 方法:描述类应该具有地功能。
* 比如:Math类:sqrt()\random()\...
* 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.方法的声明:权限修饰符 返回值类型 方法名(形参列表){
* 方法体
* }
* static、final、abstract 来修饰的方法,后买再讲。
*
* 3. 说明:
* 3.1关于权限修饰符:默认方法的权限修饰符先使用public
* Java规定的4中权限修饰符:private、public、缺省、protected -->封装性再细聊
*
* 3.2返回值类型:有返回值 vs 没有返回值
* 3.2.1如果方法有返回值,则必须在方法声明时,指定返回值的类型,同时方法中需要使用
* return关键字来返回指定类型的变量或常量。
* 如果方法没有返回值,则方法声明时,使用void来表示
* 使用return.但是,如果使用的话,只能return;"表示"
* 3.2.2我们定义方法该不该有返回值?
* ① 题目要求
* 3.3 方法名:属于标识符,遵循标识符的规则和规范,"见名知意"
*
* 3.4 形参列表:方法可以声明0个,1个,或多个形参。
* 3.4.1 格式:数据类型1 形参1,数据类型2 形参2,...
*
* 3.4.2 我们定义方法时,该不该定义形参?
* ①题目要求
* ②凭经验:具体问题具体分析
*
* 4.return关键字使用:
* 1.使用范围:使用在方法体中
* 2.作用:① 结束方法
* ② 针对于有返回值类型的方法,使用"return"数据"方法返回所要的数据"
* 3.注意点:return关键字后面不可以声明执行语句。
* 5. 方法的使用中,可以调用当前类的属性或方法
*
*
* */
public class CustomerTest {
public static void main(String[] args) {
Customer cust1 = new Customer();
cust1.eat();
//测试形参是否需要设置的问题
// cust1.sort(arr);
// int[] arr = new int[] {3,4,5,2,5,63,2,5};
}
}
//客户类
class Customer{
//属性
String name;
int age;
boolean isMale;
//方法
public void eat() {
System.out.println("客户吃饭");
return;
}
public void sleep(int hour) {
System.out.println("休息了" + hour + "个小时");
}
public String getName() {
if(age > 18) {
return name;
}else {
return "Tom";
}
}
public String getNation(String nation) {
String info = "我的国籍是:" + nation;
return info;
}
// public void sort(int[] arr) {
//
// }
// public void sort() {
// int[] arr = new int[] {3,4,5,2,5,63,2,5};
// //。。。。
// }
}
//方法练习
/*
* 要求：(1)创建Person类的对象，设置该对象的name、
age和sex属性，调用study方法，输出字符串
“studying”，调用showAge()方法显示age值，调用
addAge()方法给对象的age属性值增加2岁。
(2)创建第二个对象，执行上述操作，体会同一个类的
不同对象之间的关系。
*
* */
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "Tom";
p1.age = 18;
p1.sex = 1;
p1.study();
p1.showAge();
int newAge = p1.addAge(2);
System.out.println(p1.name + "的新年龄为:" + newAge);
System.out.println(p1.age);//20
//********************************
Person p2 = new Person();
p2.showAge();//0
p2.addAge(10);
p2.showAge();//10
}
}
//方法设计
public class Person {
String name;
int age;
int sex;
/**
* sex:1表明是男性
* sex:0表明是女性
*/
public void study() {
System.out.println("studying");
}
public void showAge() {
System.out.println("age" + age);
}
public int addAge(int i) {
age += i;
return age;
}
}
//
/*
* 2.利用面向对象的编程方法,设计类Circle计算圆的面积。
* */
//测试类
public class CircleTest {
public static void main(String[] args) {
Circle c1 = new Circle();
c1.redius = 2.1;
double area = c1.findArea();
System.out.println(c1.findArea());
}
}
//圆
class Circle{
//属性
double radius;
//求圆的面积
//方式一:
// public double findArea() {
// double area = Math.PI * radius * radius;
// return area;
// }
//方式二:
public void findArea() {
}
}
//数组的遍历
/*
package com.atguigu.exer;
/*
* 4. 对象数组题目：
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩
score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示：
1) 生成随机数：Math.random()，返回值类型double;
2) 四舍五入取整：Math.round(double d)，返回值类型long。
*
* 此代码是对StudentTest.java的该进,将操作数组的功能封装到方法中。
*
*
*
*/
public class StudentTest {
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));
}
StudentTest test = new StudentTest();
//遍历学生数组
test.print(stus);
System.out.println("**********************************");
//问题一:打印3年级(state值为3)的学生信息
test.searchState(stus, 3);
System.out.println("***********************************");
//问题二:使用冒泡排序按学生成绩排序,并遍历所有学生信息
test.sort(stus);
for(int i = 0;i < stus.length;i++) {
System.out.println(stus[i].info());
}
}
//遍历Student1[]数组的擦作
public void print(Student1[] stus) {
//遍历学生数组
for(int i = 0;i < stus.length;i++) {
System.out.println(stus[i].info());
}
}
/**
* @Description 查找Student数组中指定年级的学生信息
* @param stus
* @param state 要找的年级
*/
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());
}
}
}
/**
* @Description 查找Student数组中学生排序
* @param stus
* @param state 对学生成绩进行排序
*/
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.面向对象思想编程内容的三条主线分别是什么?
<1>类及类的成员:属性、方法、构造器、代码块、内部类
<2>面向对象的三大特征:封装、继承、多态
<3>其他关键字:this,super,abstract,interface,static,final,package,import
面向对象的编程思想？
(类、对象:面向对象的三大特征......)
2.谈谈你对面向对象中类和对象的理解,并指出二者的关系。
类：抽象的、概念上的内容
对象:实实在在存在的一个个体
对象是由类派生出来的
3.面向对象思想的体现一:类和对象的创建执行操作有哪三步?
<1>创建类
<2>类的实例化
<3>调用对象的结构:"对象.属性""对象.方法"
4.画出代码在执行是的工作
class Car{
String color = "red";
int num = 4;
void show(){
int a = 10;
System.out.println("color"+color+,"num"+num);
}
}
class CarTest{
public static main(String[] args){
Car c1 = new Car();
Car c2 = new Car();
c1.coler = "blue";
c1.show();
c2.show();
}
}
5.类的方法内是否可以定义变量?是否可以调用属性?是否可以定义方法?是否可以调用方法?
是;是;否;是
6.对象的创建与对象的内存解析
典型代码:
Person p1 = new Person();
Person p2 = new Person();
Person p3 = new Person();//没有新创建一个对象,共用一个堆空间中的对象实体。
说明:
如果创建了一个类的多个对象,则每个对象都独立的拥有一套类的属性。(非static的)
意味着:如果我们修改一个对象的属性a,则不影响另外一个对象属性a的值。
内存解析:
匿名对象:
匿名对象不需要自己new一个类,而只需要将需要引用的对象进行引用就可以完成。
匿名对象:好想跑龙套的就出现一次下次使用还是需要调用使用。
*/
以上是更新的内容,面向对象的内容繁杂而且知识点多需要吸收。
浙公网安备 33010602011771号