精华内容
下载资源
问答
  • 关键字 private

    2016-01-31 11:29:21
    //面向对象 封装private class Person { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Persono p = new Persono();

    //面向对象 封装private
    class Person {
    /**
    * @param args
    */
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    Persono p = new Persono();
    p.setAge(40);
    p.speak();//在堆内存中 默认初始值是0 最后age = 0

    }
    

    }

    /**
     * private 私有的  权限修饰符 用于修饰类中的成员(成员变量,成员函数)
     * 私有只在本类中有效
     * 将age私有化以后 类以外即使建立了对象也不能直接访问 人应该有年龄
     * 就需要在person类中提供对应访问age的方式
     * 注意: 私有仅仅是封装的一种表现形式 是最小权限
     * 之所以对外数据提供访问方式 就因为可以在访问方式中加入逻辑判断等语句
     * 对访问的数据进行操作 提高代码健壮性
     * */
    

    class Persono{
    private int age;//只能在person类中访问 private 以外不可访问age这个变量
    public void setAge(int a) //设置
    {
    if(a>0 && a<130)
    {
    age = a;//谁在使用付给谁
    speak();
    }
    else
    System.out.println(“你特么在逗我?”);
    }
    public int getAge() //获取
    {
    return age;
    }
    void speak()
    {
    System.out.println(“age =”+age);
    }
    }

    展开全文
  • 封装、关键字private & this 文章目录封装、关键字private & this1.封装 & private关键字1.1两种封装1.2封装步骤1.3封装的好处2.this关键字2.1this的特点2.2this是对象的证明 1.封装 & private...

    封装、关键字private this & static

    1.封装 & private关键字

    封装的概述:隐藏对象的属性和功能的实现,仅对外界提供公共访问方式(封装本质是访问权限修饰符)

    (封装就是对容器进行权限控制,通过访问权限修饰符【private、static…】实现)

    1.1两种封装

    1. 封装成员变量
    2. 封装成员方法

    1.2封装步骤

    1. 对封装的成员添加private关键字

              // 1.对需要封装的成员添加private关键字修饰
              private String name;	
              private int age;
              private String address;
      
    2. 添加对成员的读写(get / set)

      		// 自动生成get/set方法
              // alt + shift + s 再按R键
              public String getAddress() {
                  return address;
              }
      
              public void setAddress(String address) {
                  this.address = address;
              }
      
    3. 在读写方法中添加逻辑业务代码或者数据校验代码

    1.3封装的好处

    • 提高了类的成员的安全性(避免外界修改错误数据)

    2.this关键字

    当局部变量 & 成员变量重名时,需要用this关键字进行区分

    2.1this的特点

    1. this本质就是一个引用、变量、实例,是当前类的对象(变量:this)

    2. this可以理解成 “自己的”

              public void setAuthor(String author) {
                  this.author = author;
                  //指的author不是参数列表的author,是成员变量author
              }
      
    3. this只能出现在类的内部

    4. 类的成员在内部访问可以忽略this

              public String getAuthor() {
                  return author;// return this.author;
                  //author是成员变量,但在栈区调用时没有创建对象
                  //原因是因为已经有对象指向堆区(省略的this)
              }
      
    5. 每次创建一个对象默认都会创建一个this引用指向自己对应的那个堆区的空间,相互独立互补影响

    6. 谁new或者谁调用某个方法,this就代指谁

    7. 静态环境(static)下不能够出现this 和 super

    8. this除了可以访问本类的成员变量和成员方法以外还可以访问构造方法

    2.2this是对象的证明

            public void test() {
                this.show();
    
                Book book = new Book();
                method(book);//创建的新对象
                method(new Book());//匿名的对象也是创建了新的对象
                method(this);//假如this也能像上面两情况一样,不报错,即this也是对象
            }
    
            // 证明this就是当前类的引用
            public void method(Book book) {
                book.show();
            }
    

    3.static关键字

    多个对象共享同一份数据时,可以使用static关键字修饰

    3.1static关键字的特点

    1. 访问静态成员的方式

      //通过类访问 (推荐)
      Student.nationality = "中国";
      
      //通过对象访问静态成员 (不建议)
      s1.nationality = "中国";
      
    2. 静态变量属于类的,不属于具体的对象

      	public Student(String name, int age, String address, String nationality) {
      		this.name = name;
      		this.age = age;
      		this.address = address;
      		Student.nationality = nationality;
      		//this.nationality = nationality;
          	//The static field Student.nationality should be accessed in a static way
              //虽然对象也可以调用静态变量,但系统建议使用类对静态变量进行调用
      	}
      
    3. 静态变量又称:“类变量” ( 因为属于类的 ),没有使用static的变量为:非静态变量

    4. 静态变量可以修饰成员变量,也可以修饰方法(多用于工具类编写Arrays Object【所有成员变量&构造方法私有】外界只能调用)

    5. 静态环境下不能够访问非静态变量,非静态环境下可以访问静态变量

              public static void staticMethod() {
                  System.out.println("staticMethod");
                  // System.out.println(name);
                  //报错:Cannot make a static reference to the non-static field nam
              }
              //1.static的方法在加载class时已经完成了,在创建对象之前
           	//2.static是类,而非静态变量是对象,用static引用对象,系统不知道引用明确的对象
      
    6. 静态修饰的变量在类加载的时候加载到方法区的静态区

    7. static还可以修饰 代码块 和 类(内部类)

    展开全文
  • 1.关键字private public protected均用来进行类的访问控制 2.区别简述 private:除了类本身以及友元函数可访问外,均不可访问(类对象,派生类以及派生类对象),“我的私人空间,我和我朋友可以访问” public:...

    一、简介

    1.关键字private public protected均用来进行类的访问控制

    2.区别简述

    private:除了类本身以及友元函数可访问外,均不可访问(类对象,派生类以及派生类对象),“我的私人空间,我和我朋友可以访问”

    public:均可自由访问,“某广场,均可访问”

    protected:介于private与public之间,除了类本身以及友元函数可访问外,还由派生类可以访问 “我的家,我和我的儿女可以访问”

    二、表格陈述

    权限 类内部 类对象 子类(派生类) 友元函数
    private 可访问 不可访问 不可访问 可访问
    public 可访问 可访问 可访问 可访问
    protected 可访问 不可访问 可访问 可访问

     

    展开全文
  • private关键字:是一个权限修饰符;用于修饰成员(成员变量和成啊元函数);...解决办法:用关键字private将需要保护的成员变量进行修饰,修饰后的成员变量只能在当前类中引用;public class Person {...

    private关键字:

    是一个权限修饰符;

    用于修饰成员(成员变量和成啊元函数);

    被私有化的成员只能在本类中有效;

    常用之一:

    将成员变量私有化,对外提供对应的set,get方法对其进行访问。提高对数据访问的安全性;

    问题:定义Peron的age时无法控制输入是否合理;

    解决办法:用关键字private将需要保护的成员变量进行修饰,修饰后的成员变量只能在当前类中引用;

    public class Person {

    String name;

    private int age;

    public void setAge(int num){

    if(num<0)

    System.out.println("请重新输入!");

    else

    age = num;

    }

    public int getAge(){

    return age;

    }

    public void show(){

    System.out.println("name:"+name+":age:"+age);

    }

    }

    public class PrivateDemo {

    public static void main(String[] args) {

    Person person = new Person();

    person.name = "凌云";

    person.setAge(-20);

    person.show();

    person.setAge(18);

    person.show();

    }

    }

    展开全文
  • 关键字private===============================================这个程序中不能访问 num添加个公共的访问方法才可以,如下:对于私有方法,也是一样的道理。不过private一般不修饰方法。===========================...
  • 1.private关键字 private关键字特点  * a:是一个权限修饰符  * b:可以修饰成员变量和成员方法  * c:被其修饰的成员只能在本类中被访问 封装和private的应用:  * A:把成员变量用private修饰  * B:提供对应的...
  • class Arrary{ static int a=10; static int b=20; int c; public static void add(){ c=a+b; System.out.println(c); } } public class StaticDemo { public static void main(String[] args) { ...}
  • 关键字】 【private】 是一个权限的修饰符 可以修饰成员变量和方法 被private修饰的成员只能在本类中才能访问。 【static 】 静态 随着类的加载而加载 优先于对象存在 被类的所有对象共享 [static...
  • private String variety; private int age; private String color; public void setVariety(String zl){ variety=zl; } public void setAge(int nl){ age=nl; } public void setColor(String ys){ color...
  • private表示私有,私有的意思就是除了class自己之外,任何人都不可以直接使用,是对访问权限限制的最窄的修饰符 3. protected protected对于子女、朋友来说,就是public的,可以自由使用,没有任何限制,而对于...
  • 第一:private, public, protected 访问标号的访问范围。 private:只能由1.该类中的函数、2.其友元函数访问。 不能被任何其他访问,该类的对象也不能访问。 protected:可以被1.该类中的函数、2.子类的函数、...
  • this关键字 ...private关键字 private的基本概念 私有的,关键字 , 一种访问权限修饰符,用来修饰类的成员 他一般是封装中封装的比较彻底的方式语句。 起到封装的效果 特点 被修饰的成员只能在本类
  • Private关键字

    2019-12-02 18:10:35
    Private关键字 Private可以保护数据的安全性,使该数据无法直接访问,但可以使用Setter Getter方法进行间接访问,给数据加上限制条件,保证数据的安全正确。 下面就让我们通过一个实例来体会一下Private关键字的用法...
  • 1.封装性在java中的体现:方法就是一种封装关键字private也是一种封装封装就是将一些细节信息隐藏起来,对于外界不可见问题描述:定义年龄的时候,无法阻止不合理的数值被设置进来解决方案:用private关键字将需要...
  • 封装与private关键字

    2020-03-02 18:02:51
    封装与private关键字 private关键字 就是一个权限关键字 public protected 默认不写 private关键字 表示私有权限 该成员变量或成员函数只能够在类中被访问 外界不可访问 setter 修改器 是一个Java当中的规范 主要...
  • 封装和private关键字

    2020-02-28 20:02:56
    1.private关键字 private关键字:是一个权限关键字(表示私有权限) 和public ,protected,默认不写,这三个是一样的 一旦成员变量加了private关键字,只能在当前类中访问,一旦出了当前类则就修改不行了获取也...
  • 10.public关键字private关键字 public 修饰符,公共的谁都可以访问。 private修饰符,私有的,只有自己可以访问 // 属性 public String name; // 同一个工程中所有的类型都能访问(调用) protected int hight;...
  • 2、关键字private也是一种封装 private关键字 定义一个Person类其中含有age是private属性的,目的在于判断不符合要求的赋值。 package demo01; public class Person { private int age; String name; ...
  • private关键字

    2019-01-09 14:30:00
    Student.java /* * 学生类 * * 通过对象直接访问成员变量,会存在数据安全问题 ... * 这个时候,我们就想... * private关键字 * private: * 是一个修饰符 * 可以修饰成员变量,也可以修饰成员方法 * ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,889
精华内容 5,955
关键字:

关键字private