第九周总结

第九周总结

1.成员属性只用在执行构造方法的时候才会赋值（默认值），成员变量在执行构造方法后，会系统分配一个值

package example;

class Fa
{
    public int id;//未赋值的成员变量
}
public class TestRun
{
    public static void main(String[] args)
    {
        Fa f = new Fa();//无参构造创建实例化对象
        S(f.id);//输出没有赋值的id
    }
    public static void S(String a)
    {
        System.out.println(a);
    }
    public static void S(int a)
    {
        System.out.println(a);
    }
}

2.同样的对于有参构造而言，系统在执行构造方法的时候同样会默认赋值一个数给id，然后再将传入的参数赋值给id

3.对于mian方法而言，未初始化的变量就是未初始化，不能被调用

final的用法

1.final用在局部变量之前修饰意味着该局部只能被赋值一次

2.当final修饰类时，这个类不能被继承。

3.当final修饰成员变量（包括引用数据类型）时，只能显示赋值（要么在声明后赋值，要么在构造方法里赋值）且只能赋值一次，无参构造不会默认赋值为0。final修饰的成员变量如果会有默认值的话，那么它就是可以修改的，主要不符合final的定义和作用，所以final没有默认值。

4.final修饰的成员变量必须在构造方法结束之前赋值，值得注意的是，如果没有在定义的时候直接赋值的话，那么有参构造和无参构造里面都要有对id赋值，很简单，如果只在有参里赋值的话，调用无参的话，在构造方法结束后，还是没有对这个成员变量赋值的

package example;

class Fa
{
    public final int id ;//未赋值的成员变量
    Fa(){
        id = 10;//无参构造赋值
    }
    Fa(int id)
    {
        this.id = id;//有参构造赋值
    }
}
public class TestRun
{
    public static void main(String[] args)
    {
        final int i=10;

        Fa f = new Fa();
        S(f.id);
        //S(i);
    }
    public static void S(String a)
    {
        System.out.println(a);
    }
    public static void S(int a)
    {
        System.out.println(a);
    }
}

5.如果final修饰的是引用数据类型的话，那么指代表它的指向的对象不可改变。即它指向的物理地址只能赋值一次，但final限制的仅仅是那个引用数据类型的变量，对于它指向的对象而言，对象的所有未被final修饰的成员属性都是可以更改的

package example;

class Fa
{
    public  int id ;//未赋值的成员变量
    Fa(){
        id = 10;
    }
    Fa(int id)
    {
        this.id = id;
    }
}
public class TestRun
{
    public static void main(String[] args)
    {
        final int i=10;

       final Fa f = new Fa();
       Fa c = new Fa();
       f = c;
        //S(i);
    }
    public static void S(String a)
    {
        System.out.println(a);
    }
    public static void S(int a)
    {
        System.out.println(a);
    }
}

package example;

class Fa
{
    public  int id ;//未赋值的成员变量
    Fa(){
        id = 10;
    }
    Fa(int id)
    {
        this.id = id;
    }
}
public class TestRun
{
    public static void main(String[] args)
    {
        final int i=10;

       final Fa f = new Fa();
       Fa c = new Fa();
       f.id = 10000;
       S(f.id);
        //S(i);
    }
    public static void S(String a)
    {
        System.out.println(a);
    }
    public static void S(int a)
    {
        System.out.println(a);
    }
}

抽象类

1.编程面向抽象，不面向具体

2.抽象类的意义在于多态，父类型引用指向子类型对象

abstract：抽象类没有实例化对象，通俗地讲，就是不能new，但它一定有构造方法，以为子类要继承它，必须刻画出他的特征才能被继承

有abstract修饰的方法，不能有方法体（抽象方法，花括号都没有），且抽象方法只能出现在抽象类中