java基本语法---面向对象--static和final关键字

1.static（静态）

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

2.静态变量

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

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

package cn.tedu.staticx;
 public class Static Demo1{
 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 Static Demo4{
 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 Static Text2{
 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 Static Text3{
 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 clas sFinalDemo2{
 }
 class FDemo{
 //保证类加载完成之前给值
 final static int i;//静态常量
 //静态代码块可以给静态变量进行初始化
 static{
 i=2;
 }
 /*//属性--成员变量
 //保证对象创建完成之前给值
 final int i;
 //来一个构造代码块
 {
 i=2;
 }
 //保证每个构造方法都要赋值
 public FDemo(){
 i=2;
 }
 public FDemo(intj){
 i=j;
 }*/
 }

3.最终方法

支持重载
不支持重写

package cn.tedu.finalx;
 public class Final Demo3{
 }
 class FDemo1{
 public final void n(){}
 //支持重载
 public final void n(inti){}
 }
 class FDemo2 extends FDemo1{
 //@Override
 //不支持重写
 //public final void n(){}
 }

4.最终类

可以继承别的类不能不能被别的类继承

package cn.tedu.finalx;
 public class FinalDemo4{
 }
 //最终类不能被继承
 final class FDemo3{}
 //最终类可以继承别的类
 //class FDemo4 extends FDemo3{}