• Day7 访问权限


    构造者模式思想

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

     1 package day7;//声明一个程序包
     2 class Employee{
     3     private String name;
     4     private int no;
     5     private int age;
     6     private String sex;
     7     private String address;
     8     //alt + shift + s
     9     
    10     public int getNo() {
    11         return no;
    12     }
    13 /*    public Employee() {
    14     }*/
    15 
    16     public Employee setNo(int no) {
    17         this.no = no;
    18         return this;
    19     }
    20     public String getName() {
    21         return name;
    22     }
    23     public Employee setName(String name) {
    24         this.name = name;
    25         return this;
    26     }
    27     public int getAge() {
    28         return age;
    29     }
    30     public Employee setAge(int age) {
    31         this.age = age;
    32         return this;
    33     }
    34     public String getSex() {
    35         return sex;
    36     }
    37     public Employee setSex(String sex) {
    38         this.sex = sex;
    39         return this;
    40     }
    41     public String getAddress() {
    42         return address;
    43     }
    44     public Employee setAddress(String address) {
    45         this.address = address;
    46         return this;
    47     }
    48 /*    public Employee(String name, int no, int age, String sex, String address) {
    49         this.name = name;
    50         this.no = no;
    51         this.age = age;
    52         this.sex = sex;
    53         this.address = address;
    54     }*/
    55     public void show() {
    56         System.out.println(no+","+name+","+age+","+sex+","+address);
    57     }
    58 }
    59 public class TestEmployee {
    60 
    61     public static void main(String[] args) {
    62 /*        Employee tom = new Employee("Tom",12,33,"男","上海");
    63         tom.show();*/
    64         /*构造者模式思想 :进行 初始化。解决了 多个构造器重载 ,构造器 参数过多 记不住的情况*/
    65         Employee tom = new Employee().setNo(11).setAddress("北京").setAge(33).setSex("").setName("Tom");
    66         tom.show();
    67     }
    68 
    69 }
    View Code

    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 数据类型 变量名;
    }
     1 package day7;
     2 class Child{
     3 static int count;
     4 }
     5 public class TestChild {
     6 public static void main(String[] args) {
     7 Child a = new Child();
     8 Child b = new Child();
     9 //count被所有对象共享
    10 a.count ++;
    11 b.count ++;
    12 System.out.println(a.count);
    13 System.out.println(b.count);
    14 }
    15 }
    View Code

     

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

    静态变量(类变量)

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

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

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

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

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

    静态变量的应用场合

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

    静态块

    在类中定义

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

    局部代码块

    定义:在方法中定义

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

    静态方法

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

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

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

    应用场合

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

    静态导入

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

    格式

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

    单例模式

    对类只能创建一个对象

    饿汉模式

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

     1 package day7;
     2 class Window{
     3     private static Window win = new Window();
     4     private Window() {
     5     }
     6     public static Window getInstance() {
     7     return win;
     8     }
     9 }
    10 public class TestWindow {
    11     public static void main(String[] args) {
    12         Window win = Window.getInstance();
    13         Window win1 = Window.getInstance();
    14         System.out.println(win);
    15         System.out.println(win1);
    16     }
    17 }                
    View Code

    输出结果

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

    懒汉模式

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

     1 package day7;
     2 class Window{
     3     private static Window win = null;
     4     private Window() {
     5 }
     6 public static Window getInstance() {
     7     if(win == null) {
     8         win = new Window();
     9     }
    10     return win;
    11     }
    12 }
    13 public class TestWindow {
    14 public static void main(String[] args) {
    15 Window win = Window.getInstance();
    16 Window win1 = Window.getInstance();
    17 System.out.println(win);
    18 System.out.println(win1);
    19 }
    20 }    
    View Code

    返回结果

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

    API之Math类

    常用方法

     1 package day7;
     2 public class TestMath {
     3 public static void main(String[] args) {
     4 // Math
     5 System.out.println(Math.abs(‐33.4));//33.4
     6 //大于等于44.6的最小整数‐》double
     7 System.out.println(Math.ceil(44.6));//45.0
     8 //小于等于44.6的最大整数‐》double
     9 System.out.println(Math.floor(44.6));//44.0
    10 //四舍五入为一个long数字
    11 System.out.println(Math.round(44.6));//45
    12 //求几次方的值
    13 System.out.println(Math.pow(3,2));//9.0
    14 //double [0.0,1.0)
    15 double n = Math.random();
    16 System.out.println(n);
    17 //1‐10
    18 //[最小值,最大值]
    19 //(int)(Math.random()*(最大值‐最小值+1)+最小值)
    20 int num = (int)(Math.random()*(10‐1+1)+1);
    21 System.out.println(num);
    22 }
    23 }
    View Code

    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));
  • 相关阅读:
    svn:ignore 设置忽略文件
    Css让文字自适应Table宽度[转]
    自学python笔记
    java代码中添加log4j日志
    maven多模块项目搭建
    js || 与&&
    java内存溢出和tomcat内存配置
    xsl:for-each中引用循环外全局变量
    quartz启动两次(tomcat)
    pymysql简单封装
  • 原文地址:https://www.cnblogs.com/qingyunzong/p/8119822.html
Copyright © 2020-2023  润新知