本文介绍了Java中面向对象的一些基本概念，包括递归的定义及注意事项，构造方法的使用和默认构造器，方法重载的规则和示例，this关键字的作用以及在构造方法中的应用，包的创建、导入和命名规则，以及封装的实现方式如getter和setter方法。此外，还提及了访问修饰符的四种类型及其作用范围。
面向对象进阶
一、递归
1.概念：方法自己调用自己，但是会在某一个时机进行第次返回。
注意：递归的行为，通常要放在递归的条件之后
publicclassTest {
publicvoidfun(inti){
i--;
if(i>=0){
fun(i);
}
}
}
二、构造方法
1.什么是构造方法
用于初始化一个对象的方法
2.特点
构造方法名就是类名
没有返回值
创建对象时调用
案例：
packagecom.mine.demo01;
publicclassPerson {
publicPerson(){
System.out.println("DFshmily.STUDIO");
}
}
packagecom.mine.demo01;
publicclassMain {
publicstaticvoidmain(String[] args) {
Personperson=newPerson();
newPerson();
newPerson();
newPerson();
newPerson();
newPerson();
}
}
结果：
DFshmily.STUDIO
DFshmily.STUDIO
DFshmily.STUDIO
DFshmily.STUDIO
DFshmily.STUDIO
DFshmily.STUDIO
结论
每调用一次构造方法，就会创建一个新的对象
注意：
如果在一个类当中，没有显式的创建构造方法，则会由编译器提供一个无参构造。
3.构造方法的参数
构造方法同样可以有参数,构造方法的形参和实参与普通方法的别无二致
案例：
publicclassPerson {
publicPerson(Stringname){
System.out.println(String.format("我%s出生了，哈哈哈哈~！！！",name));
}
}
publicclassMain {
publicstaticvoidmain(String[] args) {
Personperson=newPerson("DF");
}
}
结果：
我DF出生了，哈哈哈哈~！！！
三、方法重载
概念：一个类当中，重复载入多个同名方法
1.方法重载的要素：
方法名要一致
参数要不一致：参数的数量、类型、位置
和返回值没有关系
对构造方法和普通方法都有效
案例：
packagecom.mine.demo02;
publicclassFood {
/**
* 构造方法与重载
*/
publicFood(){
System.out.println("0参构造");
}
publicFood(intf){
System.out.println("1参构造");
}
publicFood(inti,doublef){
System.out.println("2参构造");
}
publicFood(doublei,intf){
System.out.println("2参构造");
}
/**
* 方法的重载
*/
publicvoideat(){
System.out.println("0参方法");
}
publicvoideat(inti){
System.out.println("1参方法");
}
publicvoideat(intn,doublei){
System.out.println("2参方法");
}
publicvoideat(doublea,inti){
System.out.println("2参方法");
}
}
2.重载方法的调用
根据参数来进行调用
案例1：构造方法重载调用
packagecom.mine.demo02;
publicclassMain {
publicstaticvoidmain(String[] args) {
/**
* 构造方法的调用
*/
Foodfood=newFood();
Foodfood1=newFood(1);
Foodfood2=newFood(1,3.14);
Foodfood3=newFood(3.14,1);
}
}
结果：
0参构造
1参构造
2参构造
2参构造
案例2：普通方法重载调用
packagecom.mine.demo02;
publicclassMain {
publicstaticvoidmain(String[] args) {
/**
* 方法的调用
*/
food.eat();
food.eat(1);
food.eat(1,3.14);
food.eat(3.14,1);
}
}
结果：
0参的方法
1参的方法
2参的方法
2参的方法
四、this关键字
1.概念：特指对象本身
案例：
package com.mine.demo01;
public class Person {
public void print(){
System.out.println(String.format("Person的this打印结果：%s",this));
}
}
package com.mine.demo01;
public class Main {
public static void main(String[] args) {
Person p = new Person();
p.print();
System.out.println(String.format("Person的对象p打印结果：%s",p));
}
}
结果：
Person的this打印结果：com.mine.demo01.Person@5cad8086
Person的对象p打印结果：com.mine.demo01.Person@5cad8086
2.使用案例：
语法：
this.属性名
this.方法名()
this()
package com.mine.demo03;
public class Person {
private int id;//这个访问修饰符是为了保证该属性无法被类以外直接调用
private String name;
private int age;
public Person(){
}
public Person(int id){
this.id = id;
}
public Person(int id,String name){
this(id);
this.name =name;
}
public Person(int id,String name,int age){
this(id,name);
this.age = age;
}
}
3.注意的细节
this调用构造，必须在构造当中
this调用构造，必须在构造的第一行，且只能有一行
在静态当中无法使用this
五、包
1.概念：
包的本质是目录的划分
划分目录的目的是为了防止类与类之间的命名冲突
包的命名格式：
必须使用小写字母
必须是域名倒置+模块名
”.“不可用与开始和结束，因为”.“在包的命名当中是用于划分目录层级的
使用规则
一个类如果引用另一个类，被引用的类会存在两种情况：在同一个包中，不在同一个包
在同一个包下的类的引用，不需要引入包的概念（直接用就可以）
不在同一个包下，需要引用该类的时候，需要首先引入该类，或者是其所在包下所有的类
2.案例1：引入一个具体的类
package com.mine.demo07.cl2;//注意其所在包的位置
public class Person {
}
package com.mine.demo07.cl1;
import com.mine.demo07.cl2.Person;//引入了一个对应的具体的类
public class Main {
public static void main(String[] args) {
Person p = new Person();
}
}
3.案例2：引入一个包
package com.mine.demo07.cl1;
import com.mine.demo07.cl2.*;
public class Main {
public static void main(String[] args) {
Person p = new Person();
Dog d = new Dog();
}
}
注意：批量引入，只针对当前包当中类，不包含子包中的类
4.案例3：引入不同包下的同名类
package com.mine.demo07.cl1;
import com.mine.demo07.cl2.Dog;
public class Main {
public static void main(String[] args) {
Dog d = new Dog();
//使用全局限定名
com.mine.demo07.cl2.ccl.Dog d2 = new com.mine.demo07.cl2.ccl.Dog();
}
}
其他规则
每一个类当中都会有一个package，用于标明该类的位置，其有且只能有一行，并必须位于类的第一行
在java中有一个包是不需要显式引入的：java.lang
import必须在package和类的申明之间
import不能引入两个同名类，否则报错
包是辅助限权控制的重要介质
六、封装
1.getter/setter
对实体类的属性进行封装，其是封装的一种代表形式
步骤：
将所有属性的访问修饰符改为私有
通过setter方法给属性赋值
语法格式：
方法名set开头
属性名首字母大写，其他不变，拼接在set之后
参数和要赋值的属性一致
可以没有返回值
通过getter方法从属性取值
语法格式
方法名get开头
属性名首字母大写，其他不变，拼接在get之后
参数不能有
返回值类型和属性类型保持一致
案例：
package com.mine.demo04;
public class Person {
//属性私有
private int id;
private String name;
private int sex;
private int age;
public void setId(int id){
this.id = id;
}
public int getId(){
return id;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setSex(int sex){
this.sex = sex;
}
public int getSex(){
return sex;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
package com.mine.demo04;
public class Main {
public static void main(String[] args) {
Person p = new Person();
p.setId(1);
p.setName("df");
p.setSex(1);
p.setAge(18);
System.out.println(String.format("id:%s\tname:%s\tsex:%s\tage:%s",
p.getId(),p.getName(),p.getSex(),p.getAge()));
}
}
结果：
id:1 name:df sex:1 age:18
2.封装的优化
package com.mine.demo04;
public class Person {
//属性私有
private int id;
private String name;
private int sex = -1;
private int age = -1;
public Person(){
}
public Person(int id,String name,int sex,int age){
this.setId(id);
this.setName(name);
this.setSex(sex);
this.setAge(age);
}
public void setId(int id){
if(id<0){
System.out.println("id取值范围错误！");
}
this.id = id;
}
public int getId(){
return id;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setSex(int sex){
if(sex !=0&&sex !=1){
System.out.println("性别范围错误！");
return;
}
this.sex = sex;
}
public int getSex(){
return sex;
}
public void setAge(int age){
if(age > 120||age<0){
System.out.println("年龄范围取值错误！");
return;
}
this.age = age;
}
public int getAge(){
return age;
}
}
package com.mine.demo04;
public class Main {
public static void main(String[] args) {
Person p = new Person();
p.setId(1);
p.setName("df");
p.setSex(3);
p.setAge(180);
System.out.println(String.format("id:%s\tname:%s\tsex:%s\tage:%s",
p.getId(),p.getName(),p.getSex(),p.getAge()));
}
}
结果：
性别范围错误！
年龄范围取值错误！
id:1 name:df sex:-1 age:-1
3.链式调用
package com.mine.demo05;
public class Person {
//属性私有
private int id;
private String name;
private int sex = -1;
private int age = -1;
public Person(){
}
public Person(int id, String name, int sex, int age){
this.setId(id);
this.setName(name);
this.setSex(sex);
this.setAge(age);
}
public Person setId(int id){
this.id = id;
return this;
}
public int getId(){
return id;
}
public Person setName(String name){
this.name = name;
return this;
}
public String getName(){
return name;
}
public Person setSex(int sex){
this.sex = sex;
return this;
}
public int getSex(){
return sex;
}
public Person setAge(int age){
this.age = age;
return this;
}
public int getAge(){
return age;
}
}
package com.mine.demo05;
public class Main {
public static void main(String[] args) {
test(new Person().setId(1)
.setName("df")
.setSex(1)
.setAge(18));
}
public static void test(Person p){
System.out.println(String.format("id:%s\tname:%s\tsex:%s\tage:%s",
p.getId(),p.getName(),p.getSex(),p.getAge()));
}
}
结果：
id:1 name:df sex:1 age:18
七、访问修饰符
public（常用）
private（常用）
默认
protected
1.public:（共有的）
任何地方都可以访问
2.private:（私有的）
只能在本类当中
3.默认的
当前类当中
同一个包内可以访问
4.protected:受保护的
当前类当中
同一个包内可以访问
如果不在同一个包当中，想要访问有一个例外，即在其子类当中
案例：
package com.mine.demo03;
public class Test {
public int i;
protected int j;
int k;
private int h;
}
package com.mine.demo03.cl;
import com.mine.demo03.Test;
public class Test2 extends Test {
public void fun(){
super.j = 100;
}
}
八、类图
注意：
+代表public
-代表private
变量名：变量类型
方法名（参数名：参数类型......）：返回值类型
作业：
改造学员成绩管理系统：
将所有的类当中，属性全部隐藏，提供getter/setter方法，及其构造方法
增加一个功能，修改学生成绩
输入学生学号后，需要检查该学号是否存在
修改学生成绩后，重新排序
扫一扫
3405
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
