Java学习笔记（七）

目录

一：形参和返回值

二：内部类

三：常用的API

 四：Object

---

一：形参和返回值

1.1 类名做为形参和返回值

• 方法的形参是类名，其实需要的是该类的对象。
• 方法的返回值是类名，其实返回的是该类的对象。

1.2 抽象类名作为形参和返回值

• 方法的形参是抽象类名，其实需要的是该抽象类的子类对象。
• 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象。

1.3 接口名做为形参和返回值

• 方法的形参是接口名，其实需要的是该接口的实现类对象。
• 方法的返回值是接口名，其实返回的是该接口的实现类对象。

二：内部类

2.1 内部类的概述

内部类：就是在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类。

内部类的定义格式：

public class 类名{

修饰符 class 类名{

}

}

内部类的访问特点：

• 内部类可以直接访问外部类的成员，包括私有
• 外部类要访问内部类的成员，必须创建对象。

public class Outer {
    private int number=10;

    public class Inner{//内部类
       public void show(){
           System.out.println(number);//内部类可以直接访问外部类的成员，包括私有
       }
    }
    public void method(){
        Inner i=new Inner();//外部类要访问内部类的成员，必须创建对象。
        i.show();
    }
}

2.2 成员内部类

按照内部类在类中定义的位置不同，可以分为如下两种形式：

• 在类中的成员位置：成员内部类
• 在类中的局部位置：局部内部类

成员内部类，外界如何创建对象使用呢？

格式：外部类名.内部类名 对象名=外部类对象.内部对象；

范例：Outer.Inner oi=new Outer().new Inner();

public class Outer {
    private int number=10;

    private class Inner{//内部类
       public void show(){
           System.out.println(number);//内部类可以直接访问外部类的成员，包括私有
       }
    }
    public void method(){
        Inner i=new Inner();//外部类要访问内部类的成员，必须创建对象。
        i.show();
    }
}
class Demo{//测试类
    public static void main(String[] args) {
        //创建对象，调用方法
        /*Outer.Inner i=new Outer().new Inner();
        i.show();*/

        Outer o=new Outer();
        o.method();
    }
}

2.3 局部内部类

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用。

该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

public class Outer {
    private int number=10;


    public void method(){
         int number2=20;
         class Inner{//内部类
            public void show(){
                System.out.println(number);
                System.out.println(number2);
            }
        }
        Inner i=new Inner();//外部类要访问内部类的成员，必须创建对象。
        i.show();
    }
}
class Demo{//测试类
    public static void main(String[] args) {
      Outer o=new Outer();
      o.method();
    }
}

2.4 匿名内部类

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类。

格式：

new 类名或者接口名（）{

       重写方法；

           }；

范例：

new Inter(){
       public void show(){}

}

本质：是一个继承了该来或者实现了该接口的子类匿名对象。

public class Outer {
    public void method() {
       /* new Inner() {
            @Override
            public void show(){
                System.out.println("匿名内部类");
            }
        }.show();*/

        Inner i=new Inner() {
            @Override
            public void show(){
                System.out.println("匿名内部类");
            }
        };
        i.show();
    }
}

class Demo {//测试类

    public static void main(String[] args) {
        Outer o=new Outer();
        o.method();
    }
}

interface Inner {
    void show();
}

2.5 匿名内部类在开发中的使用

public class Outer {
    public void method(jumpping j) {
        j.jump();
    }
}


class Demo {//测试类

    public static void main(String[] args) {
        Outer o = new Outer();
        o.method(new jumpping() {
            public void jump() {
                System.out.println("猫可以跳高了");
            }
        });


        o.method(new jumpping() {
            @Override
            public void jump() {
                System.out.println("狗也可以跳高");
            }
        });
    }
}

interface jumpping {
    public void jump();
}

三：常用的API

3.1 Math

Math的概述：Math包含执行基本数字运算的方法

没有构造方法，如何使用类中的成员呢？

看类的成员是否都是静态的，如果是，通过类名就可以直接调用。

Math类的常用方法：

3.2 System

System类概述：System包含几个有用的类字段和方法，它不能被实例化。

System类的常用方法：

public class Main {
    public static void main(String[] args) {
       /* System.out.println("开始");
        System.exit(0);
        System.out.println("结束");*/

        //只会输出：“开始”

        System.out.println(System.currentTimeMillis());
        System.out.println(System.currentTimeMillis()*1.0/1000/60/60/24/365+"年");

        long start=System.currentTimeMillis();
        for(int i=0;i<10000;i++){
            System.out.println(i);
        }
        long end=System.currentTimeMillis();
        System.out.println("执行for循环耗时："+(end-start)+"毫秒");
    }
}

 四：Object

4.1 Object类的概述：

Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类。

构造方法：public Object（）

回想面向对象中，为什么说子类的构造方法默认访问的是父类的无参构造方法？

因为它们的顶级父类只有无参构造方法。

4.2Object类的常用方法：

1.public String toString()-----返回对象的字符串表示形式。建议所有子类重写该方法，自动生成。

public class Main {
    public static void main(String[] args) {
        //如何查看方法的源码呢？（点击方法，按下Ctrl+B）
        //建议所有子类重写此方法（toString）
        //如何重写呢？（自动生成即可）
        student s = new student();
        s.setName("小花");
        s.setAge(18);
        System.out.println(s);//Main.student@4eec7777
        System.out.println(s.toString());//Main.student@4eec7777（默认）
  //student{name='小花', age=18}，这是重写Object类toString方法后的s

        /*public void println(String x) {   //s==x
        if (getClass() == PrintStream.class) {
            writeln(String.valueOf(x));
        } else {
            synchronized (this) {
                print(x);
                newLine();
            }
        }
    }
    public static String valueOf(Object obj) {  //x==obj
        return (obj == null) ? "null" : obj.toString();
    }


    public String toString() {     //obj.toString()
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }


    */
    }
}

class student extends Object{
    private String name;
    private int age;

    public student() {
    }

    public student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {//重写了Object类的toString方法
        return "student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2.public boolean equals（Object obj）：比较对象是否相等，默认比较地址，重写后可以比较内容，自动生成。

public class Main {
    public static void main(String[] args) {
        student s1 = new student();
        s1.setName("小明");
        s1.setAge(18);
        student s2 = new student();
        s2.setName("小明");
        s2.setAge(18);
        //比较内容是否相同
        System.out.println(s1.equals(s2));//true
        //重写Object类的equals（）方法
        /*public boolean equals(Object obj) {
        //this---s1
        //obj---s2
        return (this == obj);
    }


        */
    }
}

class student extends Object {
    private String name;
    private int age;

    public student() {
    }

    public student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        //this-----s1
        //o   -----s2
        //比较地址是否相同，如果相同，直接返回true
        if (this == o) return true;
        //判断参数是否为null
        //判断两个对象是否来自于同一个类

        if (o == null || getClass() != o.getClass()) return false;
//向下转型
        student student = (student) o;//student =s2
//比较年龄是否相同
        if (age != student.age) return false;
        //比较姓名内容是否相同
        return name != null ? name.equals(student.name) : student.name == null;
    }

    /*@Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }*/
}

---

（PS：以上照片截至黑马程序员java全套视频）