面向对象——static（静态）&Math类&自定义工具类&代码块

妖狐艹你老母 2024-03-27 11:29 101阅读 0赞

**目录**

static（静态）关键字

static的注意事项

static的优点和缺点

应用场景

自定义工具类

代码块

### static（静态）关键字 ###

*  static是一个修饰符，用于修饰成员（成员变量 、成员方法）
 *  static的特点

–**随着类的加载而加载**

–优先于对象存在

–**被类的所有对象共享**

–可以被类名调用

案例：

package com.demo01;
    /*
     * static:是一个关键字，用于修饰成员变量和成员方法
     * static的特点：
     * 			被所有的对象所共享
     * 			可以使用类名调用
     * 			静态的加载优先于对象
     * 			随着类的加载而加载
     * 
     */
    public class StaticDemo {
    	public static void main(String[] args) {
    		Person.graduateFrom = "湖南大学";
    		
    		Person p = new Person();
    		p.name = "段誉";
    		p.age = 18;
    		//p.graduateFrom = "湖南大学";
    		p.speak();
    		
    		Person p2 = new Person();
    		p2.name = "萧峰";
    		p2.age = 20;
    		//p2.graduateFrom = "湖南大学";
    		p2.speak();
    		Person.think();
    	}
    }
    
    class Person {
    	String name;
    	int age;
    	static String graduateFrom;//毕业院校
    	
    	public void speak() {
    		System.out.println(name + "---" + graduateFrom);
    	}
    	
    	public static void think() {
    		System.out.println("思考");
    	}
    }

分析：先Person.graduateFrom = "湖南大学";才创建一个类对象，静态得成员变量应该用一种静态得方法来访问，用Person 来访问，不应该用p.得方式来访问。

### static的注意事项 ###

静态方法：

\* 1、可以调用静态的成员变量

\* 2、可以调用静态的成员方法

\* 3、不可以调用非静态成员变量

\* 4、不可以调用非静态成员方法

\* 静态方法只能调用静态的成员

非静态方法：

\* 1、可以调用静态的成员变量

\* 2、可以调用静态的成员方法

\* 3、可以调用非静态的成员变量

\* 4、可以调用非静态的成员方法

\* 静态的方法中是否this这个对象？没有的

**分析：**静态方法是属于类的，而非静态的成员，不管是成员变量，还是成员方法，他是属于对象的，静态方法在调用类的时候已经初始化好了，静态如果可以调用非静态成员时，会发现他是不属于类的，是属于对象的，现在还没有对象呢，那怎么办呢？所以相互矛盾，所以静态是无法调用非静态的，反过来，非静态是可以调用静态成员变量。我们在待用静态时，是已经声明了对象，才调用的。

package com.demo01;
    /*
     * static的注意事项：
     * 			静态方法：
     * 				1、可以调用静态的成员变量
     * 				2、可以调用静态的成员方法
     * 				3、不可以调用非静态成员变量
     * 				4、不可以调用非静态成员方法
     * 				静态方法只能调用静态的成员
     * 			非静态方法：
     * 				1、可以调用静态的成员变量
     * 				2、可以调用静态的成员方法
     * 				3、可以调用非静态的成员变量
     * 				4、可以调用非静态的成员方法
     * 		
     * 	静态的方法中是否this这个对象？没有的
     * 				
     * 
     */
    public class StaticDemo2 {
    	public static void main(String[] args) {
    		Student.graduateFrom = "湖南大学";//1、可以调用静态的成员变量
    		//Student.study();
    		Student s = new Student();
    		s.eat();
    	}
    }
    
    
    class Student {
    	String name;
    	int age;
    	
    	//
    	static String graduateFrom;//毕业院校
    	
    	public static void study() {
    		//System.out.println(graduateFrom);
    		sleep();//可以调用静态的成员方法
    		
    		//System.out.println(name);//不可以调用非静态成员变量
    		
    		//eat();//不可以调用非静态成员变量,这样是错误得
    		
    	}
    	
    	public static void sleep() {
    		System.out.println("sleep");
    		
    	}
    	
    	public void eat() {
    		System.out.println("eat");
    		
    		System.out.println(graduateFrom);
    		sleep();
    		
    		
    	}
    	
    }

### static的优点和缺点 ###

*  static的优点

–对对象的共享数据提供单独空间的存储，节省空间，没有必要每一个对象都存储一份

–可以直接被类名调用,不用在堆内存创建对象

*  static的弊端

–访问出现局限性。（静态虽好，但只能访问静态）

### 应用场景 ###

*  Math 类包含用于执行基本数学运算的方法。数学操作常用的类。
 *  Math类的使用

–没有构造方法，我们如何使用呢？

*  Math类要掌握的功能

–字段：PI

–方法：abs ，max，min ，pow，ceil，floor，round,random

