精华内容
下载资源
问答
  • java权限与属性方法权限

    千次阅读 2018-09-11 18:17:55
    默认可以称为friendly但是,java语言中是没有friendly这个修饰符的。C++中才是 如果写了一个类没有写访问权限修饰符,那么就是默认的访问权限,同一个包下的类都可以访问到,即使可以实例化该类 (当然如果这个类...
    • 类的访问权限(两种): 

    1. public:可以供所有的类访问。 
    2. 默认(包访问权限):默认的访问权限是包级访问权限。 默认可以称为friendly但是,java语言中是没有friendly这个修饰符的。C++中才是

          如果写了一个类没有写访问权限修饰符,那么就是默认的访问权限,同一个包下的类都可以访问到,即使可以实例化该类 
          (当然如果这个类不具有实例化的能力除外,比如该类没有提供public的构造函数)。 
    说明: 
        1、每个编译单元(类文件)都仅能有一个public class 
        2、public class的名称(包含大小写)必须和其类文件同名。 
        3、一个类文件(*.java)中可以不存在public class。 
        这种形式的存在的场景:如果我们在某个包内撰写一个class,仅仅是为了配合同包内的其他类工作,而且 
        我们不想再为了撰写说明文档给客户(不一定是现实意义的客户,可能是调用这个类的类)看而伤脑筋,而且有可能过一段时间之后    有可能会彻底改变原有的做法,并完全舍弃旧版本,以全新的版本代替。 
        4、class不可以是private和protected。(除了内部类之外) 
        5、如果不希望那个任何产生某个class的对象,可以将该类得所有构造函数设置成private。但是即使这样也可以生成该类的对象,就是class的static的成员(属性和方法)可以办到。

    • 类成员变量的访问权限: 

    1. public:紧接public的属性任何类都可以访问到。可以直接使用ClassName.propertyName。但是从类的封装性上来考虑将一个类的属性定义成public一般很少使用,    在定义静态常量的时候通常会这样定义。如:public static final int PAGE_SIZE=10; 
    2. private:只有类本身内部的方法可以访问类的private属性,当然内部类也可以访问其外部类的private成员的。(属性和方法) 
    3. 默认(friendly):包级可见,同一个包内的类可以访问到这个属性,可以直接使用className.propertyName来访问,但是从类的封装性特性来说很少这样使用类的属性的。 
    4. protected:关键字所处理的是所谓“继承”的观念。对于同一包的其他类,protected=默认,其它类可访问protected.对于不同包的类,如果存在继承关系,而baseClass存在protected属性,则可以被其自继承,而不同包的其他类 则不能访问类的protected属性。  
    • 3、类的成员方法的访问权限: 

    其从语法角度来讲,这写访问权限控制符作用于类的方法和作用于类的属性上的效果是一样的。 

    1. public:所有类可见。 
    2. private:只有同一类内部的方法可见,在有就是内部类也可以访问到。 
    3. 默认(friendly):包内可见。 
    4. protected:继承可见。 
    展开全文
  • java web简单权限管理设计

    万次阅读 多人点赞 2015-03-19 23:23:05
    推荐最新技术springboot版权限管理(java后台通用权限管理系统(springboot)),采用最新技术架构,功能强大! 注:由于该项目比较老,所以没有采用maven管理,建议下载springboot权限管理系统,对学习和使用会更有...

    源码免费下载地址:关注微信公众号“虾米聊吧”,回复关键字“权限

     

    推荐最新技术springboot版权限管理java后台通用权限管理系统(springboot)),采用最新技术架构,功能强大

    注:由于该项目比较老,所以没有采用maven管理,建议下载springboot权限管理系统,对学习和使用会更有帮助。

    springboot权限管理系统介绍地址:https://blog.csdn.net/zwx19921215/article/details/97806078

    springboot权限管理系统初级版下载地址:http://zyshare.cn/resource/detail/3

    springboot权限管理系统高级版下载地址:http://zyshare.cn/resource/detail/7

    springboot个人博客系统:https://blog.csdn.net/zwx19921215/article/details/102665020

    后台管理系统模板html打包下载: http://zyshare.cn/resource/detail/14

     

    最近在做一个网站类型项目,主要负责后台,ui框架选型为jquery easy ui,项目架构为spring mvc + spring jdbc,简单易用好上手!搭建好框架后开始了第一个任务,设计并实现一套简单的权限管理功能。

    一套最基本的权限管理包括用户、角色、资源。

     

    数据库设计

    我的设计如下:

    用户:user

    角色:role

    用户-角色:user_role

    资源:resource(包括上级菜单、子菜单、按钮等资源)

    角色-资源:role_resource

    标准的权限管理系统设计为以上5张表。

     

    注:用户、用户-角色我就不做说明了,这两个是很简单的两块,用户的crud,以及为用户分配角色(多对多的关系)稍微琢磨一下就清楚了,下面都是针对为角色分配权限的实现

    效果图:

    项目结构

     

    后台实现

    展示层采用ztree树

     

    role.jsp

     

    <%@ page contentType="text/html;charset=UTF-8"%>
    <%@ include file="/views/back/include/taglib.jsp"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    <html xmlns="http://www.w3.org/1999/xhtml">
    <head>
    <meta name="decorator" content="back" />
    <script type="text/javaScript">
    //打开菜单窗口
    function openMenuDialog(){
    	var selected = $("#list").datagrid('getSelected');
        if (selected != null) {
        	$("#id").val(selected.id);
        	queryMenus(selected.id);
        	$("#menuWindow").window("open");
        } else {
       	 $.messager.alert('提示', "未选择数据!"); 
        }
    }
    //角色-菜单信息入库
    function ajaxSubmit(rid,idstr){
    	$.post("${ctx}/roleMenu/save.jhtml",{"roleId":rid,"ids":idstr},function(obj){
    		$.messager.alert('提示',obj.msg);
    		$("#menuWindow").window('close');
    	},'json');
    }
    </script>
    <!-- ztree -->
    <script type="text/javascript">
    var tree = "";
    var setting = {
    	check : {
    		chkboxType:{"Y":"ps","N":"s"},//勾选checkbox对于父子节点的关联关系,取消勾选时不关联父
    		chkStyle:"checkbox",
    		enable : true	//是否复选框
    	},
    	//数据
    	data : {
    		simpleData : {
    			enable : true
    		}
    	}
    };
    //查询菜单信息
    function queryMenus(roleId){
    	$.post('${ctx}/role/treedata.jhtml', {'roleId':roleId}, function(zNodes) {
    		for (var i = 0; i < zNodes.length; i++) {
    			if (zNodes[i].isParent) {
    
    			} else {
    				//zNodes[i].icon = "${ctxStatic}/images/532.ico";//设置图标
    			}
    		}
    		tree = $.fn.zTree.init($("#tree"), setting, zNodes);
    		tree.expandAll(true);//全部展开
    		//var nodes = treeObj.getNodes();
    	}, 'json');
    }
    
    //获取选中节点
    function onCheck(){
    	 var rid = $("#id").val();
    	 var treeObj=$.fn.zTree.getZTreeObj("tree");
         var nodes=treeObj.getCheckedNodes(true);
         var ids = new Array();
         for(var i=0;i<nodes.length;i++){
        	//获取选中节点的值
        	 ids.push(nodes[i].id);
    	    // v+=nodes[i].id + ",";
    	    //alert(nodes[i].id); 
         }
    	ajaxSubmit(rid,ids);     
    }
    </script>
    </head>
    <body>
    	<!-- 数据表格 -->
    	<table id="list" url='${ctx}/role/list/page.jhtml' method='post'
    		class="easyui-datagrid" style="width:100%;" fitcolumns="true" 
    		toolbar='#tb' pagination='true' rownumbers='true' singleSelect='true'>
    		<thead>
    			<tr>
    				<th field='name' sortable='true' width='100'>角色名称</th>
    				<th field='description' width='200' align='right'>描述</th>
    				<th field='createTimeFormat' width='150' align='center'>创建时间</th>				
    			</tr>
    		</thead>
    	</table>
    	
    	<!-- 编辑栏  -->
    	<div id="tb" style="padding:5px 5px;">
    		<div>
    			<p2p:permission module="role" code="add"><a href="#" class="easyui-linkbutton" iconCls="icon-add" onclick="openCreateDialog();">新增</a></p2p:permission>
    			<p2p:permission module="role" code="edit"><a href="#" class="easyui-linkbutton" iconCls="icon-edit" onclick="openUpdateDialog();">编辑</a></p2p:permission>
    			<p2p:permission module="role" code="delete"><a href="#" class="easyui-linkbutton" iconCls="icon-remove" onclick="del();">删除</a></p2p:permission>
    			<p2p:permission module="role" code="authority"><a href="#" class="easyui-linkbutton" iconCls="icon-edit" onclick="openMenuDialog();">设置权限</a></p2p:permission>
    		</div>
    		<!-- 搜索项 -->
    		<div style="margin-top:5px;padding-left:5px">
    			用户名:   <input id="query_name" class="easyui-textbox" type="text" style="width:110px" />
    			创建日期: <input id="query_startDate" class="easyui-datebox" style="width:110px">
    			至: 	   <input id="query_endDate" class="easyui-datebox" style="width:110px">
    			<a onclick="reload();" href="#" class="easyui-linkbutton" iconCls="icon-search">查询</a>
    		</div>
    	</div>
    	
    	
    	
    	<!-- 权限窗口 -->
    	<div id="menuWindow" class="easyui-window" title="配置权限" data-options="modal:true,iconCls:'icon-save',footer:'#menuWindowfooter'" style="width:350px;height:420px;padding:10px">
    		<div id="tree" class="ztree" style="padding: 10px 20px;"></div>
    	</div>
    	<div id="menuWindowfooter" style="padding:5px;text-align:right;"> 
    		<a href="#" onclick="onCheck();" class="easyui-linkbutton" data-options="iconCls:'icon-save'">提交</a>
    	</div>
    	
    </body>
    </html>
    

     

     

    action层
    RoleAction.java

     

     

     

    @RequestMapping(value = "/treedata.jhtml")
    	@ResponseBody
    	public String treedata(HttpServletRequest request, Model model) {
    		DynamicParams params = new DynamicParams(request);
    		List<Map<String, Object>> mapList = Lists.newArrayList();
    
    		params.put("allMenu", "allMenu");
    		List<Menu> list = authManager.findMenuList(params);
    
    		List<RoleMenu> roleMenus = authManager.findRoleMenuList(params);
    
    		for (int i = 0; i < list.size(); i++) {
    			Menu e = list.get(i);
    			Map<String, Object> map = Maps.newHashMap();
    			map.put("id", e.getId());
    			map.put("pId", e.getParentId() != null ? e.getParentId() : 0);
    			map.put("name", e.getName());
    			for (RoleMenu roleMenu : roleMenus) {
    				if (roleMenu.getMenuId() == e.getId()) {
    					map.put("checked", true);
    				}
    			}
    			mapList.add(map);
    		}
    
    		return toJson(mapList);
    	}

     

     

     

     

     

    service层

    AuthManager.java

     

    // 菜单管理
    
    	public List<Menu> findMenuList(DynamicParams params) {
    		List<Menu> menus = new ArrayList<Menu>();
    
    		if ("allMenu".equals(params.getString("allMenu"))) {
    			menus = menuDao.findList(params);
    		} else {
    			// 通过用户查询角色
    			List<UserRole> userRoles = userRoleDao.findList(params);
    			// 通过角色查询菜单
    			List<RoleMenu> roleMenus = new ArrayList<RoleMenu>();
    			if (userRoles != null && userRoles.size() > 0) {
    				for (UserRole userRole : userRoles) {
    					params = new DynamicParams();
    					if (userRole != null) {
    						if (userRole.getRoleId().equals(params.getString("rid"))) {
    							break;
    						}
    						params.put("roleId", userRole.getRoleId().toString());
    						List<RoleMenu> rms = roleMenuDao.findList(params);
    						for (RoleMenu roleMenu : rms) {
    							roleMenus.add(roleMenu);
    						}
    					}
    				}
    			}
    
    			// 查询菜单信息
    			for (RoleMenu roleMenu : roleMenus) {
    				if (roleMenu != null) {
    					Menu menu = menuDao.find(roleMenu.getMenuId());
    					if (menu != null) {
    						menus.add(menu);
    					}
    				}
    			}
    			menus = removeDuplicate(menus);
    			Collections.sort(menus);
    		}
    		return menus;
    	}
    /**
    	 * 去除菜单中重复项
    	 * 
    	 * @param list
    	 * @return
    	 */
    	private List<Menu> removeDuplicate(List<Menu> list) {
    		List<Menu> result = new ArrayList<Menu>();
    		Set<Long> menuIds = new HashSet<Long>();
    		for (int i = 0; i < list.size(); i++) {
    			Menu m = list.get(i);
    			if (m != null && menuIds.add(m.getId())) {
    				result.add(m);
    			}
    		}
    		return result;
    	}

     

    public List<RoleMenu> findRoleMenuList(DynamicParams params) {
    		List<RoleMenu> roleMenus = roleMenuDao.findList(params);
    		return roleMenus;
    	}

     

     

    Dao层

    menuDao

    @Override
    	protected void createQuery(DynamicParams params, StringBuffer sql, List<Object> args) {
    		sql.append("select s.* from sys_menu s where 1=1 ");
    
    		String parentId = params.getString("parentId");
    		if (StringUtils.isNotBlank(parentId)) {
    			sql.append(" and parent_id = ? ");
    			args.add(parentId);
    		}
    
    		String sort = params.getString("sort");
    		String order = params.getString("order");
    
    		if (StringUtils.isNotBlank(sort)) {
    			sql.append(" order by ").append(hump2underline(sort));
    			if (StringUtils.isNotBlank(order)) {
    				sql.append(" " + order);
    			} else {
    				sql.append(" desc ");
    			}
    		} else {
    			sql.append("order by sort asc,id desc ");
    		}
    	}


    userRoleDao

     

    @Override
    	protected void createQuery(DynamicParams params, StringBuffer sql, List<Object> args) {
    		sql.append("select s.* from sys_user_role s where 1=1 ");
    		Long adminId = params.getLong("adminId");
    		if (adminId != null) {
    			sql.append(" and s.user_id = ?");
    			args.add(adminId);
    		}
    	}


    roleMenuDao

     

     

    @Override
    	protected void createQuery(DynamicParams params, StringBuffer sql, List<Object> args) {
    		sql.append("select s.* from ").append("sys_role_menu").append(" s where 1=1 ");
    		Long adminId = params.getLong("roleId");
    		if (adminId != null) {
    			sql.append(" and s.role_id = ?");
    			args.add(adminId);
    		}
    	}

     

     

     

    在WEB-INF目录下建立文件夹tlds 建立自定义标签文件shiros.tld,我们通过自定义标签实现页面按钮的控制。

     

     

    <span style="color:#333333;"><?xml version="1.0" encoding="UTF-8" ?>
    <taglib xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
    	version="2.0">
    	<description>p2p permission taglib</description>
    	<display-name>permission taglib</display-name>
    	<tlib-version>1.0</tlib-version>
    	<short-name>p2p_back</short-name>
    	<uri>http://vanfon.p2p.cn/</uri>
    
    	<tag>
    		<description>权限校验标签,有权限就显示标签体的内容,否则不显示</description>
    		<name>permission</name>
    		<tag-class>com.vanfon.p2p.back.tag.PermissionTag</tag-class>
    		<body-content>JSP</body-content>
    		<attribute>
    			<description></description>
    			<name>module</name>
    			<required>true</required>
    			<rtexprvalue>false</rtexprvalue>
    		</attribute>
    		<attribute>
    			<description></description>
    			<name>code</name>
    			<required>true</required>
    			<rtexprvalue>false</rtexprvalue>
    		</attribute>
    	</tag>
    </taglib></span>

     

     

    自定义标签类

     

    package com.vanfon.p2p.back.tag;
    
    import java.util.List;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.jsp.JspException;
    import javax.servlet.jsp.tagext.TagSupport;
    
    import com.vanfon.p2p.entity.system.Admin;
    import com.vanfon.p2p.entity.system.Menu;
    import com.vanfon.p2p.manager.system.AuthManager;
    import com.vanfon.p2p.utils.DynamicParams;
    import com.vanfon.p2p.utils.SpringContextHolder;
    
    /**
     * 权限控制标签
     * 
     * @author zhangwx
     * @date 2015-2-5
     */
    public class PermissionTag extends TagSupport {
    
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 4592227792811389132L;
    
    	private String module;// 属性名必须与JSP自定义标签的属性名一样
    
    	private String code;
    
    	public String getModule() {
    		return module;
    	}
    
    	public void setModule(String module) {
    		this.module = module;
    	}
    
    	public String getCode() {
    		return code;
    	}
    
    	public void setCode(String code) {
    		this.code = code;
    	}
    
    	@Override
    	public int doStartTag() throws JspException {
    		boolean result = false;
    		HttpServletRequest request = (HttpServletRequest) this.pageContext.getRequest();// 通过成员变量获取HttpServletRequest对象
    		Admin admin = (Admin) request.getSession().getAttribute("admin");// 获取登录到系统的用户
    		if (admin != null) {
    			if ("1".equals(String.valueOf(admin.getIfsuper()))) {// 超级管理员
    				result = true;
    			} else {
    				DynamicParams params = new DynamicParams();
    				params.put("id", String.valueOf(admin.getId()));
    				params.put("module", this.module);
    				params.put("code", this.code);
    				AuthManager authManager = SpringContextHolder.getBean(AuthManager.class);
    				List<Menu> userRoleAuths = authManager.findUserRoleAuthList(params);
    				if (userRoleAuths != null && userRoleAuths.size() > 0) {
    					result = true;
    				}
    			}
    		}
    		return result ? EVAL_BODY_INCLUDE : SKIP_BODY;
    	}
    }

     

     

     

     

     

     

     

     

    以上就是该权限管理中权限树(为角色分配权限)的大体实现。

    项目源码下载地址:http://www.zyshare.cn/resource/detail/1

    注:由于本项目年代久远,所以技术比较老旧,新人学习建议此项目 java后台通用权限管理系统(springboot)

    推荐项目:java后台通用权限管理系统(springboot)

    博主qq:193459197  , qq群技术交流与支持:557911445

     

    关注微信公众号“虾米聊吧”,回复“权限”获取源码,后续持续放送技术架构和资料干货!!!  

     

    一个热衷于分享技术和生活的程序猿,让我们一起交流吧~      
                        
                      微信扫描二维码,关注我的公众号


     
     

    展开全文
  • 详谈java的构造方法权限

    千次阅读 2017-10-03 19:25:42
    1,java的构造方法1)什么是构造方法? 名字和类名完全一样,没有返回值(可理解为返回一个对象), 用new来调,调用的结果是在堆内存中创建一个对象空间且返回它的堆内存首地址 public class MyDate_1 { private ...

    1,java的构造方法

    1)什么是构造方法?
    名字和类名完全一样,没有返回值(可理解为返回一个对象),
    用new来调,调用的结果是在堆内存中创建一个对象空间且返回它的堆内存首地址

    
    public class MyDate_1 {
        private int year;
        private int month;
        private int day;
    
        //空参构造
        public MyDate_1(){
    
        }
        //带参构造
        public MyDate_1(int year, int month, int day) {
            super();
            this.year = year;
            this.month = month;
            this.day = day;
        }
        //拷贝构造
        public MyDate_1(MyDate_1 my){
            this.year = my.year;
            this.month = my.month;
            this.day = my.day;
        }
        public int getYear() {
            return year;
        }
        public void setYear(int year) {
            this.year = year;
        }
        public int getMonth() {
            return month;
        }
        public void setMonth(int month) {
            this.month = month;
        }
        public int getDay() {
            return day;
        }
        public void setDay(int day) {
            this.day = day;
        }
        @Override
        public String toString() {
            return "MyDate_1 [year=" + year + ", month=" + month + ", day=" + day + "]";
        }
    
    }
    
    
    public class TestMyDate_1 {
        public static void main(String[] args) {
    
            //调用空参构造
            MyDate_1 my1 = new MyDate_1();
            System.out.println(my1);
    
            //调用带参构造
            MyDate_1 my2 = new MyDate_1(2017,10,1);
            System.out.println(my2);
    
            //调用拷贝构造
            MyDate_1 my3 = new MyDate_1(my2);
            System.out.println(my3);
            /**
             * 打印结果:
             * MyDate_1 [year=0, month=0, day=0]
             * MyDate_1 [year=2017, month=10, day=1]
             * MyDate_1 [year=2017, month=10, day=1]
             */
        }
    }
    

    2)构造方法的特点
    如果我们没有手动写构造方法,则Java会自动帮我们添加一个默认构造方法(空参的构造方法)。如果我们手动写了构造方法,则Java不会帮我们添加默认构造方法(空参的构造方法),如果我们需要就手动再添加

    3)在构造方法中调用构造方法
    这个需要使用this()

    public MyDate(MyDate d) {
        //在构造方法中调用构造方法,
        //用this(...), 且该方法只能在构造方法中调用,
        //功能是给内存中的数据赋值
        this(d.year,d.month,d.year); 
    }

    2,java中的权限问题

    权限从低到高(4种):
    1)private: 只有当前类能够访问
    2)缺省(默认): 只有当前包中的所有类(包含当前类)能访问
    3)protected: 当前包中的类能够访问,其它包中若是子类也能访问。其它包中不是当前类的子类则不能访问。
    4)public: 任意类(无论是否是相同的包或子类关系)都能访问

    这里写图片描述

    展开全文
  • 一文搞懂Java的 构造方法 和 访问权限

    千次阅读 多人点赞 2020-07-20 16:41:54
    Java是一门当今最火的编程语言之一,拥有很多现成可用的库,在我们编程生涯中,有着无比重要的地位。本文主要讲解Java中的构造方法和四种类的访问权限

     本文原创首发CSDN,本文链接https://blog.csdn.net/qq_41464123/article/details/107461710 ,作者博客https://blog.csdn.net/qq_41464123 ,转载请带上本链接,谢谢配合。


     


    目录

    零、前言

    一、构造方法

    1.1 简易版类的实例化

    1.2 使用构造方法实例化类

    二、Java的访问权限

    2.1 public 公开

    2.2 protected保护

    2.3 系统默认

    2.4 private私有保护

    三、总结


    零、前言

     

    Java是一门当今最火的编程语言之一,拥有很多现成可用的库,在我们编程生涯中,有着无比重要的地位。

    Java中有个概念叫做访问权限。它们是什么呢?今天我来详细讲解。

    本文所有代码已经上传CSDN下载模块,下载地址​​​​​​​,也可以在文章下方的评论区找我要,谢谢!


     

    一、构造方法

     

    1.1 简易版类的实例化

     

    在内部类中,会涉及到访问权限的概念;而在访问权限中,会涉及到构造方法的概念,所以我们先来学习什么是构造方法。

    我们先来编写一个最简单的类 —— 人,并且不用Java的封装。

    public class People {
    
    	String name;
    	
    	int age;
    	
    }

    人有两个属性,分别是名字name和年龄age。

     接着编写一个主函数,实例化这个类,并且输出它的属性。

    public class Main {
    
    	public static void main(String[] args) {
    		
    		People people = new People();
    		people.name = "ZWZ";
    		people.age = 18;
    		System.out.println("姓名 = " + people.name + ", 年龄 = " + people.age);
    	}
    
    }

    输出结果如下图所示:

    很好,那么我们如果要实例化五个类呢?很简单,我们写五遍就好了

    public class Main {
    
    	public static void main(String[] args) {
    		
    		People people1 = new People();
    		people1.name = "ZWZ01";
    		people1.age = 18;
    		
    		People people2 = new People();
    		people2.name = "ZWZ02";
    		people2.age = 18;
    		
    		People people3 = new People();
    		people3.name = "ZWZ03";
    		people3.age = 18;
    		
    		People people4 = new People();
    		people4.name = "ZWZ04";
    		people4.age = 18;
    		
    		People people5 = new People();
    		people5.name = "ZWZ05";
    		people5.age = 18;
    		
    		System.out.println("姓名 = " + people1.name + ", 年龄 = " + people1.age);
    		System.out.println("姓名 = " + people2.name + ", 年龄 = " + people2.age);
    		System.out.println("姓名 = " + people3.name + ", 年龄 = " + people3.age);
    		System.out.println("姓名 = " + people4.name + ", 年龄 = " + people4.age);
    		System.out.println("姓名 = " + people5.name + ", 年龄 = " + people5.age);
    	}
    
    }

     

    1.2 使用构造方法实例化类

     

    那么聪明的你又没有想过,能不能简化对类的实例化操作呢?

    当然可以!这就需要用到构造方法

    我们现在People.java类中添加构造方法,构造函数访问权限默认即可

    public class People {
    
    	String name;
    	int age;
    	
    	People(String name,int age){
    		this.name = name;
    		this.age = age;
    	}
    }

    这个时候,People类自带的无参构造方法就失效了。


    PS:当你没有为类写构造方法时,系统会默认给你安排一个无参的构造方法,当你自己写了构造方法之后,系统自带的就会消失。


    接着我们在主函数实例化类的时候,传入参数就可以了,代码是不是简单了很多?

    public class Main {
    
    	public static void main(String[] args) {
    		
    		People people1 = new People("ZWZ01",18);
    		People people2 = new People("ZWZ01",18);
    		People people3 = new People("ZWZ01",18);
    		People people4 = new People("ZWZ01",18);
    		People people5 = new People("ZWZ01",18);
    		
    		System.out.println("姓名 = " + people1.name + ", 年龄 = " + people1.age);
    		System.out.println("姓名 = " + people2.name + ", 年龄 = " + people2.age);
    		System.out.println("姓名 = " + people3.name + ", 年龄 = " + people3.age);
    		System.out.println("姓名 = " + people4.name + ", 年龄 = " + people4.age);
    		System.out.println("姓名 = " + people5.name + ", 年龄 = " + people5.age);
    	}
    }

    这就是构造方法。

    当然你也可以把输出信息放在构造方法内部,那也完全可以,就像这样:

    public class People {
    
    	String name;
    	int age;
    	
    	People(String name,int age){
    		this.name = name;
    		this.age = age;
    		System.out.println("姓名 = " + this.name + ", 年龄 = " + this.age);
    	}
    }

    主函数就直接做实例化操作即可。

    public class Main {
    
    	public static void main(String[] args) {
    		
    		People people1 = new People("ZWZ01",18);
    		People people2 = new People("ZWZ01",18);
    		People people3 = new People("ZWZ01",18);
    		People people4 = new People("ZWZ01",18);
    		People people5 = new People("ZWZ01",18);
    	}
    }

    总结起来一句话!构造方法就是在我们实例化类的时候,给类的指定变量赋值、执行指定方法。

     


    本文原创首发CSDN,本文链接https://blog.csdn.net/qq_41464123/article/details/107461710 ,作者博客https://blog.csdn.net/qq_41464123 ,转载请带上本链接,谢谢配合。


     

    二、Java的访问权限

     

    在讲内部类之前,必须要理解Java的访问权限。

    Java语言采用访问控制修饰符,来控制类、成员方法、成员变量的访问权限,共分为以下四个级别:

    (1)public 公开,对外部访问不做限制。

    (2)protected保护,只对子类和同一个包下的类公开。

    (3)默认级保护,不加修饰符,只对同一个包下的类公开。

    (4)private私有保护,只有自己才能访问,不对外公开。

    其中:以上访问级别只适用于类和类的成员,不适用于局部变量。

    成员变量、成员方法、构造方法都可以使用上面的四种访问级别。

    先把结论写出来,后面一一证明。

     

    Java四种访问权限的范围
     private默认protectedpublic
    同一类的成员
    同一个包的其他类(包括子类)×
    不同包的子类××
    不同包的非子类×××

     

    在第一块已经讲解了Java的构造方法,我们就以构造方法为例,讲解Java的访问权限

     

    2.1 public 公开

    首先是public 公开,我们将People类的构造方法的访问权限定义为public

    public class People {
    
    	String name;
    	int age;
    	
    	public People(String name,int age){
    		this.name = name;
    		this.age = age;
    		System.out.println("姓名 = " + this.name + ", 年龄 = " + this.age);
    	}
    }

    用自己包下的测试函数,跑一波

    public class Main {
    
    	public static void main(String[] args) {
    		People people = new People("ZWZ01",18);
    	}
    }

    发现没毛病,可以正常实例化People类。

    总结:使用public修饰访问权限,所有类都可以访问到此构造方法。

     


    2.2 protected保护

    我们在cn.ypc(下面简称A包)的People的构造方法,改成 protected 类型

    package cn.ypc;
    
    public class People {
    
    	String name;
    	int age;
    	
    	protected People(String name,int age){
    		this.name = name;
    		this.age = age;
    		System.out.println("姓名 = " + this.name + ", 年龄 = " + this.age);
    	}
    }
    

    测试A包下的主函数

    package cn.ypc;
    
    public class Main {
    
    	public static void main(String[] args) {
    		People people = new People("ZWZ01",18);
    	}
    }
    

    发现可以正常实例化

    接着测试cn.yy包(以下简称B包)下的测试函数

    IDE报错了,以我的英语水平都能看出来,按照中文式翻译方法

    The    constructor   People(String, int)   is   not    visible

    这个    结构体(类)     People(String, int)            可见的

    聪明的读者明白了吧?B包的测试函数无法读取A包People的构造方法。


    同理,如果是People的子类,能不能访问到 protected权限的构造方法呢?

    我们在A包下,创建一个Student学生类,继承自People父类。代码如下所示

    package cn.ypc;
    
    public class Student extends People{
    
    	protected Student(String name, int age) {
    		super(name, age);
    	}
    }

    接着在A包的测试类中,进行对Student学生类的实例化。

    package cn.ypc;
    
    public class Main {
    
    	public static void main(String[] args) {
    		Student student = new Student("ZWZ01",18);
    	}
    }

    可以正常输出!

     

    总结:只对子类,或者同一包下的类公开构造方法。(注意子类并不一定在一个包下)

     


    2.3 系统默认

    现在People类创建在A包下,我们在B包下创建一个People的子类——Student类。

    翻译一下,就是 People 类没有默认的构造方法,必须要自己定义一个构造方法

    当我们自动填写父类的构造方法的时候,IDE又报错了,类似之前的错误,也是构造方法找不到的问题。

    所以,可以得出结论:在系统默认的访问权限下,对同一个包公开,对不同包不公开。

     

    总结:系统默认情况下,只对同一包下的类公开构造方法。

    系统默认与protected不同的是,如果其子类不在同一包下,那么这个子类就不能访问父类的构造方法。


     

    2.4 private私有保护

    如果我们把A包的People类构造方法改为private私有

    package cn.ypc;
    
    public class People {
    
    	String name;
    	int age;
    	
    	private People(String name,int age){
    		this.name = name;
    		this.age = age;
    		System.out.println("姓名 = " + this.name + ", 年龄 = " + this.age);
    	}
    }

    看!首先是本包下的子类引用父类的构造方法,就报错了,说是找不到构造方法

    接着是本包下的测试类调用People的构造方法,也不行!

     

     那么如果是别的包下的测试类,那也一样找不到构造方法

     

    总结:如果被private修饰,那么这个构造方法只能被自己所用,不能被其他类所调用。


     

    三、总结

     

    1.构造方法:就是在我们实例化类的时候,给类的指定变量赋值、执行指定方法。

    2.public:使用public修饰访问权限,所有类都可以访问到此构造方法。

    3.protected:只对子类,或者同一包下的类公开构造方法。(注意子类并不一定在一个包下)

    4.系统默认:与protected不同的是,如果其子类不在同一包下,那么这个子类就不能访问父类的构造方法。

    5.private:如果被private修饰,那么这个构造方法只能被自己所用,不能被其他类所调用。

     

    Java的成员变量、成员方法、构造方法的访问级别可以是上面的任意一个,一般使用 public (公开)private (私有)会比较多。

    展开全文
  • java访问权限

    千次阅读 2010-07-14 09:16:00
    本文是Java教程之Java语言的访问权限修饰符部分。 上篇文章中,提到了Java类需要打包,打包后可以进行访问权限控制。本文中,将 对Java语言中的访问权限修饰符,进行简单介绍。一个Java应用有很多类,但是有些类,...
  • 如题.这是什么原因.?重写为什么字类的方法要大于父类的方法.
  • java 操作文件权限

    千次阅读 2019-01-15 14:42:23
    java 操作文件权限java 操作文件权限代码 java 操作文件权限 java 生成linux下的文件,有时候需要添加权限。比如755权限 代码 File directory = file.getParentFile(); FileUtils.forceMkdir(directory); ...
  • JAVA访问权限控制

    千次阅读 2013-09-01 14:12:10
    Java提供了public, private, protected 三个访问权限修饰词,提供了以下四种访问权限控制机制: 1、包访问权限; 2、Public访问权限;...3、Private访问权限;...当方法或域未给定访问权限限制符时,其默
  • Java权限基础

    万次阅读 2016-01-07 11:39:32
    Java权限控制器是什么鬼? 首先需要一个权限文件。 这里使用到一个命令行工具policytool。这个在JDK bin目录下面。 举个例子,以下代码默认是可以运行的 public class Main {   public static void ...
  • Java权限修饰词

    千次阅读 2016-11-20 13:15:23
    1;什么是权限修饰符,他有什么作用,为什么需要他;...权限修饰符就是用于控制被修饰变量、方法、类的可见范围.也就是其作用范围; 2;java权限修饰符包括4种;公共类型 public ; public可以修饰类,
  • Java访问控制权限

    千次阅读 2016-05-06 17:57:11
    Java中一共存在四种访问控制权限,即 private、default(默认)、protected和public 1、private 访问权限 private属于私有访问权限,可以用在属性的定义、方法的声明上,一旦使用了private关键字声明,则只能在...
  • Java主要提供了四种类型的权限修饰符,权限从大到小分别是private、default(缺省)、protected 、public,它们的权限如下表所示 权限修饰符 同一类内 同一包内 子 类 任何地方 private √ default...
  • Java权限修饰符

    千次阅读 2018-06-26 09:45:49
    一、Java的修饰符的分类:权限修饰符:public、默认(包访问权限)、protected、private其他修饰符:abstract、static、fianl、transient、volatile、native、synchronized、strictrp二、权限修饰符: 权限修饰符:...
  • Java方法(一)

    万次阅读 多人点赞 2021-09-29 22:24:45
    一、前言 前面我们学习了数组的概念和使用,现在我们来学习Java中的方法,这个方法和c语言的 函数十分相似。 方法的概述 方法是具有一定功能的代码段,我们通过这个来解决问题,
  • JAVA 数据权限设计

    万次阅读 2014-07-17 09:34:18
    在各种系统中,要保证数据对象的安全性以及易操作性,使企业的各业务部门、职能部门能够方便而且高效的协同工作,那么一个好的数据权限管理设计就成为一个关键的问题。虽然企业中各个单元的工作流程有所不同,处理的...
  • JAVA权限管理系统

    2009-08-06 11:22:49
    JAVA权限管理系统,帮助对java的权限实现和了解
  • 本篇文章主要介绍 Java 的访问权限控制。
  • Java web 后台菜单权限验证方法

    千次阅读 2018-10-11 09:48:09
    首先有个菜单表,和权限表,用户表, 用户表id 关联权限id 权限表中要有个 权限...方法将所有菜单id依次set进创建的BItInteger中 并保存到我们的权限表中, 2.在查询/判断权限时用菜单id依次和权限字段用BitInt...
  • java访问权限关键字

    千次阅读 2017-02-07 14:13:55
    Java的类成员访问权限修饰词有四类:private,无(默认情况下),protected和public。其权限控制如下表所示:   修饰词 本类 同一个包的类 继承类 其他类 private √ ×
  • 构造方法可以用哪个访问修饰符(private\protected\public\默认)? 如果用private修饰还是构造方法吗?是普通方法吗?
  • java实现用户权限模块两种方法

    千次阅读 2019-04-08 10:22:55
    方法一: 一般用这种比较多的,3个模块:用户模块、角色模块、菜单模块,对应数据库表:用户表、角色表、菜单表、用户角色表、角色菜单表,这种方法实现思路表结构都清晰明确,当然也存在一个弊端:菜单表添加菜单...
  • Java访问权限的修饰符public,private,protected,缺省(default)一个类中的成员变量和成员方法(非静态)被访问分为两种场景,一是在该类中,或其子类中访问,二是创建该类的对象进行访问。假设:有三个类 class ...
  • Java访问权限修饰符详解

    千次阅读 2018-05-14 10:04:54
    Java中的访问权限修饰符(Java关键字)今天很皮的发现,自己现在竟然不会玩儿Java基础了,就翻看了一下自己的笔记,写一篇文章复习一下!测试环境:Java运行环境,myEclipse。测试前准备:实体类包(Student类,...
  • JAVA访问权限控制(JAVA Access Control)

    千次阅读 2017-08-22 21:40:17
    —— 摘自JAVA编程思想 1. 代码会被重构。最初实现的代码并不是最好的(可维护性角度考虑)。 2. 消费者(客户端程序员)需要代码在某些方面不变。内在实现可变,但是接口调用方式不变,即不破坏消费者的代码。...
  • 开源权限管理java源码下载

    热门讨论 2017-04-01 20:27:24
    java开源权限管理
  • java权限管理系统的jar包

    千次下载 热门讨论 2012-11-10 10:42:19
    java权限管理系统的jar包配合http://www.oschina.net/code/snippet_59256_15087使用。
  • [java]方法重写的访问权限

    千次阅读 2012-07-30 13:26:22
    ---被重写的方法的访问权限不能为private ---子类的访问权限不能小于父类的访问权限
  • Java访问权限控制简述

    千次阅读 2016-11-29 19:58:57
    四种访问权限Java中类与成员的访问权限共有四种,其中三种有访问权限修饰词:public,protected,private,。 Public:权限最大,允许所有类访问,但其他包下的类想要访问需使用import关键字将这些public类导入包中...
  • Java权限设计与控制

    万次阅读 多人点赞 2017-06-17 10:53:34
    1.场景还原 近期,由于项目中要引用权限模块,于是笔者趁着空暇时间写了一个权限控制的小Demo,现在跟大伙讲讲权限的原理。2.权限数据库设计user:用户表user_role:用户角色表(用户跟角色多对多关系)role:角色表role...
  • java 中用户角色权限判定方法

    千次阅读 2012-05-21 11:48:54
    这里用Java语言描述,其实都差不多的。要换成其他的语言主,自己转一下就可以了。为了方便起见,我们这里定义a^b为:a的b次方。这里,我们为每一个操作设定一个唯一的整数值,比如: 删除A---0 修改A---1 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 711,798
精华内容 284,719
关键字:

java方法权限

java 订阅