JAVA小记-类设计的进阶

1、instanceof关键字的使用

①作用：用于判断一个对象是否属于是某一个类（或者父类）的实例。

②语法形式：

如果“对象”是“类名”的一个实例对象，则返回“true”,否则的话返回“false”。

对象 instanceof 类名

③示例：instanceof 的使用

//点类实现接口Cloneable
class Point implements Cloneable//这里是接口，他的父类还是是Object
{
    private int x,y;//成员变量
    Pint (int x,int y)//构造方法
    {
        this.x=x;
        this.y=y;
    }
    public void move(int offsetx,int offsety){//点的移动方法
        x+=offsetx;
        y+=offsety;
    }
    //重写父类toString()方法，使点的位置形成一个字符串
        public String toString(){
        String str="("+x+")";
        return str;
    }
    public void print()//打印方法
    {
        System.out.println(toString());
    }
}
public class Main()
{
    public static void main(String args[])
    {
        Point point=null;
        System.out.println("对象名point表示的是一个空对象，则：");
        System.println("point instanceof Point ="+(point instanceof Point));
        System.println("point instanceof Object ="+(point instanceof Object));
      
        println("对象pint表示一个正真的对象，则：");
        Point point=new Point(10,20);//它是Point的对象，同时也是Object的对象
        System.out.println("point instanceof Point ="+(point instanceof Point));
        System.println("point instanceof Object ="+(point instanceof Object));
    }
}

④运行结果：

2、Object类

Java只支持单继承，所有的一个类都只有一个父类。Java的基础类中有一个object类。他是所有类的直接或者间接父类。但是Object是最顶级的类，是没有父类的。

3、super关键字

①定义：如果子类隐藏了父类的域或者重写了父类的方法，但是子类想要访问被隐藏的域或者重写的方法，则可以通过关键字“super”来进行访问。可以说super是父类对象的指针。通过super还可以调用父类的构造方法，以便于对继承自父类的域进行初始化。值得注意的是：这一条语句要放在第一条语句的位置。

②语言形式：

super.域;
super.方法名(实际参数);

③实例：super的使用

代码

class Super{
    int var;
    public Super(int var){
        this.var=var;
    }
}
class Sub extends Super{
    int var;
    public Sub(int var1,int var2){
        super(var2);//调用父类的方法
        this.var=var1;
    }
    public void display(){
        System.out.println("继承自父类的域："+super.var);
        System.out.println("本身定义的域："+var);
    }
}
​
public class Main()
{
    public static void main(String args[])
    {
        Sub sub=new Sub(10,-200);//由子类去初始化了父类中的var
        sub.display();
    }
}

4、final关键字

①定义：final关键字可以修饰域，方法，还有类。它修饰的域叫做最终域。

如果用final来修饰类则表示这个类不可以被继承。如果被用来修饰方法，则这个方法不可以被子类重 写。如果用这个来修饰变量，则这个变量在赋值过后就不可以被修改。

5、方法的重载和重写

区别：重载发生在一个类之间，必须修改方法参数；而重写发生在父类和子类之间，不能修改方法参数；

（1）重写

①定义：在子类中重新定义继承父类的方法或者域。

②注释的方法：@Override(表示的是对父类种方法的重写，若是此方法在父类中没有却用这个符号注释，编译时就会出现编译错误)。

③实例：

1）域的隐藏

class SuperClass
{
    int var;
    public void setSpurVar(int var)
    {
        this.var=var;
    }
    public int getSuperVar()
    {
        return var;
    }
}
​
class SubClass extends SuperClass
{
    int var;
    public void SubClass(int v)
    {
        var=v;
    }
    public int getSubVar()
    {
        return var;
    }
}
public class Main()
{
    public static void main(String args[])
    {
        Subclass obj=new Subclass();
        obj.setSubVar(20);
        obj.setSuperVar(-20);
        System.out.println("子类对象本身的域的值："+obj.getSubVar());
        System.out.println("子类对象继承父类的域的值："+obj.getSuperVar());
    }
}

结果为：

 

2)方法的重写

子类重写父类的方法时，方法的名称，类型还有形式参数应该与继承自父类的方法相同。

实例：

 

class shape
{
    public double area()
    {
        return 0;//最开始不知道是什么图形，所以无法计算面积，所以直接返回0
    }
    public double perimeter()
    {
        return 0;
    }
}
class Circle extends Shape
{
    private double radius;
    public Circle(double radius)
    {
        this.radius=radius;
    }
    public double area()//方法重写
    {
        return Math.PI*radius*radius;
    }
    public double perimeter()//重写
    {
       return 2*Math*PI*radius;
    }
}
class Rectangle extends shape
{
    public Rectangle(double width,double height)
    {
        this.width=width;
        this.heght=height;
    }
    public double area()
    {
        return width*heigth;
    }
    public double perimeter()
    {
        return 2*(width+heigth);
    }
}
​
public class Main()
{
    public static void main(String args[])
    {
        Circle circle=new Circle(10);
        Rectangle rect=new Rectangle(15.2,10.8);
        
        System.out.print("圆的面积周长是：");
        System.out.printf("%.2f,%.2f\n",circle.area(),circle.perimeter());//保留两位小数
        
        System.out.print("矩形的面积周长是：");
        System.out.printf("%.2f,%.2f\n",rect.area(),rect.perimeter());//保留两位小数
    }
}

运行的结果是：

 

（2）重载

①定义：在一个作用域（如在一个类中）内定义的多个同名方法称为方法的重载。重载时要求方法的形式参数互不相同。

②注释方法：@ Overload

③实例：

例题：找出两个整型数，3个整型数和3个以上的整型数和最大值。

其中用到了foreach循环

运用的形式：

for(元素类型t 元素变量x : 遍历对象obj){ 引用了x的java语句; }

代码：

private static int max(int x,int y)//第一个max
{
    return x>y?x:y;
}
​
private static int max(int x,int y,int z)
{
    int m=max(x,y);//在第二个函数中调用第一个函数；
    return m>z?m:z;
}
​
private static int max(int a[])//不知道个数，直接先用一个数组
{
    int m=a[0];
    for(int x:a)//用到了foreach循环，这种有冒号的for循环叫做foreach循环
    {
        m=m>x?m:x;
    }
    return m;
}
​
public class Main()
{
    public static void main(String arg[])
    {
        int a=10,b=25,c=-90;
        int x[]={98,34,78,934,8,93,48,928,92,8,83};
        //分别调用三个max
        System.out.println("两个数中的最大数："+max(a,b));
        System.out.println("三个数中的最大数："+max(a,b,c));
        System.out.println("多个数的最大数："+max(x));
    }
}

运行的结果是：

两个数中的最大数：25

三个数中的最大数：25

多个数中的最大数：934