Java学习--Day6

最新推荐文章于 2024-04-15 15:36:19 发布
最新推荐文章于 2024-04-15 15:36:19 发布
阅读量91 收藏
点赞数
分类专栏： JAVA自学记录 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45066381/article/details/113919189
版权

Java学习–Day6

这是过年期间，零碎时间看的，所以是好几天的内容，基本JavaSE结束，有漏掉的，我再补充

Java方法详解（C++有接触，不多赘述）

可变参数

一个方法中只能指定一个可变参数，他必须是方法的最后一个参数，任何普通的参数必须在它之前声明。

public class Demo01 {
    public static void main(String[] args) {
        printMax(34,56,1,3,56,78,21,32);
        printMax(new double[]{1,2,3});
    }
    //可变参数，也叫不定项参数
    public static void printMax(double...numbers){
        if(numbers.length==0){
            System.out.println("No argument passed");
            return;
        }
        double result = numbers[0];
        //找最大
        for(int i = 1;i < numbers.length;i++){
            if(numbers[i] > result){
                result = numbers[i];
            }
        }
        System.out.println("The max value is" + result);
    }
}
//结果为
The max value is78.0
The max value is3.0

数组

//静态初始化:创建+赋值
int[] a={1,2,3,4,5,6};
//动态初始化:包含数值的默认初始化
int[] b= new int[10];
b[0]=10;

面向对象

三大特征

  1. 封装
  2. 继承
  3. 多态

方法回顾

  1. 静态方法加关键字，在另一个类中可以用 类名**.**方法名 来调用方法
  2. 非静态方法，在另一个类中调用该方法时只能先实例化类的对象，然后通过对象来调用方法。
  3. 在静态方法中不能调用非静态方法，因为静态方法是和类一起加载的，而非静态方法是类实例化之后才存在的。

创建与初始化对象

使用类关键字new创建对象

class student{
    //类中属性
    String s_name;
    int s_age;
    //类中方法
    public static void study(){
        System.out.println(this.name+"在学习");
    }
}
//创建学生类并初始化
Student xiaoming=new Student();
//初始化
xiaoming.s_name="小明";
xiaoming.s_age=12;
//此处若不初始化，则在用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认初始化，以及对类的构造器（下面细讲）的调用。

构造器

要求：

  1. 与类名相同，public修饰
  2. 无返回值

作用：

  1. 可以在new对象时，如果定义有参构造，一定要有无参构造（可以空着，但不能没有。）
  2. 可以用来初始化对象的值

快捷键：alt+insert添加构造器

class Person{
    String name;
    //无参构造器
    public Person(){
        
    }
    //有参构造器
    public Person(String name){
        
    }
}

封装

程序设计要求：高内聚，低耦合

class Student{
    //私有属性，不能通过 对象名.属性 来设置或获取属性值
    //而应该调用Get与Set方法获取或设置
    //快捷键：alt+insert
    /*
    *1.提高程序的安全性，保护数据
    *2.隐藏代码的实现细节
    *3.统一接口
    *4.系统可维护性增加了
    */
    private String name;
    private int id;
    private char sex;
    public Student(){

    }
    public Student(String name){

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

    public void setId(int id) {
        this.id = id;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public char getSex() {
        return sex;
    }
}

继承

  1. 关键字extends
  2. Java中只有单继承，没有多继承，一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子。(在类中快捷键ctrl+h可查看继承的结构树)
  3. super关键字
package Base_Grammer;

//在java中，所有类都默认直接或间接继承Object类
public class Person {
    private int money=10_000_000;
    public void say(){
        System.out.println("yoyo~");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
    //super的用法
    protected String identity = "I am father";
    public void print(){
        System.out.println("Person");
    }
}


package Base_Grammer;

//子类继承父类，会继承父类所有public修饰的属性和方法
public class Student extends Person {
    private String identity="I am student";
    public void sayIdentity(String identity){
        System.out.println(identity);//I am student
        System.out.println(this.identity);//I am student
        //通过super来调用父类的属性，同时也可以用这种方法来调用父类的方法,但私有方法，super也不能调用
        System.out.println(super.identity);//I am father
    }
    public void print(){
        System.out.println("Student");
    }
    //用super调用父类方法
    public void test2(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }
}
  1. 构造器的执行

此处父类必须要有无参的构造器(即使父类有有参构造器)，如果没有子类的构造器会报错，这也就是为什么一个类一定要有无参构造器的原因。

package Base_Grammer;

//在java中，所有类都默认直接或间接继承Object类
public class Person {
    public Person() {
        System.out.println("Person的无参构造方法！");
    }
}

package Base_Grammer;

//子类继承父类，会继承父类所有public修饰的属性和方法
public class Student extends Person {
    public Student() {
        //这一行为隐藏代码：调用了父类的无参构造器
        super();//调用父类构造器，必须要在子类构造器的第一行
        System.out.println("Student的无参构造方法！");
    }
}


package Base_Grammer;

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        //此时newStudent类对象时会打印两行结果
        //Person的无参构造方法！
        //Student的无参构造方法！
    }
}

