static总结
static:
* static静态的,是一个关键字,用来修饰成员变量或者成员方法;
* 特点如下:
* 1. 被static修饰的成员,属于类成员,是类的一部分.
* 2. 被static修饰的成员变量,属于共享数据,一个地方改变了,在另外的地方访问也就变了.
*
* 修饰成员变量的格式: static 数据类型 变量名;
* 修饰成员方法的格式: public static void method(参数){...}
package package02static;
public class Person {
// 成员变量
String name;
int age;
// 静态成员变量
static String country = "中国";
// 成员方法
public void methodNormal(){
System.out.println("普通的成员方法");
}
// 静态成员方法
public static void methodstatic(){
System.out.println("静态成员方法");
}
}
* 如何使用static修饰的内容
* 1. 方式一: 使用类名称类访问; * 类名称.成员变量 * 类名称.成员方法();
* 2. 方式二: 使用对象名访问;(不推荐的) * 对象名.成员变量 * 对象名.成员方法();
* 注意点:
* 被static修饰的内容属于类的一部分,应该使用类名称访问
* 静态的内容和非静态的内容如何进行相互之间访问的问题:
* 1. 被static修饰的内容,可以理解成先人(随着类的加载而存在)
* 2. 非static修饰的内容, 可以理解成后人(随着对象的创建而存在)
*
* 特点:
* 1. static修饰的方法不能访问普通内容(非static修饰); 先人(李世明)不知道后人(习*平)
* 2. 非static方法,可以访问静态内容; 后人知道先人
如:
public class Person {
String name;
static int num;
public void methodNormal(){
System.out.println(name);
System.out.println(num);
methodStatic();
}
public static void methodStatic(){
// static修饰的方法不能访问普通内容(非static修饰); 先人(李世明)不知道后人(习*平)
//System.out.println(name);
//methodNormal();
}
}
(注意:) 1.被static修饰的方法可以看做是工具类
2.而被static修饰的变量可以被其他类共享
3.被final static修饰的变量可以看做为全局常量(因为值是共享的,且值是不变的)
(注意(难理解):)被static修饰的方法与不被static修饰的方法的区别:
类名.方法() 这是静态方法独有的方法调用格式,(静态的方法的调用:直接类名.方法名 )
如果在getFight方法中不加static,只能重新创建new对象,再调用方法.
package cn.itcast.test02;
/*
* 使用战士工厂根据传入的参数生产不同的战斗人类(警察和战士)，并让能战斗的人类进行战斗，战士战斗前需要武装后再进行战斗
提示: 把战斗功能抽取到接口中 ,把战斗人类通用的姓名放在抽象类中;
*/
public class Test01 {
public static void main(String[] args) {
Man jc = FightFactory.getFight(1);//类名.方法() 这是静态方法独有的方法调用格式
Man sd = FightFactory.getFight(2);
//向下转型,不能写成new FightFactory.getFight(1);
((JingCha)(FightFactory.getFight(1))).zhanDou();
//如果在getFight方法中不加static,只能重新创建new对象,再调用方法.
/*FightFactory f = new FightFactory();
f.getFight(1);*/
JingCha jc1 = (JingCha) jc;
Soldier sd1 = (Soldier) sd;
jc1.zhanDou();
sd1.zhanDou();
}
}
package cn.itcast.test02;
public class FightFactory {
public static Man getFight(int i){//如果不加static,main方法会报错.
if (i==1) {
return new JingCha("张三");
}
if (i==2) {
return new Soldier("王五");
}
return null;
}
}
* 在多态的体现形式下,访问静态内容和非静态内容的特点:
* 非静态内容:
* 成员变量: 编译看左边, 运行看左边
* 成员方法: 编译看左边, 运行看右边
*
* 静态内容:
* 成员变量: 编译看左边, 运行看左边
* 成员方法: 编译看左边, 运行看左边
public class Demo01StaticVariable {
public static void main(String[] args) {
// 非静态内容的访问
Animal ani = new Cat();
System.out.println(ani.name);//张三 编译看左边, 运行看左边
ani.method();// 编译看左边, 运行看右边
System.out.println("===========");
// 静态内容访问
System.out.println(ani.country);// 中国 编译看左边, 运行看左边
ani.methodstatic();// 编译看左边, 运行看左边
}
}
package package04static;
//动物类
public class Animal {
String name = "张三";
static String country = "中国";
public void method(){
System.out.println("Animal === method");
}
public static void methodstatic(){
System.out.println("Animal === methodstatic");
}
}
package package04static;
//猫类
public class Cat extends Animal {
String name = "李四";
static String country = "美国";
public void method(){
System.out.println("Cat === method");
}
public static void methodstatic(){
System.out.println("Cat === methodstatic");
}
}
结果: 张三 Cat === method =========== 中国 Animal === methodstatic
* 什么是静态代码块呢?
* 被static修饰的代码块称为静态代码块.
* 格式:
* static{
*
* }
*
* 特点:
* 1. 只要静态代码块所在的类被使用(不管以什么样的形式)马上就会执行, 并只会执行一次
* 2. 静态代码块一般可以用来加载驱动驱动信息,比如: 数据库驱动
*
* 构造代码块: 只要创建对象就会执行,一般情况下可以给final成员变量去赋值.还可编写构造方法中共有的代码
* 构造方法: 只要创建对象就会执行, 创建对象的时候调用
package package05staticBlock;
/*
* 面试题:
* 说出以下的代码执行的流程;
* A-D-E-F-B-C
* A-D-B-E-C-F
* A-D-B-C-E-F 正确
*
* 执行流程:
* 1. 父类静态代码块
* 2. 子类静态代码块
* 3. 父类构造代码块
* 4. 父类构造方法
* 5. 子类构造代码块
* 6. 子类构造方法
*
* 构造代码块:
*/
public class Demo02StaticPractice {
public static void main(String[] args) {
new Cat();
int a = 10;
System.out.println(a);
}
}
package package05staticBlock;
//动物类
public class Animal {
static{
System.out.println("A: Animal === 静态代码块");
}
{
System.out.println("B: Animal == 构造代码块");
}
public Animal(){
System.out.println("C: Animal == 构造方法");
}
public Animal(int a, int b){
}
public Animal(int a, float b, int c){
}
}
package package05staticBlock;
//猫类
public class Cat extends Animal {
static{
System.out.println("D: Cat === 静态代码块");
}
{
System.out.println("E: Cat == 构造代码块");
}
public Cat(){
System.out.println("F: Cat == 构造方法");
}
}
