目录
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());
}
}
自定义工具类
案例：
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对象，首先执行的静态代码块，执行完以后，就执行构造代码块，执行完构造代码块才执行构造方法。