亲宝软件园·资讯

展开

Java访问权限 Java访问权限原理与用法详解

扎心了,老铁 人气:0

本文实例讲述了Java访问权限原理与用法。分享给大家供大家参考,具体如下:

构造者模式思想

进行初始化,解决了多个构造器重载,构造器参数过多记不住的情况。

package day7;//声明一个程序包
class Employee{
  private String name;
  private int no;
  private int age;
  private String sex;
  private String address;
  //alt + shift + s
  
  public int getNo() {
    return no;
  }
/*  public Employee() {
  }*/

  public Employee setNo(int no) {
    this.no = no;
    return this;
  }
  public String getName() {
    return name;
  }
  public Employee setName(String name) {
    this.name = name;
    return this;
  }
  public int getAge() {
    return age;
  }
  public Employee setAge(int age) {
    this.age = age;
    return this;
  }
  public String getSex() {
    return sex;
  }
  public Employee setSex(String sex) {
    this.sex = sex;
    return this;
  }
  public String getAddress() {
    return address;
  }
  public Employee setAddress(String address) {
    this.address = address;
    return this;
  }
/*  public Employee(String name, int no, int age, String sex, String address) {
    this.name = name;
    this.no = no;
    this.age = age;
    this.sex = sex;
    this.address = address;
  }*/
  public void show() {
    System.out.println(no+","+name+","+age+","+sex+","+address);
  }
}
public class TestEmployee {

  public static void main(String[] args) {
/*    Employee tom = new Employee("Tom",12,33,"男","上海");
    tom.show();*/
    /*构造者模式思想 :进行 初始化。解决了 多个构造器重载 ,构造器 参数过多 记不住的情况*/
    Employee tom = new Employee().setNo(11).setAddress("北京").setAge(33).setSex("男").setName("Tom");
    tom.show();
  }

}

package day7;//声明一个程序包,必须放在文件的第一行

层次结构

package 父包[.子包.······];
包名:小写字母;通常是域名反转.部门名.项目名

包的好处

1.管理类和接口
2.防止命名冲突
3.封装,通过权限的控制,更好的

不同程序包下的类的方法访问方式

1.导入程序包

import b.Exam2;//导入b包下的类型Exam2
import b.*;//不能导入子包
import b.c.Exam3;//导入子包下的类型

2.用完全限定命名的方式

b.Exam2 e2 = new b.Exam2();

注意:两个包下有相同的类型,必须用完全限定命名的方式进行。

访问修饰符

Java将类成员的可见度分为四个种类:

创建类的时候只有两种:public和默认

static

static是一个修饰符
应用:可以用于修饰属性,方法,块,类
静态变量

class 类名{
//静态成员变量,类变量
public static 数据类型 变量名;
}

package day7;
class Child{
static int count;
}
public class TestChild {
public static void main(String[] args) {
Child a = new Child();
Child b = new Child();
//count被所有对象共享
a.count ++;
b.count ++;
System.out.println(a.count);
System.out.println(b.count);
}
}

 

静态变量随着类的创建的而存在,优先于对象存在。

静态变量(类变量)

属于类的,被所有对象所共享,优先于对象而存在的。
使用

类名.静态变量名
对象名.静态变量名//少用,容易混淆

静态变量和实例变量的区别

1.静态:类加载的时候就加载了,就创建了,就分配空间默认初始化了

实例:对象创建的时候,才能创建;
2.静态:属于类的,存在于方法区中的。
实例:属于对象。存在于堆中。
3.静态:声明周期很长,类销毁的时候,才回释放。
实例:对象销毁,会释放。

静态变量的应用场合

当数据共享时,使用。
当不需要对象,或无法创建对象时使用。

静态块

在类中定义

static{
  作用:初始化类的,给类变量初始化,静态变量
}

局部代码块

定义:在方法中定义

public void show(){
  {
    局部代码块
    作用:用来控制局部变量生命周期和使用范围。
  }
}

静态方法

静态方法中只能访问静态成员。
静态方法中不能使用this,super关键字。super可能访问到非静态的成员。

静态方法和实例方法的区别

1.静态:属于类,用类名直接调用
实例: 属于对象调用。
2.静态:只能直接访问静态成员(静态变量,静态方法)
实例:可以直接访问静态的和非静态的
3.静态:不能使用this,super。
实例:可以使用this,super。

应用场合

当不用创建对象访问,形式简单或者不能创建对象,那么就要用静态的方法了

静态导入

导入的是类中的静态成员,导入之后可以直接使用。

格式

import static 包名.类名.静态变量名(方法);

单例模式

对类只能创建一个对象

饿汉模式

类加载时,静态变量就存储了一个对象

package day7;
class Window{
  private static Window win = new Window();
  private Window() {
  }
  public static Window getInstance() {
  return win;
  }
}
public class TestWindow {
  public static void main(String[] args) {
    Window win = Window.getInstance();
    Window win1 = Window.getInstance();
    System.out.println(win);
    System.out.println(win1);
  }
}

输出结果

day7.Window@7852e922
day7.Window@7852e922

懒汉模式

类加载时,没有指定对象,只有在应用的时候才去创建对象,多线程的环境时,推荐使用饿汉式,因为是线
程安全的。

package day7;
class Window{
  private static Window win = null;
  private Window() {
}
public static Window getInstance() {
  if(win == null) {
    win = new Window();
  }
  return win;
  }
}
public class TestWindow {
public static void main(String[] args) {
Window win = Window.getInstance();
Window win1 = Window.getInstance();
System.out.println(win);
System.out.println(win1);
}
}

返回结果

day7.Window@7852e922
day7.Window@7852e922

API之Math类

常用方法

package day7;
public class TestMath {
public static void main(String[] args) {
// Math
System.out.println(Math.abs(‐33.4));//33.4
//大于等于44.6的最小整数‐》double
System.out.println(Math.ceil(44.6));//45.0
//小于等于44.6的最大整数‐》double
System.out.println(Math.floor(44.6));//44.0
//四舍五入为一个long数字
System.out.println(Math.round(44.6));//45
//求几次方的值
System.out.println(Math.pow(3,2));//9.0
//double [0.0,1.0)
double n = Math.random();
System.out.println(n);
//1‐10
//[最小值,最大值]
//(int)(Math.random()*(最大值‐最小值+1)+最小值)
int num = (int)(Math.random()*(10‐1+1)+1);
System.out.println(num);
}
}

Random类

Random rand1 = new Random(11);//11为随机种子
System.out.println(rand1.nextDouble());
Random rand2 = new Random(11);//
System.out.println(rand2.nextDouble());

随机种子相同时,相同随机次数输出结果相同。

Random rand3 = new Random(11);
//int范围内的整数
System.out.println(rand3.nextInt());
//[0,5)
System.out.println(rand3.nextInt(5));

希望本文所述对大家java程序设计有所帮助。

加载全部内容

相关教程
猜你喜欢
用户评论