  1. 方法的重写

    有继承关系，子类重写父类的方法！

    先来看带static修饰的方法重写

    package Base_Grammer;

//A继承B类
public class A extends B {
    public static void test(){
        System.out.println("A=>test()");
    }

}

package Base_Grammer;

public class B {
    public static void test(){
        System.out.println("B=>test()");
    }
}


package Base_Grammer;

public class Test {
    public static void main(String[] args) {
        //现在看来方法的执行与定义的对象类型有关
        A a = new A();
        a.test();//A=>test()
        //父类的引用指向子类
        B b = new A();
        b.test();//B=>test()
    }
}

    去掉static关键字，用ctrl+o的快捷键重写父类方法

    package Base_Grammer;

public class A extends B {
    @Override//重写的功能注释
    public void test() {
        System.out.println("A=>test()");
    }
}

package Base_Grammer;

public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}


package Base_Grammer;

public class Test {
    public static void main(String[] args) {
        A a = new A();
        a.test();//A=>test()
        //父类的引用指向子类
        B b = new A();//子类重写了父类方法
        b.test();//A=>test()
        //因此只有非静态方法才能被重写
    }
}

总结

在这里插入图片描述

多态

//举几个例子来说好了
//一个对象的实际类型是确定的
//如new Student(),new Person()...
//但可以指向的引用类型就不一定了，如父类的引用指向了子类
//1.子类可以调用自己独有的和继承父类的方法
Student student = new Student();
//2.父类的引用虽然可以指向子类，但父类只能调用自己的方法（调子类的方法也不是不行，类型强转一下），并且，一旦方法被从写，这样定义的父类引用会执行子类重写后的方法，见总结上边的例子
Person person = new Student();
Object object = new Student();

类型转换

关键字：instanceof

x instanceof y来表明x与y是否有继承关系
  1. 父类转子类是要强制转换
  2. 子类转父类，可能丢失自己的一些方法

static关键字详解

  1. 静态变量可以通过类名来访问

  2. 静态方法可以通过类名来执行

  3. 静态方法只可以调用静态方法

  4. 静态代码块：类加载执行一次，且只执行一次，可以用来赋初始值

    static{
    //静态代码块
}

  5. 静态导入包

    import static java.lang.Math.random;
//这样可以直接用random()函数，不用加Math. 但一般没有这么做的

抽象类

关键字：abstract

package Base_Grammer;
//1.抽象类不能new,要考子类去实现它
//2.抽象类中可以有普通方法，但是抽象方法只能在抽象类中
//3.缺点就是，类只能单继承，一个儿子只能有一个爸爸，但接口可以多继承
public abstract class Action {
    //抽象类中的抽象方法，只有方法名字，没有方法的实现
    public abstract void run();
}

package Base_Grammer;

public class A extends Action {
    //子类必须要重写父类抽象方法
    @Override
    public void run() {

    }
}

【思考】抽象类含有构造器吗？

​ 答：抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法。

接口

关键字:interface,implements

  1. 实现了接口的类必须实现接口中的方法
  2. 接口中的方法默认是 public abstract的
  3. 接口中的常量是public static final类型的，但我们一般不定义常量
  4. 接口可以多继承：implements关键字

内部类

  1. 成员内部类

    package Base_Grammer;

public class Outer {
    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //内部类还可以获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}


package Base_Grammer;

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();

    }
}

  2. 静态内部类

    将上边的Inner类加上static修饰，这样会导致内部类无法获得外部类的私有属性

    package Base_Grammer;

public class Outer {
    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public static class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //内部类还可以获得外部类的私有属性
        public void getID(){
            System.out.println(id);//这里会报错滴
        }
    }
}

  3. 局部内部类

    package Base_Grammer;