package com.demo02;
    
    public class MathDemo {
    	public static void main(String[] args) {
    		//Math:包含了一些基本的数学运算方法
    		//static double PI  
    		System.out.println(Math.PI);
    		//
    		//static double abs(double a)  :返回绝对值
    		System.out.println(Math.abs(15.67));
    		System.out.println(Math.abs(-0.10));
    		
    		//static double ceil(double a) 天花板   向上取整
    		System.out.println(Math.ceil(-2.1));
    		System.out.println(Math.ceil(1.6));
    		//static double floor(double a)  地板  向下取整
    		System.out.println(Math.floor(1.2));
    		System.out.println(Math.floor(-1.6));
    		
    		//static long round(double a)  ：四舍五入
    		System.out.println(Math.round(-1.2));
    		System.out.println(Math.round(1.6));
    		
    		//static double max(double a, double b) 
    		System.out.println(Math.max(3, 4));
    		
    		//static double pow(double a, double b) :返回第一个参数的第二个参数次幂
    		System.out.println(Math.pow(3, 4));
    		
    		//static double random() :返回一个随机数，大于零且小于一
    		System.out.println(Math.random());
    		
    		
    		 
    	}
    }

![bde5fc9bdc3e47c48c4417a74d8467dc.png][]

### 自定义工具类 ###

案例：

package com.demo03;
    
    /**
     * 数组工具类
     * @author (无限嚣张(菜菜))
     *
     */
    public class MyArrays {
    	private MyArrays() {} 
    	
    	/*
    	 * 返回数组中最大的元素
    	 * 
    	 */
    	public static int getMax(int[] arr) {
    		if(arr==null||arr.length==0) {
    			return 0;
    		}
    		int max = arr[0];//参照物
    		//遍历数组
    		for(int x = 1;x < arr.length;x++) {
    			if(arr[x] > max) {
    				max = arr[x];//替换参照物
    			}
    		}
    		
    		return max;
    	}
    	
    	
    	/*
    	 * 返回数组中指定参数的索引
    	 * 
    	 */
    	
    	public static int getIndex(int[] arr,int a) {
    		//遍历数组
    		for(int x = 0;x < arr.length;x++) {
    			if(arr[x] == a) {
    				return x;
    			}
    		}
    		
    		return -1;//如果查不到指定的参数，则返回-1
    	}
    }

package com.demo03;
    
    public class MyArraysDemo {
    	public static void main(String[] args) {
    		//MyArrays m = new MyArrays();
    		int[] arr = {3,5,8,10,1};
    		int max = MyArrays.getMax(arr);
    		System.out.println(max);
    		
    		int index = MyArrays.getIndex(arr, 8);
    		System.out.println(index);
    		
    		
    	}
    }

### 代码块 ###

*  在Java中，使用\{\}括起来的代码被称为代码块
 *  代码块分类

–局部代码块——存在于方法中，控制变量的生命周期（作用域），用完销毁

–构造代码块——提取构造方法中的共性，每次创建对象都会执行，并且在构造方法执行之前执行

–静态代码块——随着类的加载而加载，只加载一次，加载类时需要做的一些初始化，比如加载驱动

–同步代码块(多线程)

package com.demo04;
    
    public class BlockDemo {
    	public static void main(String[] args) {
    		
    		//局部代码块：存在于方法中，控制变量的生命周期（作用域），用完销毁
    		{
    			for(int x = 0;x < 10;x++) {
    				System.out.println("我爱Java");
    			}
    			int num = 10;
    		}
    		//System.out.println(num);
    		
    		Teacher t = new Teacher();
    		Teacher t2 = new Teacher("王老师",18);
    	}
    }
    
    class Teacher {
    	String name;
    	int age;
    	
    	//构造代码块：提取构造方法中的共性，每次创建对象都会执行，并且在构造方法执行之前执行
    	{
    		for(int x = 0;x < 10;x++) {
    			System.out.println("我爱Java");
    		}
    		System.out.println("我爱Java");
    	}
    	
    	//静态代码块：随着类的加载而加载，只加载一次，加载类时需要做的一些初始化，比如加载驱动
    	static {
    		System.out.println("我爱Java");
    	}
    	
    	public Teacher() {
    		System.out.println("我是无参空构造");
    	}
    	
    	public Teacher(String name,int age) {
    		System.out.println("我是有参构造");
    		
    		this.name = name;
    		this.age = age;
    	}
    	
    	
    }

> 分析：我们首先new一个无参的对象，进去以后执行局部代码块，输出10词我爱Java,num=10,运行完以后num就被删除了，我们new 一个teacher对象，首先执行的静态代码块，执行完以后，就执行构造代码块，执行完构造代码块才执行构造方法。

[bde5fc9bdc3e47c48c4417a74d8467dc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/3752e09a5734416ebc6d00506af1ed52.png