1，static关键字
-可以修饰成员变量和成员方法，代码块
-特点：
被类的所有对象共享
也是我们判断要不要用static修饰的标准
随着类的加载而加载
优先于对象存在的
可以通过类名调用
本身也可以通过对象名调用
-静态内容也称为：类成员
package com.momo.demo;
/*
- 创建了多个对象，不同的人姓名年龄不一样，这个正常，
- 但是目前这几个人都是日本的，一样的国籍，每次创建对象的时候都要在堆内存中开辟空间存一样的值
- 有点浪费空间，怎么搞？
- 针对这种情况（多个对象有相同的成员变量值），java就提供了关键字 static
- */
public class Demo2 {
public static void main(String[] args) {
Person p1 = new Person("小泽",28,"日本");
p1.show();
//Person p2 = new Person("小井",30,"日本");
Person p2 = new Person("小井",30);
p2.show();
//Person p3 = new Person("小苍",35,"日本");
Person p3 = new Person("小井",30);
p3.show();
p3.country = "小日子"; p1.show(); p2.show(); p3.show();
}
}
class Person{
String name;
int age;
// String country;
static String country;
public Person(){}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public Person(String name, int age, String country) { this.name = name; this.age = age; this.country = country; } public void show(){ System.out.println("我叫："+name+",今年："+age+"岁，来自："+country); }
}
package com.momo.demo;
public class Demo3 {
public static void main(String[] args) {
/* Stu s = new Stu();
System.out.println(s.a);
System.out.println(s.b);
s.show(); s.fun();*/ // System.out.println(Stu.a);// 无法从静态上下文中引用非静态 变量 a System.out.println(Stu.b); // Stu.show(); 无法从静态上下文中引用非静态 方法 show() Stu.fun(); }
}
class Stu{
int a = 5;
static int b = 6;
public void show(){ System.out.println("aaa"); } public static void fun(){ System.out.println("bbb"); }
}
-注意事项：
在静态方法中不能使用this关键字(冲突)
静态是随着类的加载而存在，优先于对象存在
this是随着对象的创建才存在意义。
静态方法中只能访问静态的成员变量和静态的成员方法
静态方法：
成员变量：只能访问静态的
成员方法：只能访问静态的
非静态方法：
成员变量：可以访问静态，也可以访问非静态
成员方法：可以访问静态，也可以访问非静态
总结：静态只能访问静态 ，非静态可以访问静态也可以访问非静态。
package com.momo.demo;
public class Demo5 {
public static void main(String[] args) {
}
}
class Tea{
int a = 5;
static int b = 6;
public void show(){ System.out.println(a); System.out.println(b); method1(); method2(); } public static void fun(){ //System.out.println(a);无法从静态上下文中引用非静态 变量 a System.out.println(b); //method1();无法从静态上下文中引用非静态 方法 method1() method2(); } public void method1(){} public static void method2(){}
}
2，静态变量和成员变量的区别
-所属不同
静态变量属于类
成员变量属于对象
-内存位置不同
静态变量在静态区
成员变量在堆中
-出现时间不同
静态随着类的加载而存在，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
-调用方式不同
静态可以通过类名调用，也可以使用对象名调用
非静态只能使用对象名调用
3，main方法是静态的？
public static void main(String[] args){}
一，帮助文档
1，制作帮助文档
-写一个工具类
-对这个类加入文档注释
给类加，说明类是干什么的类
给成员加
成员变量，定义的是什么内容
成员方法，说明方法，参数，返回值
-命令： javadoc -d 路径 字段信息 文件名.java
javadoc -d . -author -version ArrayTools.java-->点代表当前路径
-idea工具：使用工具栏Tools--Genarate javaDoc
package com.momo.demo;
/**
- 这是数组操作类，有很多数组操作相关方法
- @author 67823540
- @version v1.0
- / public class ArrayTools { /*
- 私有构造方法，不让外界造对象
- / private ArrayTools(){} /*
- 这是一个遍历数组的方法
- @param arr 要遍历的数组，遍历后的格式[元素1，元素2，...]
- / public static void printArray(int[] arr){ System.out.print("["); for (int i = 0; i < arr.length; i++) { if(i==arr.length-1){ System.out.println(arr[i]+"]"); }else{ System.out.print(arr[i]+","); } } } /*
- 这是获取最大值的方法
- @param arr 要获取最大值的数组
- @return 数组中的最大值
- / public static int getMax(int[] arr){ int max = arr[0]; for (int i = 1; i < arr.length; i++) { if(arr[i]>max){ max = arr[i]; } } return max; } /*
- 这是查找指定元素第一次出现的索引，不存在返回-1
- @param arr 要查找的数组
- @param value 要查找的值
- @return 返回索引
- */
public static int getIndex(int[] arr,int value){
int index = -1;
for (int i = 0; i < arr.length; i++) {
if(arr[i]==value){
index = i;
break;
}
}
return index;
}
}
2，使用帮助文档(***)
-打开文档
-点击显示，点击索引，出现输入框
-输入我们要学习的类的名字，回车
-关于这个类的详细情况就会出现在右侧
-学习这个类
简单的看一下类的说明，了解这个类是干什么的类，别忘了看版本。
看需不需要导包，java.lang包以外的都要导包
看构造方法，看有没有显示构造方法
有显示，一般就需要创建对象使用
没显示，一般成员都是静态的/要么就会有一个静态方法可以获取该类对象
看成员变量，定义了什么内容
看成员方法，都有什么功能
看左：看是否静态，如果静态可以直接使用类名调用
看返回值，它返回什么类型，将来就可以用什么类型的变量来接收
看右：看方法名，名字不要写错
看参数列表，要什么给什么，要几个给几个
-练习：通过API帮助文档学习Math类，然后编写一个猜数字小游戏代码
规则：程序运行后会随机生成一个1-100之间的整数
提示用户输入一个数进行猜测
猜对：提示用户恭喜你猜中了
猜错：提示用户大了还是小了
附加规则1：给用户3次猜测机会，如果猜错提示用户还剩几次机会 当机会用完，提示用户游戏结束 附加规则2：给用户无限次机会，直到用户猜中为止，程序结束
二，代码块
1，在java中，单独使用{}括起来的代码被称为代码块
根据位置和声明的不同又分为：
局部代码块：在方法中出现的{}
作用：限定变量的生命周期，尽早释放，提高内存使用率
构造代码块：在类中方法外出现的{}
作用：把多个构造方法中相同的代码存放到一起，只写一次
每次调用构造方法时都会执行，是在构造方法执行前执行
静态代码块：在类中方法外出现的{}，加上static
static{}
作用：给类成员进行初始化的，在类加载的时候就执行，只执行一次
同步代码块(后面讲) synchronized (){}
-问：静态代码块，构造代码块，构造方法的执行顺序和次数？
静态代码块>构造代码块>构造方法
静态代码块 1次
构造代码块，每次调用构造方法的时候都会执行
package com.momo.demo;
public class Demo9 {
public static void main(String[] args) {
/* int a = 5;
// int b = 6;
//局部代码块
{
int b = 6;
System.out.println(b);
}
System.out.println(a);
// System.out.println(b);*/
CodeBlock c1 = new CodeBlock(); System.out.println(c1.a); CodeBlock c2 = new CodeBlock(123); System.out.println(c2.a); CodeBlock c3 = new CodeBlock(321,345); System.out.println(c3.a); System.out.println(CodeBlock.b); }
}
class CodeBlock{
int a;
static int b;
//静态代码块
static{
// a = 123;
b = 777;
System.out.println("静态代码块");
}
//构造代码块 { a = 666; System.out.println("构造代码块"); } //构造方法 public CodeBlock(){ System.out.println("无参构造"); // a = 666; } public CodeBlock(int aasa){ System.out.println("1参构造"); //a = 666; } public CodeBlock(int adf,int bdf){ System.out.println("2参构造"); //a = 666; } public void show(){ //局部代码块 { } }
}
package com.momo.demo;
public class Demo10 { static{ System.out.println("静态代码块2"); } { System.out.println("构造代码块2"); } Demo10(){ System.out.println("demo10的无参构造"); } public static void main(String[] args) { StuDemo s1 = new StuDemo(); System.out.println("main方法"); StuDemo s2 = new StuDemo(); } } class StuDemo{ static{ System.out.println("静态代码块1"); } { System.out.println("构造代码块1"); } StuDemo(){ System.out.println("无参构造方法"); } }
package com.momo.demo;
public class Demo10 {
static{
System.out.println("静态代码块");
}
{
System.out.println("构造代码块");
}
Demo10(){
System.out.println("demo10的无参构造");
}
public static void main(String[] args) {
StuDemo s1 = new StuDemo();
System.out.println("main方法");
StuDemo s2 = new StuDemo();
}
}
class StuDemo{
static{
System.out.println("静态代码块3");
}
static{
System.out.println("静态代码块1");
}
{
System.out.println("构造代码块1");
}
static{
System.out.println("静态代码块2");
}
{
System.out.println("构造代码块2");
}
{ System.out.println("构造代码块3"); } StuDemo(){ System.out.println("无参构造方法"); }
}