public class Outer {
    //局部内部类
    public void method(){
        class inner{
            public void in(){

            }
        }
    }
}

  4. 匿名内部类

    package Base_Grammer;

public class Test {
    public static void main(String[] args) {
        //没有名字的初始化类，不用将实例保存到变量中
        new Apple().eat();
        new Userservice(){

            @Override
            public void hello() {
                
            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("eat");
    }
}
interface Userservice{
    void hello();
}

异常机制

Java分为两类，错误Error和异常Exception,异常可以抛出处理

快捷键：选中要抛出异常的部分，然后ctrl+alt+t

1.try,catch,finally

package Base_Grammer;

public class Test {
    public static void main(String[] args) {
       int a = 1;
       int b =0;
       try {//try监控区域
           System.out.println(a/b);
       }catch (ArithmeticException e){//catch捕获异常，参数为想要捕获的异常类型
           System.out.println("变量b不能为零");
       }finally {//处理善后工作
           System.out.println("finally");
       }
       //finally可以不要，但一般要写，比如关闭一些资源流的时候，如I/O流
        //假设要捕获多个异常，一定要从小到大捕获,不然会报错
        try{
            System.out.println(a/b);
        }catch (Error e){
            System.out.println("error");
        }catch (Exception e){
            System.out.println("exception");
        }catch(Throwable t){
            System.out.println("throwable");
        }finally {//处理善后工作
            System.out.println("finally");
        }
    }
}

2.throw,throws

package Base_Grammer;

public class Test {
    public static void main(String[] args) {
        try {
            new Test().test(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();//这里是打印错误栈信息
        }
    }
    //假设这方法中，处理不了这个异常，方法上抛出异常
    public void test(int a,int b) throws ArithmeticException {
        if (b == 0) {
            //知道这里必定出错，主动抛出异常，一帮在方法中使用
            throw new ArithmeticException();
        }
        System.out.println(a / b);
    }
}

3.自定义异常

只要继承Exception类就行

package Base_Grammer;

public class MyException extends Exception {
    //假设数字大于10就产生异常
    private int detail;
    public MyException(int a){
        this.detail = a;
    }
    //为打印信息，添加个toString方法

    @Override
    public String toString() {
        return "MyException{" +
                "detail" + detail +
                '}';
    }
}


package Base_Grammer;

public class Test {
  static void test(int a) throws MyException {
      System.out.println("传递的参数为："+a);
      if(a>10){
          throw new MyException(a);//抛出
      }
      System.out.println("ok");
  }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            //这里还可以增加一些处理异常的代码块
            System.out.println("MyException===>"+e);
        }
    }
}
凌玲翎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java学习day01-day15学习资料
04-05
自学Java的基本资料（资料来自黑马程序员免费提供），本人并无恶意，单纯分享。本资料对应黑马程序员Java从入门到起飞的上半部分的1-15天资料。希望能对你有帮助。如有侵权，请联系删除。
JAVA学习笔记- - - day 1
热门推荐
m0_71956038的博客
11-18 6万+
目录💕前言：作者是一名正在学习JAVA的初学者，每天分享自己的学习笔记，希望能和大家一起进步成长💕​编辑运算符(重要)运算符四则运算基本数据类型变量间的运算赋值运算符比较运算符逻辑运算符(重要)流程控制(重要)1.if2.if...else...3.if...else if...else4.switch 只能做等值判断5.三元运算符6.循环结构while 先判断在做循环do...while 先循环在做判断for循环break面向对象面向过程面向对象类的属性类的方法创建对象的内存结构局部变量成员变量匿名对
JAVA学习笔记- - - day 2
m0_71956038的博客
11-26 5万+
目录💕前言：作者是一名正在学习JAVA的初学者，每天分享自己的学习笔记，希望能和大家一起进步成长💕封装(重点)数组一维数组(重点)二维数组方法的重载(重点)this关键字（重点）构造器（重点）默认构造器有参构造器static关键字（重点）属性上(静态属性/变量)方法上（静态方法）静态代码块设计模式(重点)单例。
学习日志 -- Day02
zixuan226的博客
05-09 2140
java简介、编写规范、变量、数据类型
Day1-Java入门
aiains的博客
06-27 3万+
CMD常用命令； 用CMD运行电脑程序以及对应的环境配置； 用记事本编写helloworld，用CMD运行； Java环境变量的配置； Notepad++的使用； 初步了解JDK和JRE。
Java学习-Day03（运算符）
wanlaizhou的博客
03-29 4222
在java中取模的本质 a % b = a - a / b * b &&短路与: （开发常用） 前面的条件为false，后面的条件不执行不判断，效率高 &逻辑与: 前面的条件为false，后面的条件仍然会判断执行，效率低 ||短路或：（开发常用） 前面的条件为true，后面的条件不执行不判断，效率高 |逻辑或： 前面的条件为true，后面的条件仍然会判断执行，效率低 ！取反：T->F,F->T ^逻辑异或： 相同为真，不同为假 赋值运算符： = ， += ， -.
java-ee-ssm-day-two-master.zip
06-28
Java学习资料&项目源码&教程等资源
Java入门基础学习资料day09-10
10-22
此java基础课程，适合0基础小白，课程一共11天课时，目录如下： day01【前言、入门程序、常量、变量】 day02【数据类型转换、运算符、方法入门】 day03【流程控制语句】 day04【 Idea、方法】 day05【数组】 day06...
Java入门基础学习资料day07-08
10-22
此java基础课程，适合0基础小白，课程一共11天课时，目录如下： day01【前言、入门程序、常量、变量】 day02【数据类型转换、运算符、方法入门】 day03【流程控制语句】 day04【 Idea、方法】 day05【数组】 day06...
Java入门基础学习资料day05-06
10-22
此java基础课程，适合0基础小白，课程一共11天课时，目录如下： day01【前言、入门程序、常量、变量】 day02【数据类型转换、运算符、方法入门】 day03【流程控制语句】 day04【 Idea、方法】 day05【数组】 day06...
关于Ribbon在SpringCloudAlibaba2021.1版本中，找不到服务实例
aoxiaojun的博客
04-12 361
关于Ribbon在SpringCloudAlibaba2021.1版本中，找不到服务实例
java面向对象.day21（继承02--super）
BaiZhuYuan的博客
04-14 597
super===父this===当前使用super时，首先要继承父类，其次是在子类里面才能使用super。继承父类后，运行子类时会同时调用父类的构造方法，如果要显性调用父类的构造方法必须在子类的第一行调用。单使用super()表示调用父类构造方法，单使用this()表示调用本身的构造方法。父类具有有参的构造方法时，并且没有显性无参构造方法，那么子类要使用时必须直接调用父类的有参构造方法，
SpringBoot整合javaMail
weixin_62513677的博客
04-13 539
快速掌握springboot邮件的发送
互联网大厂ssp面经（操作系统：part1）
qq_41214208的博客
04-11 944
互联网大厂ssp面经，操作系统：part1
Mybatis 中的延迟加载，以及原理
weixin_40587144的博客
04-15 286
Mybatis 中的延迟加载，以及原理
SpringBoot通用模块--文件上传开发（阿里云OSS）
qq_42736179的博客
04-09 1204
在sky-server模块注意冒号后面有空格！！！application-dev.yml（开发环境下的配置文件，yml可以引用该文件的值，这样就不用把值写死）sky:alioss:spring:profiles:active: dev #设置环境sky:alioss:细节：application-dev.yml是开发环境下的配置文件，yml可以引用该文件的值，这样就不用把值写死在sky-server模块中定义接口/*** 通用接口*/
Java IO流-字节流
最新发布
qq_40603125的博客
04-15 323
上述两两结合一下，就得到四种大的分类。使用循环一个个字节输入。
Java学习Hutool工具库中的DateUtil工具类
李长渊的博客
04-09 1373
Java学习Hutool工具库中的DateUtil工具类
Spring框架第一篇（Spring概述与IOC思想）
Du_XiaoNan的博客
04-13 1082
Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用 Spring 框架来创建性能好、易于测试、可重用的代码。 Spring 框架是一个开源的 Java 平台，它最初是由 Rod Johnson 编写的，并且于 2003 年 6 月首 次在 Apache 2.0 许可下发布。 官网：[https://spring.io/](https://spring.io/)
springmvc 音频流输出_Java高级框架 - SpringMVC学习(02) Day08
05-26
```java @RequestMapping("/audio") @ResponseBody public ResponseEntity[]> getAudio() throws IOException { // 读取音频文件字节数组 InputStream in = getClass().getResourceAsStream("/static/audio/sample...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值