我的java学习日记（二）

对象比较和方法重写

在java程序设计中，经常会对两个数据进行比较，如果是基本数据类型，那么可以直接使用“”即可判断两个值是否相等；如果是两个对象的比较，那么使用“”的话就不对了，例如有两个对象obj1和obj2，如果直接使用以下语句：

obj1==obj2

则这句话的意思就是比较这两个对象的地址，那么这样比较两个对象是否相等就不对了。

所以要使用java中自带的方法equals()

equals()的用法

对象1.equals(对象2)

这句话执行之后，会返回一个boolean类型的值，true或者false

可以嵌套在if语句或者其他条件判断语句中使用

@Override 方法重写

如果我们有特殊需要，要将父类的方法改写，那么就需要用到@Override这条命令了。

class Student
        {
            int sNo;
            String name;
            double age;
            @Override//这里重写equals方法是为了加一个判断学号是否一致的条件
            public boolean equals(Object obj)
            {
                if(obj==this)//obj指的是传入的对象，this指的是调用该方法的对象
                    return true;
                if(obj instanceof Student)
                {
                    Student tempobj=(Student)obj;//这一句必须在大括号内。。。//强制类型转换 （Student）意思是强制将右边的的东西转换为括号内的类型）
                    return (tempobj.sNo==this.sNo);//obj指的是传入的对象，tempobj指的是
                }
                return false;//如果以上两个条件都没有符合，则判断这两个不一样

            }
        }
public class Demo4_9
{
    public static void main(String[] args) {
        Student s=new Student();
        s.sNo=111;
        Student s1=new Student();
        s1.sNo=121;
        Student s2;
        s2=s;
        if(s==s1)//这里指的是两个对象的地址，所以即使值完全相等，也不会
        {
            System.out.println("s==s1");
        }
        else
        {
            System.out.println("s!=s1");
        }
        if(s.equals(s1))
        {
            System.out.println("s equals s1");
        }
        else
        {
            System.out.println("s not equals s1");
        }
        if(s.equals(s2))
            System.out.println("s equals s2");

    }
}

第七行开始就是对equals()方法的重写，因为equals()方法是父类的方法，所以，如果我们有需要，要对这个方法进行重写的话，我们可以使用@Override语句，将相应的方法重写一遍，将父类的方法覆盖掉。

上面的代码中，利用@Override语句将父类中的equals（）方法进行了重写，添加了一个判断条件。

即，当学号一致时，返回true。

这就是@Override的使用方法。

封装

为了防止对象之外的代码对类的内部进行不适当的访问和修改，需要对对象进行封装。

在java中，通过修饰符实现对对象的封装。通过静态属性私有化，提供公有方法访问私有属性来隐藏实现的细节。

如果是public 则会允许外部代码修改或访问勒种的数据值，这样会破坏类的封装性，如果使用的是private可见性，则只能由类的内部访问，不允许类的外部访问，这样可以确保类的封装性

类的成员方法是否允许客户可见，取决于方法的用途。

类的成员变量也可以利用封装来限制用户对变量的权限，例如setter和getter

Setter和Getter

public class oj3949 {
    public static void main(String[] args) {
        Demo obj = new Demo();
//        System.out.println(obj.a);//这一行会报错，因为类中对a设置了private访问权限，外部代码没有权限对其进行修改和访问
//        obj.a =999;//同理这一行也是错的
        obj.setter(777);
        System.out.println(obj.geta());//这一行就不会报错了，因为private的成员变量是可以被同一个类里面的方法访问的。
        Demo obj1=new Demo();//例如想要调用obj1方法里面的私有函数
//        obj1.setter1(888);//同样是不能直接访问该私有方法的
        obj1.helper(888);//但是我们可以使用类里面的代码来代理访问这个私有方法
        System.out.println(obj1.geta());
    }
}
class Demo
{
    private int a;
    public int b;
    public void setter(int a)
    {
        this.a=a;
    }
    public int geta()
    {
        return this.a;
    }
    private void setter1(int a)
    {
        this.a=a;
    }
    public void helper(int a)
    {
        this.setter(a);
    }
}

继承

继承指的是从已有的类中派生出新的类的过程。

例如Student类，可以派生出Pupil MiddleSchool HighSchool College

在Java中是用用extends关键字指明的。

具体格式如下

class 子类 extends 父类
{
...  
}

例如

class Student 
{
 ... 
}
class College extends Student
{
  ...
}

其中College声明为Student的子类，Student为College的父类。

子类的类体中有一部分是自己定义的，另一部分是从父类继承而来的。

列如：

public class Demo1_14 
{
    public static void main(String[] args) {
        Son obj=new Son();
        obj.dfun();//
        obj.cfun();//obj作为一个用Father的子类为模板制作出来的对象既可以调用父类的方法，也可以调用自己的方法
    }
}
class Father
{
    public int a;
    public int b;
    public void cfun()
    {
        System.out.println("this is father's function");
    }
}
class Son extends Father
{
    public int d;
    public void dfun()
    {
        System.out.println("this is son's function");
    }
}

obj作为一个用Father的子类为模板制作出来的对象既可以调用父类的方法，也可以调用自己的方法。

如果子类有的方法或者成员变量和父类的重名了或者冲突了，那么java会默认使用子类自己的方法或者成员变量的值，如果在这种情况下，如果想用父类的方法或者成员变量，就需要使用super 关键字。

public class Demo1_14
{
    public static void main(String[] args) {
        Son obj=new Son();
        obj.dfun();//
        obj.cfun();//obj作为一个用Father的子类为模板制作出来的对象既可以调用父类的方法，也可以调用自己的方法
        obj.a=1;//可以修改和调用父类的成员变量
    }
}
class Father
{
    public int a;
    public int b;
    public void cfun()
    {
        System.out.println("this is father's function");
    }
}
class Son extends Father
{
    public int d;
    public void dfun()
    {
        System.out.println("this is son's function");
    }
    public void cfun()
    {
        System.out.println("this is son's cfunction!\nand the following is the father's funciton");
        super.cfun();//这里调用了父类的方法
    }
}

output

/Users/Admin/Library/Java/JavaVirtualMachines/openjdk-15.0.2/Contents/Home/bin/java -javaagent:/Applications/IntelliJ IDEA.app/Contents/lib/idea_rt.jar=59936:/Applications/IntelliJ IDEA.app/Contents/bin -Dfile.encoding=UTF-8 -classpath /Users/Admin/IdeaProjects/study/out/production/study Demo1_14
this is son's function
this is son's cfunction!
and the following is the father's funciton
this is father's function

进程已结束，退出代码为 0