首页 > 其他分享 >面向对象进阶

面向对象进阶

时间：2023-03-14 17:57:57浏览次数：41  
标签：进阶 Person int public 面向对象 com id String

面向对象进阶

一、递归

1.概念：方法自己调用自己，但是会在某一个时机进行第次返回。

注意：递归的行为，通常要放在递归的条件之后

public class Test {
	public void fun(int i){
		i --;
		if(i>=0){
			fun(i);
		}
	}
}

二、构造方法

1.什么是构造方法

用于初始化一个对象的方法

2.特点

  1. 构造方法名就是类名
  2. 没有返回值
  3. 创建对象时调用

案例：

package com.mine.demo01;

public class Person {
    public Person(){
        System.out.println("DFshmily.STUDIO");
    }
}


package com.mine.demo01;

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        new Person();
        new Person();
        new Person();
        new Person();
        new Person();
    }
}

结果：
DFshmily.STUDIO
DFshmily.STUDIO
DFshmily.STUDIO
DFshmily.STUDIO
DFshmily.STUDIO
DFshmily.STUDIO

结论

每调用一次构造方法，就会创建一个新的对象

注意：

如果在一个类当中，没有显式的创建构造方法，则会由编译器提供一个无参构造。

3.构造方法的参数

构造方法同样可以有参数,构造方法的形参和实参与普通方法的别无二致

案例：

public class Person {
	public Person(String name){
		System.out.println(String.format("我%s出生了，哈哈哈哈~！！！",name));
	}
}

public class Main {
	public static void main(String[] args) {
		Person person = new Person("DF");
	}
}

结果：
我DF出生了，哈哈哈哈~！！！

三、方法重载

概念：一个类当中，重复载入多个同名方法

1.方法重载的要素：

  1. 方法名要一致
  2. 参数要不一致：参数的数量、类型、位置
  3. 和返回值没有关系
  4. 对构造方法和普通方法都有效

案例：

package com.mine.demo02;

public class Food {
    /**
     * 构造方法与重载
     */
    public Food(){
        System.out.println("0参构造");
    }

    public Food(int f){
        System.out.println("1参构造");
    }

    public Food(int i,double f){
        System.out.println("2参构造");
    }

    public Food(double i,int f){
        System.out.println("2参构造");
    }

    /**
     * 方法的重载
     */

    public void eat(){
        System.out.println("0参方法");
    }
    public void eat(int i){
        System.out.println("1参方法");
    }
    public void eat(int n,double i){
        System.out.println("2参方法");
    }
    public void eat(double a,int i){
        System.out.println("2参方法");
    }

}

2.重载方法的调用

根据参数来进行调用

案例1：构造方法重载调用

package com.mine.demo02;

public class Main {
    public static void main(String[] args) {
        /**
         * 构造方法的调用
         */
        Food food = new Food();
        Food food1 = new Food(1);
        Food food2 = new Food(1,3.14);
        Food food3 = new Food(3.14,1);
    }
}

结果：
0参构造
1参构造
2参构造
2参构造

案例2：普通方法重载调用

package com.mine.demo02;

public class Main {
    public static void main(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.注意的细节
  1. this调用构造，必须在构造当中
  2. this调用构造，必须在构造的第一行，且只能有一行
  3. 在静态当中无法使用this

五、包

1.概念：
  1. 包的本质是目录的划分
  2. 划分目录的目的是为了防止类与类之间的命名冲突
  3. 包的命名格式：
    • 必须使用小写字母
    • 必须是域名倒置+模块名
    • ”.“不可用与开始和结束，因为”.“在包的命名当中是用于划分目录层级的
  4. 使用规则
    • 一个类如果引用另一个类，被引用的类会存在两种情况：在同一个包中，不在同一个包
      • 在同一个包下的类的引用，不需要引入包的概念（直接用就可以）
      • 不在同一个包下，需要引用该类的时候，需要首先引入该类，或者是其所在包下所有的类
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

对实体类的属性进行封装，其是封装的一种代表形式

步骤：

  1. 将所有属性的访问修饰符改为私有
  2. 通过setter方法给属性赋值
    • 语法格式：
      • 方法名set开头
      • 属性名首字母大写，其他不变，拼接在set之后
      • 参数和要赋值的属性一致
      • 可以没有返回值
  3. 通过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:（私有的）

只能在本类当中

image

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;
	}
}

八、类图

image

注意：

+代表public

-代表private

变量名：变量类型

方法名（参数名：参数类型......）：返回值类型

作业：

改造学员成绩管理系统：

  1. 将所有的类当中，属性全部隐藏，提供getter/setter方法，及其构造方法
  2. 增加一个功能，修改学生成绩
    • 输入学生学号后，需要检查该学号是否存在
    • 修改学生成绩后，重新排序

标签：进阶,Person,int,public,面向对象,com,id,String
From： https://www.cnblogs.com/DFshmily/p/17215765.html

相关文章

  • JavaSE-day02（面向对象：内部类，枚举，泛型）
    一、内部类内部类是类中的五大成分之一（成员变量、方法、构造器、内部类、代码块），如果一个类定义在另一个类的内部，这个类就是内部类。当一个类的内部，包含一个完整的事物，且......
  • JavaSE-day01(面向对象高级)
    面向对象的核心：设计对象来处理数据，解决问题。一、静态static读作静态，可以用来修饰成员变量，也能修饰成员方法。1.1static修饰成员变量Java中的成员变量按有无static修......
  • 提醒工具的进阶玩法来了，如何利用提醒功能实现每日目标？
    相信很多人都有过这样的经历，为了完成某个重要的任务，列出了详细的计划和步骤，但是在执行的过程中，总是因为这样或那样的原因导致忘记或拖延，最终无法按时完成既定的目标。那么......
  • Java面向对象
    方法：packagestudy1;publicclassDemo1{ publicstaticvoidmain(String[]args){ //调用方法 doubleaa=sjx(10,2); System.out.println("三角形的面积......
  • C语言指针进阶（一）
    前言什么是指针？指针就是一个可以存储地址的变量。当我们将具体的某个对象的地址存放到某个指针变量当中时，我们可以说将某个对象的地址存放到某个指针当中，也可以说指向某个对......
  • 面向对象
    面向对象面向对象是基于面向过程的编程思想面向对象的思想特点是一种更符合我们思考习惯的思想把复杂的事情简单化让我们从执行者变成了指挥者注意：如何让我们的操作更......
  • 面向对象
    面向对象1.初识面向对象面向过程思想步骤清晰简单，第一步做什么，第二步做什么…面对过程适合处理一些较为简单的问题。面向对象思想物以类聚，分类的思维模式，思考问......
  • 面向对象类图的六种关系（继承、实现、依赖、关联、聚合、组合）
    进行面向对象设计时，经常需要根据场景抽象出一些类，梳理各个类之间的关系，实现一个“低耦合，高内聚”的系统。下面通过学生、班级、教师、学校这些角色和场景，说明面向对象中，类......
  • UML-面向对象与软件建模
    面向对象与软件建模面向对象技术以问题域中出现的问题为中心，进行模型化设计和开发基础知识：对象与类封装泛化（继承）多态性多态的两种模式：方法的多态性方法的重......
  • 面向对象基础
    一、面向对象基础1、面向对象思想简介软件编程就是将我们的思维转变成计算机能够识别语言的一个过程什么是面向过程？自上而下顺序执行，逐步求精其程序结构是按功能......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99