java-static（静态）、final（最终）-day09

static（静态）

1.概念

关键字 、修饰符 变量 、方法、代码块、内部类

2.静态变量

静态变量随着类的加载（方法区的静态区）而加载到方法区的静态区、与l类同级
也叫类变量，通过类名形式来调用 静态属性变量也可以通过对象来调用静态变量，
存储在方法区时会默认给静态变量赋予系统默认初始值。；类产生的对象共享一个静态变量。
看静态变量是否需要被所有的对象共享，如果需要共享就设置成静态变量。

方法里可不可以定义静态变量？静态变量与类同级、只有方法被调用时里面的内r容才能出现、
前后矛盾、不能定义

package cn.tedu.staticx;

public class StaticDemo1 {
public static void main(String[] args) {
//创建Person类的对象
Person p=new Person();
p.name=“郭靖”;
p.age=19;
p.gender=‘男’;
Person p1=new Person();
p1.name=“黄蓉”;
p1.age=18;
p1.gender=‘女’;
//输出
System.out.println(p.toString());
System.out.println(p1.toString());

}

}
//定义代表人的类
class Person{
//属性
String name;
int age;
static char gender;

//定义方法来输出对象的属性值
public String toString(){
    return this.name+","+this.age+","+this.gender;
}

}

3.静态方法

静态方法会随着类的加载而加载到方法区的方法区的静态区。 与类同级也叫类方法
，通过类名形式来调用发也可以通过对象调用。静态区不会对静态
Java中静态信息只能直接使用静态信息，非静态可以直接使用静态和非静态信息。

支持重载？ —支持重载
支持重写？不支持重写 静态方法与类同级，重写针对是对象级别不一样 静态方法没有提供重写。
父子类中要么出现方法签名一致的都是非静态方法（重写）要么都是静态方法（没有重写）
Arrays.sort()、Arrays.copyOf()、System.arraycopy()、Arrays.toString()
package cn.tedu.staticx;

public class StaticDemo3 {
public static void main(String[] args) {
//向上造型
SDemo s=new SDemo1();
//向上造型对象执行的是子类方法证明发生重写
s.m();
}

}
class SDemo{
public void m(){
System.out.println(1);
}
public static void n(){}
}
class SDemo1 extends SDemo{
//注解—给计算机看的注释
// @Override表面下面的方法是重写方法
@Override
public void m(){
System.out.println(2);
}
//加注解在报错说明不是重写方法
//静态方法与类同级
//重写—运行时多态—针对的是对象—和对象一个级别
//静态方法就没有提供重写
//@Override
public static void n(){}
}

4.静态代码块

a、可以给静态变量进行初始化
b、预先加载资源
c、随着类的加载只加载一次
d、static修饰的静态信息都只能加载一次·
e、父子类执行顺序（父类静态信息—字类静态信息–父类对象级别信息–子类对象级别信息）
package cn.tedu.staticx;

public class StaticDemo4 {
public static void main(String[] args) {
//匿名对象
new SDemo2();
new SDemo2();
}
}

//
class SDemo2{
static int i;//静态变量
//静态代码块
//给静态变量进行初始化
//预先加载资源
//因为静态代码块随着类的加载而加载，但是类只加载一次
static {
i=1;
System.out.println(“静态代码块”);
}
{
System.out.println(“构造代码块”);
}
public SDemo2(){
System.out.println(“构造方法”);
}
}

package cn.tedu.staticx;

import javax.crypto.spec.PSource;

public class StaticText2 {
public static void main(String[] args) {
System.out.println(new STDemo().i);
}
}

class STDemo{
/* int i=5;
{
i+=1;
}*/
{
i=1;
}
int i=3;
}

package cn.tedu.staticx;

public class StaticText3 {
public static void main(String[] args) {
System.out.println(new STDemo1().x+","+new STDemo1().y);
}
}

class STDemo1{
//StackOverflowError—栈溢出错误
/* STDemo1 st=new STDemo1();//属性
int age=1;
static int x;
static int y=3;
public STDemo1(){
x++;
y++;
}/
/
加载 执行第一步 执行第二步 执行第三步
* st=null st=0x01 st=0x01 st=0x01
x=0 x=1 x=1 x=1
y=0 y=1 y=1 y=3
*
* */
static STDemo1 st=new STDemo1();
static int x;
static int y=3;
public STDemo1(){
x++;
y++;
}
}

final（最终）

1.概念

关键字、修饰符 数据、方法、类

2.最终值

当final修饰基本类型数据时， 保证值不能改变
当final修饰引用数据类型时，地址值不能改变
当final修饰成员变量时，保证对象创建完成之前给值
当final修饰静态常量时（静态常量)，保证类加载完成之前给值
package cn.tedu.finalx;

public class FinalDemo1 {
public static void main(String[] args) {
//当引用指向数据可以改变时表面是变量
int x=1;
//当final修饰基本类型数据时保证值不能改变
//当引用指向数据不能改变时就是常量
final int i=1;//自定义常量
int j=i+1;
//i++;

    //当final修饰引用类型数据时是地址值不能改变
    final int[] arr={1,2,3};
    arr[0]=10;
    //arr=new int[3];
    //数组长度是被final修饰
    //arr.length=10;

}

}

package cn.tedu.finalx;

public class FinalDemo2 {

}
class FDemo{

 //保证类加载完成之前给值
 final static int i;//静态常量

 //静态代码块可以给静态变量进行初始化
 static {
     i=2;
 }


/*//属性--成员变量
//保证对象创建完成之前给值
final int i;

//来一个构造代码块
{
    i=2;
}

//保证每个构造方法都要赋值
public FDemo(){
    i=2;
}
public FDemo(int j){
    i=j;
}*/

}

3.最终方法

支持重载
不支持重写
package cn.tedu.finalx;

public class FinalDemo3 {

}

class FDemo1{
public final void n(){}
//支持重载
public final void n(int i){}
}
class FDemo2 extends FDemo1{
//@Override
//不支持重写
//public final void n(){}
}

4.最终类

可以继承别的类但是不能被别的类继承
package cn.tedu.finalx;

public class FinalDemo4 {
}
//最终类不能被继承
final class FDemo3{}
//最终类可以继承别的类
//class FDemo4 extends FDemo3{}

抽象类、接口、内部类、包