精华内容
下载资源
问答
  • Java自己写的工具类封装成jar并在maven中添加依赖
    千次阅读
    2020-12-07 15:31:14

    将自己的写的工具类项目右键导出jar文件保存到自己设置的目录中
    打开cmd命令框输入并执行一下内容

    mvn install:install-file -DgroupId=com.xxx.test   -DartifactId=util -Dversion=0.0.1  -Dfile=D:\file\com.xxx.jar    -Dpackaging=jar
    

    –自行命名–

    解释下命令

    mvn install:install-file
         -DgroupId=com.xxx.test       #这个是引用的包名   相当于 groupId
         -DartifactId=util            #这个是引用的名字   相当于 artifactId
         -Dversion=0.0.1              #这个是版本        相当于 version
         -Dfile=D:\file\com.xxx.jar  #这个是jar文件所在的位置
         -Dpackaging=jar              #这个是打包类型
    

    maven中依赖
    在pom.xml 这样引用

    <dependencies>
      	<dependency>
      		<groupId>com.xxx.test</groupId>
      		<artifactId>util</artifactId>
      		<version>0.0.1</version>
      	</dependency>
      </dependencies>
    
    更多相关内容
  • Appium使用po实例和封装打包,包含断言、po封装,还有几个例子
  • JAVA封装JSON数据

    2019-04-09 01:03:37
    NULL 博文链接:https://hzywy.iteye.com/blog/1618266
  • 主要为大家详细介绍了java自定义封装StringUtils常用工具类,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Java封装AESUtil类

    2018-06-21 11:54:10
    AESUtil Java封装类 AES加密工具类,其中导入的jarjdk引进去就可以用了,jdk的版本尽量大于1.5
  • 个人jar自己封装

    2019-04-17 16:15:17
    个人jar
  • 当有几个项目A,B,C有公共执行的一些函数可以抽出来封装成一个工具供A,B,C这几个项目调用,提高代码效率。
  • 适合java进行文件上传下载的童鞋们,常用方法已包装好,可直接使用。
  • JAVA微信开发封装好的工具类及JAR
  • 本文给大家分享了2个java封装好的mail发送电子邮件的类,并附上使用方法,小伙伴们可以根据自己的需求自由选择。
  • 封装jar,包括验证、封装hibernate的templ、拼接hql和sql、分页封装方法
  • JAVA封装的外挂SDK

    2012-01-28 12:33:17
    很久以前的收集的,用JAVA封装的外挂开发,有键盘模拟,鼠标模拟,窗口相关的API
  • Java Logger Logging 封装

    2015-07-03 12:14:32
    Java日志实现。对java.util.logging.Logger的封装,在前人(原文件来自网络)的类上完善了文件的控制,使得日志文件可以重入。
  • 解决有java调用shell脚本需求的童鞋们,包含一些调用的测试方法,有问题可留言回复。
  • 并且在平时开发中会遇到各种各样通用的一些功能,比如对json的处理,对String对象的处理,对Excel文件的处理,MD5加密处理,Bean对象处理等等,这些常用并通用的方法可以被封装成一个个工具类如StringUtil,...
  • 那些有趣的java封装

    2020-12-21 15:47:33
    2.java中的 2.1 的概念 2.2 导包 3.this关键字 4.static关键字 5.代码块 一、封装 基本概念 封装思想:隐藏对象的属性和方法细节且对设置或读取类中的属性进行限制,防止他人随意操作。 封装概念:在设计一个类...
  • Java封装和封装的案例

    千次阅读 2019-08-03 20:05:47
    Java封装和封装的案例 目录 一、Java封装知识点简介 二、Java程序中的 三、static关键字、代码块 四、封装的综合应用案例: 一、Java封装知识点简介 1、面向对象三大特性之封装的概念: 隐藏类的某些内部...

    Java封装和封装的案例

    目录

    一、Java封装知识点简介

    二、Java程序中的包

    三、static关键字、代码块

    四、封装的综合应用案例:


    一、Java封装知识点简介

    1、面向对象三大特性之封装的概念:

    • 隐藏类的某些内部细节,不允许外部程序直接访问
    • 隐藏某些细节的类提供某些公共方法,对隐藏的内部细节进行访问和修改
    • 隐藏对象的信息
    • 留出访问的接口

    2、封装的特征:

    • 只能通过类提供的方法访问和修改数据
    • 隐藏类的实现细节,方便修改和实现

    3、封装的实现步骤:

    (1)、步骤:第一、修改属性的修饰符为private;第二、创建get/set方法来访问和修改属性值;第三、在get/set方法中添加控制语句规范代码

    (2)封装实现代码示例:创建getter/setter方法可以通过【源码】——【生成getter/setter方法来自动创建】

    package com.imooc.model;
    
    public class Student {
    	private String studentNo;
    	private String studentName;
    	private String studentSex;
    	private int studentAge;
    	//方案三,将学科对象作为属性
    	private Subject subject;
    	
    	public Subject getSubject() {
    		if(subject==null)
    			subject=new Subject();
    		return subject;
    	}
    	public void setSubject(Subject subject) {
    		this.subject = subject;
    	}
    	//无参构造
    	public Student() {
    		
    	}
    	//多参构造,实现对全部属性的赋值
    	public Student(String studentNo,String studnetName,String studentSex,int studentAge) {
    		this.setStudentNo(studentNo);
    		this.setStudentName(studnetName);
    		this.setStudentSex(studentSex);
    		this.setStudentAge(studentAge);
    	}
    	//将Subject对象初始化的构造函数
    	public Student(String studentNo,String studnetName,String studentSex,int studentAge,Subject subject) {
    		this.setStudentNo(studentNo);
    		this.setStudentName(studnetName);
    		this.setStudentSex(studentSex);
    		this.setStudentAge(studentAge);
    		this.setSubject(subject);
    	}
    	public String getStudentNo() {
    		return studentNo;
    	}
    	public void setStudentNo(String studentNo) {
    		this.studentNo = studentNo;
    	}
    	public String getStudentName() {
    		return studentName;
    	}
    	public void setStudentName(String studentName) {
    		this.studentName = studentName;
    	}
    	public String getStudentSex() {
    		return studentSex;
    	}
    	public void setStudentSex(String studentSex) {
    		if(studentSex=="男"||studentSex=="女")
    			this.studentSex = studentSex;
    		else
    			return;
    	}
    	public int getStudentAge() {
    		return studentAge;
    	}
    	public void setStudentAge(int studentAge) {
    		if(studentAge<=0||studentAge>100)
    			studentAge=18;
    		this.studentAge = studentAge;
    	}
    	/**
    	 * 介绍学生详细信息的方法(新增方法参数)
    	 * @param subjectName所学专业名称
    	 * @param subjectTime所学专业学时
    	 * @return 返回学生姓名、学号、年龄、性别、专业名称、学制年限等信息
    	 */
    	public String studentInfo(String subjectName,int subjectTime) {
    		String ref="学生详细信息:\n学生姓名:"+this.getStudentName()+"\n学生学号:"+
    	this.getStudentNo()+"\n学生年龄:"+this.getStudentAge()+"\n学生性别:"+
    				this.getStudentSex()+"\n所学专业名称:"+subjectName+"\n学制年限:"+subjectTime;
    		return ref;
    	}
    	/**
    	 * 学生详细信息介绍的方法重载(将对象作为方法参数)
    	 * @param subject专业对象名参数
    	 * @return 返回学生姓名、学号、年龄、性别、专业名称、学制年限等信息
    	 */
    	public String studentInfo(Subject subject) {
    		String ref="学生详细信息:\n学生姓名:"+this.getStudentName()+"\n学生学号:"+
    	this.getStudentNo()+"\n学生年龄:"+this.getStudentAge()+"\n学生性别:"+
    				this.getStudentSex()+"\n所学专业名称:"+subject.getSubjectName()+"\n学制年限:"+subject.getSubjectTime();
    		return ref;
    	}
    	/**
    	 * 返回学生相信信息介绍方法(将对象作为类的属性)
    	 * @return 返回学生姓名、学号、年龄、性别、专业名称、学制年限等信息
    	 */
    	public String studentInfo() {
    		String ref="学生详细信息:\n学生姓名:"+this.getStudentName()+"\n学生学号:"+
    				this.getStudentNo()+"\n学生年龄:"+this.getStudentAge()+"\n学生性别:"+
    							this.getStudentSex()+"\n所学专业名称:"+this.getSubject().getSubjectName()+"\n学制年限:"
    				+this.getSubject().getSubjectTime();
    		return ref;
    	}
    	
    }
    

    4、封装实现的意义:

    (1)、类的初始化时的三种初始化赋值方式:

    • 带参数的构造方法直接赋值
    • 通过添加了流程控制语句的getter/setter方法赋值
    • 带参构造方法中调用getter/setter方法达到过滤作用

    (2)、意义:可以过滤一些非法赋值。如:

    public void setStudentSex(String studentSex) {
            if(studentSex=="男"||studentSex=="女")
                this.studentSex = studentSex;
            else
                return;
        }

    二、Java程序中的包

    1、包的概念:计算机中用文件进行存储,用文件夹对文件进行管理。类似用Java文件存储源码,用包管理Java文件

    2、包的作用:

    • 管理Java文件
    • 与计算机中在 不同文件夹下的同名文件被允许一样。解决同名文件文件名冲突问题

    3、包的定义语法:

    package 包名;

    示例:

    package com.model.project;

    定义包时应注意:

    • 定义包的语法必须放在Java源文件的第一行
    • 一个Java源文件只能有一个package语句
    • 包名全部英文小写
    • 包名的命名规范:域名倒序+模块名+功能名

    4、导入包的语法:

    import 包名.类名;//导入当前包下的某个类

    示例:import com.imooc.model.Dog;//导入com.imooc.model包下的Dog类

    import 包名.*;//导入当前包下的全部类

    示例:import com.imooc.model.*;//导入com.imooc.model包下的所有类

    5、常用系统包:

    • java.lang:包含Java语言基础的类
    • Java.util:包含Java语言中各种工具类
    • Java.io:包含输入输出相关功能的类

    三、static关键字、代码块

    1、static关键字:

    static关键字 +属性静态属性
    static关键字+方法静态方法
    static关键字+类名不存在
    static关键字+方法内部局部变量不存在

    注意:静态成员随类加载产生,直到类销毁才回收

    2、静态方法:

    • 可以直接调用同类中的静态成员
    • 不可以直接调用同类中的其他非静态成员
    • 可以通过实例化对象后,对象名点方法名的方式调用非静态 成员

    3、代码块:

    • 通过{}形成代码块
    • 方法内的代码块称为普通代码块
    • 类内的代码块称为构造代码块
    • 在构造代码块钱加static关键字称为静态代码块

    4、代码块的执行顺序:

    • 无论实例产生多少对象,静态代码块只执行一次
    • 构造代码块随实例化过程调用
    • 普通代码块随方法调用执行

    四、封装的综合应用案例:

    1、模拟场景实现:

    (1)、需求:某校开设计算机科学与应用专业,专业编号J0001,学制四年,现有3名学生报名学习了这个专业

    (2)、需求分析:专业类(专业名称、专业编号、学制年限)、方法(专业相信信息);学生类(学生姓名、学号、性别、年龄、专业对象)、方法(介绍学生信息及所学专业)

    (3)、实现专业和学生关联:

    • 方案一:在学生类的自我 介绍 方法中,添加2个参数:专业名称和学制年限
    • 方案二:在学生类的自我 介绍 方法中,在方法中添加1个专业对象作为参数,通过其属性获得相关信息
    •  方案三:在类中添加专业对象作为属性,通过其属性获得相关信息

    (4)案例扩展:

    扩展功能:实现某种专业下统计报名学习的人数

    扩展功能实现:在专业类中添加数组、统计人数2个属性,同时添加一个添加学生对象的方法将对象添加进去并统计人数

    2、模拟场景代码实现:

    (1)、实现步骤:

    步骤一:在eclipse中国添加2个包model和test

    步骤二:在model包中添加2个类Student和Subject;在test包中添加Test类

    步骤三:按照封装的步骤(将属性设置为private;设置get/set方法;在get/set方法中加入流程控制语句)一次编写model包中的2歌类

    步骤四:在Text类中做测试 

    (2)、编写Subject类:

    package com.imooc.model;
    
    public class Subject {
    	/*
    	 * 封装的步骤一:将属性设置为私有,禁止类外部进行访问
    	 */
    	private String subjectName;//专业名称
    	private String subjectNum;//专业编号
    	private int subjectTime;//专业学时
    	private Student[] studentArray;//用来存储选修某专业的学生对象
    	private int studentCount;//记录选修某专业的人数
    	public Student[] getStudentArray() {
    		if(studentArray==null)
    			this.studentArray=new Student[200];
    		return studentArray;
    	}
    	public void setStudentArray(Student[] studentArray) {
    		this.studentArray = studentArray;
    	}
    	
    	//无参构造方法
    	public Subject(){
    		
    	}
    	//有参构造方法
    	public Subject(String subjectName,String subjectNum,int subjectTime) {
    		this.setSubjectName(subjectName);
    		this.setSubjectNum(subjectNum);
    		this.setSubjectTime(subjectTime);
    	}
    	//有参构造
    	public Subject(String subjectName,String subjectNum,int subjectTime,Student[] studentArray) {
    		this.setSubjectName(subjectName);
    		this.setSubjectNum(subjectNum);
    		this.setSubjectTime(subjectTime);
    		this.setStudentArray(studentArray);
    	}
    	public int getStudentCount() {
    		return studentCount;
    	}
    	public void setStudentCount(int studentCount) {
    		this.studentCount = studentCount;
    	}
    	/*
    	 * 封装类的步骤二:设置类外部访问属性的接口
    	 * 封装类 的步骤三:通过getter/setter方法添加控制语句
    	 */
    	//预留访问类的接口
    	public void setSubjectName(String subjectName) {
    		this.subjectName=subjectName;
    	}
    	public String getSubjectName() {
    		return this.subjectName;
    	}
    	
    	public void setSubjectNum(String SubjectNum) {
    		this.subjectNum=SubjectNum;
    	}
    	public String getSubjectNum() {
    		return this.subjectNum;
    	}
    	
    	public void setSubjectTime(int subjectTime) {
    		if(subjectTime<=0)
    			return;
    		this.subjectTime=subjectTime;
    	}
    	public int getSubjectTime() {
    		return this.subjectTime;
    	}
    	//在类中编写一个输出详细信息的方法
    	public String printDetail() {
    		String ref="专业详细信息为:\n专业名称:"+this.getSubjectName()+"\n专业编号:"
    	+this.getSubjectNum()+"\n学时:"+this.getSubjectTime();
    		return ref;
    	}
    	/**
    	 * 添加学员到数组中并记录数组中成员个数
    	 * @param student 传递进入方法的学生对象
    	 */
    	public void addStudent(Student student) {
    		for(int i=0;i<this.getStudentArray().length;i++) {
    			if(this.getStudentArray()[i]==null) {
    				this.getStudentArray()[i]=student;
    				this.studentCount=i+1;
    				return;
    			}
    		}
    	}
    }
    

    (2)、编写Student类:

    package com.imooc.model;
    
    public class Student {
    	private String studentNo;
    	private String studentName;
    	private String studentSex;
    	private int studentAge;
    	//方案三,将学科对象作为属性
    	private Subject subject;
    	
    	public Subject getSubject() {
    		if(subject==null)
    			subject=new Subject();
    		return subject;
    	}
    	public void setSubject(Subject subject) {
    		this.subject = subject;
    	}
    	//无参构造
    	public Student() {
    		
    	}
    	//多参构造,实现对全部属性的赋值
    	public Student(String studentNo,String studnetName,String studentSex,int studentAge) {
    		this.setStudentNo(studentNo);
    		this.setStudentName(studnetName);
    		this.setStudentSex(studentSex);
    		this.setStudentAge(studentAge);
    	}
    	//将Subject对象初始化的构造函数
    	public Student(String studentNo,String studnetName,String studentSex,int studentAge,Subject subject) {
    		this.setStudentNo(studentNo);
    		this.setStudentName(studnetName);
    		this.setStudentSex(studentSex);
    		this.setStudentAge(studentAge);
    		this.setSubject(subject);
    	}
    	public String getStudentNo() {
    		return studentNo;
    	}
    	public void setStudentNo(String studentNo) {
    		this.studentNo = studentNo;
    	}
    	public String getStudentName() {
    		return studentName;
    	}
    	public void setStudentName(String studentName) {
    		this.studentName = studentName;
    	}
    	public String getStudentSex() {
    		return studentSex;
    	}
    	public void setStudentSex(String studentSex) {
    		if(studentSex=="男"||studentSex=="女")
    			this.studentSex = studentSex;
    		else
    			return;
    	}
    	public int getStudentAge() {
    		return studentAge;
    	}
    	public void setStudentAge(int studentAge) {
    		if(studentAge<=0||studentAge>100)
    			studentAge=18;
    		this.studentAge = studentAge;
    	}
    	/**
    	 * 介绍学生详细信息的方法(新增方法参数)
    	 * @param subjectName所学专业名称
    	 * @param subjectTime所学专业学时
    	 * @return 返回学生姓名、学号、年龄、性别、专业名称、学制年限等信息
    	 */
    	public String studentInfo(String subjectName,int subjectTime) {
    		String ref="学生详细信息:\n学生姓名:"+this.getStudentName()+"\n学生学号:"+
    	this.getStudentNo()+"\n学生年龄:"+this.getStudentAge()+"\n学生性别:"+
    				this.getStudentSex()+"\n所学专业名称:"+subjectName+"\n学制年限:"+subjectTime;
    		return ref;
    	}
    	/**
    	 * 学生详细信息介绍的方法重载(将对象作为方法参数)
    	 * @param subject专业对象名参数
    	 * @return 返回学生姓名、学号、年龄、性别、专业名称、学制年限等信息
    	 */
    	public String studentInfo(Subject subject) {
    		String ref="学生详细信息:\n学生姓名:"+this.getStudentName()+"\n学生学号:"+
    	this.getStudentNo()+"\n学生年龄:"+this.getStudentAge()+"\n学生性别:"+
    				this.getStudentSex()+"\n所学专业名称:"+subject.getSubjectName()+"\n学制年限:"+subject.getSubjectTime();
    		return ref;
    	}
    	/**
    	 * 返回学生相信信息介绍方法(将对象作为类的属性)
    	 * @return 返回学生姓名、学号、年龄、性别、专业名称、学制年限等信息
    	 */
    	public String studentInfo() {
    		String ref="学生详细信息:\n学生姓名:"+this.getStudentName()+"\n学生学号:"+
    				this.getStudentNo()+"\n学生年龄:"+this.getStudentAge()+"\n学生性别:"+
    							this.getStudentSex()+"\n所学专业名称:"+this.getSubject().getSubjectName()+"\n学制年限:"
    				+this.getSubject().getSubjectTime();
    		return ref;
    	}
    	
    }
    

    (4)、编写Test测试类:

    package com.imooc.common;
    
    import com.imooc.model.Student;
    import com.imooc.model.Subject;
    
    //import java.util.Scanner;
    public class CharDemo {
    
    	public static void main(String[] args) {
    		Subject subject=new Subject("计算机科学与应用","j0001",4);
    		System.out.println(subject.printDetail());
    		System.out.println("-------------在方法中通过新增参数实现扩展-------------");
    		Student student=new Student("s01","张三","男",18);
    		System.out.println(student.studentInfo("计算机科学与应用",4));
    		System.out.println("------------将对象作为方法参数--------------");
    		Student student1=new Student("s02","李四","女",28);
    		System.out.println(student1.studentInfo(subject));
    		System.out.println("-------------将对象作为类的属性-------------");
    		Student student2=new Student("s03","王五","女",17,subject);
    		System.out.println(student2.studentInfo());
    		System.out.println("-------------想知道一个专业到底有多少个学生选修-------------");
    		subject.addStudent(student2);
    	    subject.addStudent(student1);
    		subject.addStudent(student);
    		System.out.println("选修"+subject.getSubjectName()+"专业的学生有"+subject.getStudentCount()+"名");
    	}
    }
    

    (5)、运行结果如下:

    专业详细信息为:
    专业名称:计算机科学与应用
    专业编号:j0001
    学时:4
    -------------在方法中通过新增参数实现扩展-------------
    学生详细信息:
    学生姓名:张三
    学生学号:s01
    学生年龄:18
    学生性别:男
    所学专业名称:计算机科学与应用
    学制年限:4
    ------------将对象作为方法参数--------------
    学生详细信息:
    学生姓名:李四
    学生学号:s02
    学生年龄:28
    学生性别:女
    所学专业名称:计算机科学与应用
    学制年限:4
    -------------将对象作为类的属性-------------
    学生详细信息:
    学生姓名:王五
    学生学号:s03
    学生年龄:17
    学生性别:女
    所学专业名称:计算机科学与应用
    学制年限:4
    -------------想知道一个专业到底有多少个学生选修-------------
    选修计算机科学与应用专业的学生有3名

     

    展开全文
  • Java 封装、继承、多态

    千次阅读 2021-03-07 14:27:26
    Java 封装、继承、多态1.封装封装的理解:将类的某些信息隐藏在类的内部,不允许外部程序直接访问,并通过该类提供的方法来实现对隐藏信息的操作和访问。(简单的说就是隐藏对象的信息,留出访问的接口)。特点:1....

    Java 封装、继承、多态

    1.封装:

    封装的理解:

    将类的某些信息隐藏在类的内部,不允许外部程序直接访问,并通过该类提供的方法来实现对隐藏信息的操作和访问。(简单的说就是隐藏对象的信息,留出访问的接口)。

    特点:1.只能通过规定的方法访问数据;2.隐藏类的实例细节,方便修改和实现。

    实现封装的方式:使用访问控制符:

    java提供了三种访问权限,准确的说还有一种是默认的访问权限,加上它一共四种。

    private   在当前类中可访问

    default        在当前包内和访问

    protected    在当前类和它派生的类中可访问

    public          公众的访问权限,谁都能访问

    现在代码实现下封装:

    bfb3fc9643ca4a300140d7438c8ae31f.png

    现在有两个类 学生类里有几个共有的字段 name age sex 现在用另一个Teacher类是可以访问它的属性的并非没有报错。

    32918e22ae7473e35d3561d50c56a9ca.png

    现在把字段的访问控制符 都改成了private Teacher类就访问不到了 这样就完成了属性的封装 那怎么让外界访问到Student的字段呢?

    就要用get set方法了

    789dc16cf2c9cc15de1214ad1c83dd64.png

    现在写了set和get方法 其他类只需要用get和set方法 就可以完成值的设置和获取

    运行Teacher.java结果:

    ec07bba4ecbe7236135c5a3e12ad9626.png

    可以看到设置并获取到了值

    2.继承:

    继承的概念

    继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。

    继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

    类的继承格式:

    在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,一般形式如下:

    class父类 {

    }class 子类 extends父类 {

    }

    代码实现一下:

    169ddf94194fc5b08af8338a129bbde5.png

    现在这里有三个类 Student Person Teacher 其中Student 和 Teacher 都继承了Person 所以 Person是父类 Student和Teacher是子类

    a0848d0a2ef38a9e483f00aa475e35dc.png

    现在向Preson类写一个字段和一个方法 在子类中创建父类对象 然后可以看到子类都可以调用父类的方法和属性 这就是继承:子类从父类继承方法,使得子类具有父类相同的行为。

    运行子类结果:

    736d82dcacaf77a480240ec766bd6456.png

    得到了父类的方法和属性

    f88c794b7c9050e9452c16c4df80f8f4.png

    当我们用一个对象 点 的时候下面会有很多方法 我们并没有继承为什么会有呢?

    这是因为java的所有类都继承的object类这些方法其实就是object类中的方法

    3.多态:

    多态是同一个行为具有多个不同表现形式或形态的能力。

    多态就是同一个接口,使用不同的实例而执行不同操作,如图所示:

    4029680a21999a23731efbeb5043ce0e.png

    代码实现多态:

    1f5f273b1d1eb2fc9a690a192cbd619b.png

    现在有三个类 Person Student 和 Text  Student继承了Person

    7bd160b64a9ef5259cb1710fcb01bd3b.png

    现在在测试类里 分别new三个对象 可以看到 都是new的Student 但是他的引用类型可以是他的父类和Object

    6771347d5fbb6a051d2e2bfaa097b205.png

    分别调用student的say方法和student2的say方法

    运行:

    35309b4d23f4799551b28fb9d9becd61.png

    可以看到都调用了父类的say方法

    52bff846f10d3b5ad82f69a664b89b3c.png

    现在在Student中重写父类的say方法

    2bc4ff7ebb0a5a30b7540df8284d2e14.png

    在测试类中再次调用student的say和student2的say方法

    运行:

    4502284ef2b1f3d57ac8d695ad4d11eb.png

    可以看到虽然student2引用类型是Person但是并没有执行父类的say方法

    这就完成了多态 虽然都是同一个父亲但是自己完成了不一样的操作

    展开全文
  • Java-封装 接口

    千次阅读 2021-02-12 14:50:59
    Java 封装封装是指一种将抽象性函式接口的实现...而不用修改那些调用代码的程序片段封装的优点良好的封装能够减少耦合、类内部的结构可以自由修改、可以对成员变量进行更精确的控制、隐藏信息,实现细节实现Java封装...

    Java 封装

    封装是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法

    封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问

    要访问该类的代码和数据,必须通过严格的接口控制

    封装最主要的功能在于能够修改自己的实现代码,而不用修改那些调用代码的程序片段

    封装的优点

    良好的封装能够减少耦合、类内部的结构可以自由修改、可以对成员变量进行更精确的控制、隐藏信息,实现细节

    实现Java封装的步骤

    public class EncapTest{

    // 修改属性的可见性来限制对属性的访问(一般限制为`private`)

    private String name;

    private String idNum;

    private int age;

    //对每个值属性提供对外的公共方法访问,即创建一对赋取值方法,用于对私有属性的访问

    public int getAge() {

    return age;

    }

    public String getName() {

    return name;

    }

    public String getIdNum() {

    return idNum;

    }

    public void setAge(int newAge) {

    age = newAge;

    }

    public void setName(String newName) {

    name = newName;

    }

    public void setIdNum(String newId) {

    idNum = newId;

    }

    }

    //变量如何被访问

    public class RunEncap{

    public static void main(String args[]) {

    EncapTest encap = new EncapTest();

    encap.setName("James");

    encap.setAge(20);

    encap.SetIdNum("1234");

    System.out.print("Name:" + encap.getName() + "Age:" + encap.getAge());

    }

    }

    接口

    接口是一个抽象类型,是抽象方法的集合,接口通常以interface来声明;一个类通过继承接口的方式,从而来继承接口的抽象方法

    接口并不是类,编写接口的方式和类很相似,但是它们属于不同概念。类描述对象的属性和方法;接口则包含类要实现的方法

    除非实现接口放入类是抽象类,否则该类要定义接口中的所有方法

    接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类

    接口与类相似点

    一个接口可以有多个方法

    接口文件保存在.java结尾的文件中,文件名使用接口名

    接口的字节码文件保存在.class结尾的文件中

    接口相应的字节码文件必须在与包名称相匹配的目录结构中

    接口与类的区别

    接口不能用于实例化对象

    接口没有构造方法

    接口中所有的方法必须是抽象方法

    接口不能包含成员变量,除了static和final变量

    接口不是被类继承了,而是要被类实现

    接口支持多继承

    接口的声明

    [可见度] interface 接口名称 [extends 其他的类名] {

    //声明变量

    //抽象方法

    }

    实例

    interface Animal {

    public void eat ();

    public void traval ();

    }

    接口的实现

    当类实现接口的时候,类要实现接口中所有的方法;类使用implements关键字实现接口

    public class MammalInt implements Animal{

    public void eat() {

    System.out.println("Mammal eats");

    }

    public void traval() {

    System.out.println("Mammal travels");

    }

    public int noOfLegs() {

    return 0;

    }

    public static void main(String args[]) {

    MamamlInt m = new MammalInt();

    m.eat();

    m.traval();

    }

    }

    重写接口中声明的方法时,需要注意以下规则

    类在实现接口的方法时,不能抛出强制性异常,只能在接口中,或者继承接口的抽象类中抛出该强制性异常

    类在重写方法时要保持一致的方法名,并且应该保持相同或者相兼容的返回值类型

    如果实现接口的类是抽象类,那么就没必要实现该接口的方法

    在实现接口的时候,需要注意

    一个类可以同时实现多个接口

    一个类只能继承一个类,但是能实现多个接口

    一个接口能继承另一个接口

    接口的继承--使用extends关键字,子接口继承父接口的方法

    // Sport.java

    public interface Sports

    {

    public void setHomeTeam(String name);

    public void setVisitingTeam(String name);

    }

    // Football.java

    public interface Football extends Sports

    {

    public void homeTeamScored(int points);

    public void visitingTeamScored(int points);

    public void endOfQuarter(int quarter);

    }

    // Hockey.java

    public interface Hockey extends Sports

    {

    public void homeGoalScored();

    public void visitingGoalScored();

    public void endOfPeriod(int period);

    public void overtimePeriod(int ot);

    }

    接口的多继承

    public interface Hockey extends Sports, Event

    展开全文
  • 对于jedis的二次封装,所有方法都从简调用,jar引入到项目,默认构造器会扫描配置文件,读取redis参数,也可以通过构造器自定义参数,所有的异常处理,类型转换和锁控制都处理好了,还有对于map,bean对象,数组的...
  • java方法和封装

    千次阅读 2021-02-12 16:56:51
    JavaBean的概念 JavaBean是一种java语言写成的可重用软件,其他java类可以通过反射机制发现和操作这些JavaBean的属性。 JavaBean本质上就是符合以下标准的java类: 类是公共的; 有一个无参的公共的构造器; 有属性...
  • 主要介绍了Java实现Http工具类的封装操作,涉及java针对http请求与响应、远程交互与字符串拼接等操作封装技巧,需要的朋友可以参考下
  • java如何实现封装

    千次阅读 2021-03-22 17:53:09
    java封装类通过三个步骤实现: (1)修改属性的可见性,限制访问。 (2)设置属性的读取方法。 (3)在读取属性的方法中,添加对属性读取的限制。Java中什么叫封装呢? 继承和多态都明白些,就是封装理解不上去,老师没...
  • 主要介绍了Java实现AOP功能的封装与配置的小框架实例代码,分享了相关代码示例,小编觉得还是挺不错的,具有一定借鉴价值,需要的朋友可以参考下
  • java常用工具类封装

    千次阅读 2021-09-29 10:35:41
    java常用工具类封装 import org.apache.commons.lang.StringUtils; import java.math.BigDecimal; public class CommonUtil { public static String safeToString(Object value, String defaultValue) { if ...
  • 提供java jni示例程序,linux so工程,windows dll工程,将科大讯飞语音合成程序封装成windows支持的dll和linux支持的so并且导出api,java使用jni直接调用。代码均已编译测试通过,需要appid和mscdll则可以自己去...
  • 修改数据库连接字段,以及对应名,即可调用。看的懂的可以选在加载配置文件来获取数据库连接信息。
  • http请求封装

    2019-05-08 09:04:39
    封装了一下java 的http请求工具类要求jdk版本在1.8及以上
  • 所以我对socket进行了封装,客户端和服务端可以通过配置注解,让双方相互调用注解方法,提供了专门的工具类,让注解方法可以支持返回list或map等集合或其他的类型,三行代码你就可以完美的使用socket进行通信,支持...
  • Java封装一个类怎么实现?

    千次阅读 2021-02-12 17:32:05
    封装将某些东西包装在一起,然后以新的完整形式呈现出来;隐藏属性、方法或实现细节的处理方式称为封装封装其实就是有选择性地公开或隐藏某些信息,它解决了数据的安全性问题。构建对象的方法和数组相似,对象也是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 653,781
精华内容 261,512
关键字:

java 封装包

java 订阅