Java学习周记《四》

目录

toString方法的用法：

==和equals的区别：

static关键字用法：

final修饰符：

 抽象类：

---

toString方法的用法：

• toString()方法是Object类里的一个实例方法，所有的Java类都是Object类的子类，因此所有的Java对象都具有toString()方法。
• Object类提供的toSring()方法总是返回该对象实现类的“类名+@+hashCode”值，这个值并不能真正实现“自我描述”功能，因此如果用户需要自定义类实现“自我描述”的功能，就必须重写Object类的toString()方法。

• class Apple{
      private String color;
      private double weight;
      public Apple() {}
  
      public Apple(String color,double weight){
          this.color=clor;
          this.weight=weight;
      }
  
      //重写toString()方法，用于实现Apple对象的自我描述
      public String toString(){
          return "一个苹果，颜色为："+color+",重量为："+weight;
      } 
  }
  public class ToStringTest{
      public static void main(String[] agrs){
          Apple a=new Apple("红色"，5.56);
          //打印Apple对象
          System,out.println(a);
      }
  }

  运行结果：

  一个苹果，颜色为：红色，重量为：5.56

•  大部分时候，重写toString()方法总是返回该对象的所有令人感兴趣的信息，所组成的字符串。

通常返回一下格式字符串：

类名[field1=值1，fiels2=值2，......]

•  因此，可将上面的APple类的toString()方法改为：

public String toString()

{

        return "Apple [color="+color+",weight ="+weight+"]";

}

==和equals的区别：

• Object类默认提供的equals()只是比较对象的地址，即Object类的equals()比较的结果与==运算符比较的结果完全相同。因此一般都要重写equals()方法，相等的条件有业务要求决定。

static关键字用法：

• static关键字修饰的就是类的成员。static关键字不能修饰构造器。staic修饰的类成员属于整个类，不属于单个实例。
• 对于static关键字，有一个重要的规则：类成员（包括方法，初始化快，内部类和枚举类）不能访问实例成员（包括成员变量，方法、初始化快、内部类和枚举类）。因为类成员属于类，类成员的作用域比实例成员的大，有可能类成员已经初始化完成而实例成员还未开始初始化，将会引发大量错误！

final修饰符：

• final可修饰类、变量、和方法。
• final修饰变量时，不是该变量一旦获得初始值就不可改变！

final成员变量：

• 规定：final修饰的成员变量必须显式地指定初始值！ 
• final修饰类变量、实例变量指定初始值的地方：

>>>类变量：必须在静态初始化块中指定初始化值或声明该类变量时指定·初始值，而且只能在这两个其中一个指定。

>>>实例变量：必须在非静态初始化块、声明该实例变量或构造器中指定初始值，而且只能在这三个其中一个指定。

>>>普通方法不能为final修饰的成员变量赋值。

 注意：实例变量不能在静态初始化块中指定！类变量不能在普通初始化块中指定！应先初始化再访问！

fianal局部变量：

• 系统不会为局部变量进行初始化，必须显式初始化。
• final修饰的局部变量在定义时没有指定默认值，则可以在后面对该final变量赋值，但不可重复赋值！

final修饰·的基本类型变量和引用类型变量的区别：

• final修饰基本类型变量时，不能重复赋值，因此基本类型变量不能改变。
• 但是，对于引用类型变量，它保存的仅仅是一个引用，final只保证这个引用类型变量所引用的地址不会改变，即一直引用同一个对象，但是这个对象可以发生改变。

例如：

//final修饰数组变量，iArr是一个引用变量

final int[] iArr ={5,6，12,9}

//对数组元素赋值，合法

iArr[2]=-8;

//对iArr重新赋值，非法

iArr=null;

//final修饰Person变量，p是一个引用变量

final Person p=new Person(45);//age=45

//改变Person对象的age的实例变量，合法

p.setAge();

//对p重新赋值，非法

p=null;

