黑马程序员JAVA学习第四节

最新推荐文章于 2022-12-08 19:09:14 发布

天堂的倒影

最新推荐文章于 2022-12-08 19:09:14 发布

阅读量204

点赞数

分类专栏： java基础学习文章标签： java 编程语言接口

本文链接：https://blog.csdn.net/weixin_51181574/article/details/117330941

版权

java基础学习专栏收录该内容

15 篇文章 2 订阅

订阅专栏

黑马程序员JAVA学习第四节

（视频链接黑马程序员全套Java教程_Java基础入门教程，零基础小白自学Java必备教程_哔哩哔哩 (゜-゜)つロ干杯~-bilibili）

本节主要内容是 形参和返回值内部类常用API(Math,Object,System,冒泡排序,Arrays类) 时间日期类包装类异常，对应视频187-219

形参和返回值：

1.普通类名做形参和返回值与int string 基本上差不多。

2.抽象类名做形参和返回值;

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

abstract class Animal {
    public abstract void eat();
}
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
class AnimalOperator {
    public void useAnimal(Animal a) { //Animal a = new Cat();
        a.eat();
    }
    public Animal getAnimal() {
        Animal a = new Cat();
        return a;
    }
}
public class AnimalDemo {
    public static void main(String[] args) {
        //创建操作类对象，并调用方法
        AnimalOperator ao = new AnimalOperator();
        Animal a = new Cat();
        ao.useAnimal(a);
        Animal a2 = ao.getAnimal(); //new Cat()
        a2.eat();
    }
}

3.接口名作形参和返回值：

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

interface Jumpping {
    void jump();
}
class JumppingOperator {
    public void useJumpping(Jumpping j) { //Jumpping j = new Cat();
        j.jump();
    }
    public Jumpping getJumpping() {
        Jumpping j = new Cat();
        return j;
    }
}
class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
public class JumppingDemo {
    public static void main(String[] args) {
        //创建操作类对象，并调用方法
        JumppingOperator jo = new JumppingOperator();
        Jumpping j = new Cat();
        jo.useJumpping(j);
        Jumpping j2 = jo.getJumpping(); //new Cat()
        j2.jump();
    }
}

内部类：

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

2.定义格式：

    class 外部类名{
     修饰符 class 内部类名{    
     }    
    }

3.访问特点：

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

public class Outer {
    private int num = 10;
    public class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}

4.成员内部类：

1）与成员变量一个位置

2）外界创建成员内部类格式：格式：外部类名 .内部类名对象名 = 外部类对象.内部类对象;
举例： Outer.Inner oi = new Outer().new Inner();（若私有化后失效）

3）内部类的推荐使用：私有化定义后，提供一个让外界调用的方法，方法内部创建内部类对象并调用

class Outer {
    private class Inner {
        public void show() {
            System.out.println("_____");
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}
public class InnerDemo {
    public static void main(String[] args) {
//Outer.Inner oi = new Outer().new Inner(); 方法一：外界创建内部类格式(如果内部类私有时失效）
//oi.show();        
        Outer o = new Outer();//方法二：推荐
        o.method();
    }
}

5.局部内部类：

1）局部内部类定义位置：局部内部类是在方法中定义的类
2）局部内部类方式方式
局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
该类可以直接访问外部类的成员，也可以访问方法内的局部变量

class Outer {
    private int num = 10;
    public void method() {
        int num2 = 20;
        class Inner {
            public void show() {//方法中定义
                System.out.println(num);//访问外部类成员变量
                System.out.println(num2);//访问局部变量
            }
        }
        Inner i = new Inner();
        i.show();
    }
}
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

6.匿名内部类：（重要，特殊的局部内部类）

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

2）格式： new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }；

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

常用API

1.Math

Math 类中无构造方法，但内部的方法都是静态的，则可以通过类名.进行调用

2.System

1)public static void exit(int status) 终止当前运行的 Java 虚拟机，非零表示异常终止

2)public static long currentTimeMillis() 返回当前时间(以毫秒为单位)

        // 获取开始的时间节点
        long start = System.currentTimeMillis();
        for (int i = 1; i <= 10000; i++) {
            System.out.println(i);
        }
        // 获取代码运行结束后的时间节点
        long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end  start) + "毫秒");

3.Object类

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

2）查看源码方式： Ctrl+B

3）重写toString方法：ALt+insert 选择toString，在类的空白区域，右键 -> Generate -> 选择toString

—— - -- - -- - - -- - -- - -- - - - -- -- - -- - - - - -

1）equals方法作用：用于对象之间的比较，返回 true和false的结果

2）重写 equals方法的场景：不希望比较对象的地址值，想结合对象属性进行比较的时候

3）重写 equals方法的方式
1 . alt + insert 选择equals() and hashCode()，IntelliJ Default，一路next，finish 即可
2 . 在类的空白区域，右键 -> Generate -> 选择equals() and hashCode()，后面的同上

4.冒泡排序：

1）冒泡排序概述
一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序
2）特点：如果有 n个数据进行排序，总共需要比较n-1次
每一次比较完毕，下一次的比较就会少一个数据参与

5.Arrays类

作用：包含用于操作数组的各种方法

方法名说明
public static String toString(int[] a) 返回指定数组的内容的字符串表示形式
public static void sort(int[] a) 按照数字顺序排列指定的数组

Arrays.sort(arr);
Arrays.toString(arr);

6.工具类设计思想
1）构造方法用 private 修饰（防止外界创建对象）
2）成员用 public static 修饰（使用类名访问成员方法）

包装类

1.基本类型包装类：将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。常用的操作之一：用于基本数据类型与字符串之间的转换

2.Integer类

构造方法：

Integer i3 = Integer.valueOf(100);
System.out.println(i3);
Integer i4 = Integer.valueOf("100");
System.out.println(i4);

3.int与String类型的相互转换

1）int->String

方式一：直接在数字后加一个空字符串
方式二：通过 String类静态方法valueOf()

 String s1 = number + "";//方式一
String s2 = String.valueOf(number);//方式二

2）String->int

方式一：先将字符串数字转成 Integer，再调用valueOf()方法
方式二：通过 Integer静态方法parseInt()进行转换

Integer i = Integer.valueOf(s);//方式一
int x = i.intValue();
System.out.println(x);

int y = Integer.parseInt(s);//方式二

//把字符串中的数字数据存储到一个int类型的数组中 按空格分割
String[] strArray = s.split(" ");//String s = "91 27 46 38 50";

4.自动拆箱和自动装箱

自动装箱：把基本数据类型转换为对应的包装类类型
自动拆箱：把包装类类型转换为对应的基本数据类型

Integer i = 100;  // 自动装箱 本来是Integer i=Integer.valueOf(100)
i += 200;     //i + 200 自动拆箱；i = i + 200; 是自动装箱  i=i.intValue()+200

时间日期类

1.Date概述：代表一个特定的时间，精确到毫秒

2.Date构造方法：

public Date() //分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
public Date(long date)// 分配一个 Date对象，并将其初始化为表示从标准基准时间(1970)起指定的毫秒数

3.Date类常用方法：

public long getTime() //获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
public void setTime(long time) //设置时间，给的是毫秒值

4.SimpleDateFormat概述：是一个具体的类，用于以区域设置敏感的方式格式化和解析日期

5.SimpleDateFormat常用模式字母以及对应关系：y-年，M-月，d-日，H-时，m-分，s-秒

6.SimpleDateFormat构造方法：

public SimpleDateFormat() //构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(Stringpattern)//构造一个SimpleDateFormat使用给定的模式和默认日期格式

7.SimpleDateFormat常用方法：

格式化 (从Date到String)
public final String format(Date date) ：将日期格式化成日期/时间字符串

解析 (从String到Date)
public Date parse(String source) ：从给定字符串的开始解析文本以生成日期

   Date d = new Date();//格式化：从Date到String
   SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
   String s = sdf.format(d);
   System.out.println(s)

   //从 String 到 Date
    String ss = "2048-08-09 11:11:11";
    SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date dd = sdf2.parse(ss);
    System.out.println(dd);

8.Calendar 类概述
Calendar 为特定瞬间与一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法，Calendar 提供了一个类方法 getInstance 用于获取这种类型的一般有用的对象。该方法返回一个Calendar 对象。其日历字段已使用当前日期和时间初始化：Calendar rightNow = Calendar.getInstance()

9.Calendar 常用方法

public int get(int field) //返回给定日历字段的值
public abstract void add(int field, intamount)//根据日历的规则，将指定的时间量添加或减去给
//定的日历字段
public final void set(int year,int month,intdate)//设置当前日历的年月

异常

1.异常体系

2.JVM 默认处理异常的方式

把异常的名称，错误原因及异常出现的位置等信息输出在了控制台程序停止执行

3.try-catch方式处理异常

try {
    可能出现异常的代码;
} catch(异常类名 e) {
    //异常的处理代码;
//    System.out.println("你访问的数组索引不存在，请回去修改为正确的索引");
      e.printStackTrace();
      System.out.println(e.toString());
      System.out.println(e.getMessage());
}

4.Throwable成员方法

public String getMessage() 返回此 throwable 的详细消息字符串
public String toString() 返回此可抛出的简短描述
public void printStackTrace() 把异常的错误信息输出在控制台

5.编译时异常和运行时异常的区别

1）编译时异常
都是 Exception类及其子类
必须显示处理，否则程序就会发生错误，无法通过编译
2）运行时异常
都是 RuntimeException类及其子类
无需显示处理，也可以和编译时异常一样处理

6.throws方式处理异常

public void 方法() throws 异常类名 {//抛出异常
 ]

这个 throws格式是跟在方法的括号后面的，编译时异常必须要进行处理，两种处理方案： try...catch …或者 throws，如果采用 throws 这种方案，将来谁调用谁处理，运行时异常可以不处理，出现问题后，需要我们回来修改代码。

7.自定义异常：

继承自Exception或者RuntimeException

public class ScoreException extends Exception {
  public ScoreException() {}
  public ScoreException(String message) {
    super(message);
 }
}
//老师类
public class Teacher {
  public void checkScore(int score) throws ScoreException {
    if(score<0 || score>100) {
//      throw new ScoreException();
      throw new ScoreException("你给的分数有误，分数应该在0-100之间");
   } else {
      System.out.println("成绩正常");
   }
 }
}
//测试类
public class Demo {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入分数：");
    int score = sc.nextInt();
    Teacher t = new Teacher();
    try {
      t.checkScore(score);
   } catch (ScoreException e) {
      e.printStackTrace();
   }
 }
}

8.throws与throw的区别：

天堂的倒影

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员JAVA学习第四节

黑马程序员JAVA学习第四节（视频链接黑马程序员全套Java教程_Java基础入门教程，零基础小白自学Java必备教程_哔哩哔哩 (゜-゜)つロ干杯~-bilibili）本节主要内容是，对应视频187-形参和返回值：1.普通类名做形参和返回值与int string 基本上差不多。2.抽象类名做形参和返回值; 1)方法的形参是抽象类名，其实需要的是该抽象类的子类对象 2)方法的返回值是抽象类名，其实返回的是该抽象类的子类对象abstractclassAnim...
复制链接

扫一扫