>>>final修饰的引用类型变量不能被重新赋值，但可以改变引用类型变量所引用对象的内容。

final方法：

• final修饰的方法不能被重写，但是可以被重载。

• public class FinalOverload()
  {
      public final void test();
      public final void test(String arg);
  }

  final类：

• final修饰的类不可以有子类。例如Java.lang.Math类就是一个final类，它不可以有子类。

 抽象类：

• 抽象方法只有方法签名，没有方法实现的方法！
• abstract不能用于修饰成员变量、局部变量，即没有抽象变量、抽象成员变量的说法；也不能修饰构造器，没有抽象构造器，抽象类里定义的构造器只能是普通构造器。

抽象方法和抽象类：

• 都用abstract修饰符来定义。
• 抽象方法·不能有具体的方法体，只能由子类提供实现（重写）。
• 抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建对象，即抽象类不包含抽象方法，这个抽象类也不能创建实例。
• 抽象类可以有成员变量、方法（普通方法、抽象方法都行）、构造器、初始化块、内部类、（接口、枚举）5种成分。抽象类的构造器不能用于创建实例，主要用于被其子类调用。
• 含有抽象方法的类（包括直接定义了一个抽象方法；或继承了一个抽象父类，但没有实现父类包含的抽象方法；或实现了一个接口，但没有完全实现接口的抽象方法3种情况）只能被定义为抽象类。
• static和abstract不能同时修饰某个方法，即没有所谓的课抽象方法。（staic修饰的方法为类方法，通过类就可调用该方法，但被定义为抽象方法时，类调用一个没有方法体的方法必然引发错误！）
• 定义一个shape抽象类：

public abstract class Shape
{
    {
        System.out.println("执行Shape的初始化块");
    }
    private String color;
    //定义一个计算周长的抽象方法
    public abstract double calPerimeter();
      //定义一个返回形状的抽象方法
    public abstract String getTyoe();
    //定义Shape的构造器
    public Shape（）{}
    public Shape (String color)
    {
        System.out.println("执行Shape的构造器.....");
        this.color=color;
    }
    //可补充color的stter和getter方法
    .......
}

//定义一个三角形类：

public class Triangle extends Shape
{
    //定义三角形的三边
    private double a;
    private double b;
    private double c;
    public Triangle(String color,double a,double b,double c)
    {
        surper(color);
        this.setSides(a,b.c);
    }
    public setSides(double a,double b,double c)
    {
        if(a>=b+c||b>=a+c||c>=a+b)
        {
            System.out.println("三角形两边之和大于第三边");
            return;
        }
        this.a=a;
        this.b=b;
        this.c=c;
    }
    //重写Shape类计算周长的抽象方法
    public double calPerimeter()
    {
        return a+b+c;
    }
    //重写Shape类返回形状的抽象方法
    public String getType()
    {
        return "三角形";
    }
}

//再定义一个Circle普通类：

public class Circle extends Shape
{
    private double radius;
    public Circle(String color,double radius)
    {
        super(color);
        this.radius=radius;
    }
    public void setRadius(double radius)
    {
        this.radius=radius;
    }
    //重写Shape类的计算周长的抽象方法
    public double calPerimeter()
    {
        return 2*Math.PI*radius;
    }
    //重写Shape类的返回形状的抽象方法
    public String getType()
    {
       return getColor()+"圆形";
    }
    public static void nain(String[] args)
    {
        Shape s1=new Triangle("黑色"，3,4,5);
        Shape s2=new Circle("蓝色"，3);

        System.out.println(s1.getType());
        System.out.println(s1.calPerimeter());

         System.out.println(s2.getType());
          System.out.println(s2.calPerimeter());
    }

}

 abstract关键字修饰的方法必须被其子类重写才有意义，否则这个方法将永远不会有方法体，因此abstract方法不能定义为private访问权限，即private和abstract不能同时修饰方法。

 抽象类的作用：