JavaSE 02笔记流程控制、面向对象和异常

最新推荐文章于 2022-09-14 19:17:43 发布

甜心小宇yu丶

最新推荐文章于 2022-09-14 19:17:43 发布

阅读量251

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/weixin_43744709/article/details/107785936

版权

JavaSE 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

流程控制

Scanner
scanner扫描器对象用于接收键盘数据 ; 判断是否还有输入程序会等待用户输入
凡是IO流的类用完了之后关闭以节约内存和空间
scanner.next()
一定读取到有效字符才可以结束输入 ; 以空白为结束符 ; next()不能得到带有空格的字符串
scanner.nextLine() // 用的多
以enter为结束符 , 把enter之前所有的字符的返回 ; 可以获得空白
用户输入 : system in
eg:
scanner.hasNext()
scanner.hasNextInt() // 输入的是整数
scanner.nextInt()

补充 :
字符的本质还是数字
每一个对象都有一个hashCode

IDEA：
100.for 回车
psvm 回车
Java - class (字节码文件) IDEA可以反编译 class文件打开可以看反编译文件
alt + insert 生成构造器等 select none => 生成无参

三大结构
顺序结构 :

默认程序结构,自上而下

选择结构 :

  单选择结构 if  			  
  双选择结构 if - else 			  
  多选择结构 if - else if - else if  			  
  switch-case : 支持String , case穿透现象用break终止

循环结构 :

  while循环 			
  do while循环 至少执行一次循环体 			
  ★for循环 (常用)
  增强for循环 jdk1.5 for(int x : numbers)

注 : break 跳出循环 ; continue 终止本次循环 ; return结束方法运行

方法

方法定义 :修饰符返回值方法名(参数名){return 返回值;}

方法的不成文规范 : 原子性一个方法只做一个事，便于拓展和维护

方法调用 :
1.类变量类名.方法（实参列表）
2.对象对象.方法（实参列表）

方法重载 :
名字相同,参数列表不同

★命令行传参 : 给main传递参数 jvm调优时候用

可变参数 :
…
1.必须放在参数的最后才可以
2.只能有一个
递归
自己调用自己,给自己一个出口
注 : 递归降低性能，小数据量行，掌握递归的思想即可

数组

定义 :
1.动态初始化 - 包含默认初始化例:int类型数组里默认的元素是0
eg: int [] array = new int[5] ;
2.静态初始化 - 创建 + 赋值
eg: int [] array ={1,2,3,4,5} ;

默认初始化的值(补充):
数字:0 , 0.0
char: u0000
boolean: false
引用: null

前提 : 必须是同一类型

使用 : 使用下标进行定位元素注 : 不要下标越界

**遍历数组 ** :

//JDK 1.5 没有下标
for(int arr : array){
 System.out.println(array);
}
//手写reverse()方法
for(int i =0 , j=result.length-1 ; i<array.length ; i++ , j--){
result[j] = arrays[i];
}

二维数组 :
1.动态初始化 int [][] array = new int[][] ;
2.静态初始化 int [][] array = {{1,2},{3,4},{5,6}} ;

多维数组:
数组的数组（数组里嵌套数组）

稀疏数组:
压缩数组节约空间的思想

工具类 :
Array类 Java.util.Arrays; util是工具包的意思
利用工具类避免重复造轮子

★排序 :
冒泡排序
选择排序
插入排序
快速排序
归并排序
希尔排序
堆排序
基数排序

面向对象

意义 : 模拟世界

OOP :
以类的方式组织代码 , 以对象的组织(封装)数据.

类和对象的关系 :
类(class)是对象的抽象 , 对象是一个类的具体实例
类相当于模板
eg:
小明(对象) - 学生(类)
别克(对象) - 汽车(类)

★构造器(构造方法) :
构造器 (1.与类名相同 , 2.没有返回值)
作用:
1.使用new关键字,本质是在调用构造器
2.用来初始化对象的值
默认有无参构造方法
如果手动定义了有参构造 , 无参构造失效 , 就必须要手动再加一个无参构造(否则报错!)

new对象
new关键字创建对象赋值给实例
栈 - 引用
堆 - 具体的对象
对象内存分析(粗略)
main() 在栈里
栈里面 - 引用变量[在堆中开辟一块内存空间] 和 main()
方法区 - 在堆里面
静态方法区 - static 和类一起加载

程序的追求目标:
高内聚低耦合

static
执行顺序 :

public class Demo03 {
    //第二加载；适用于赋初值
    {
        System.out.println("匿名代码块");
    }
    //第一加载；只在第一次执行
    static{
        System.out.println("静态代码块");
    }
    //第三加载
    public Demo03() {
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
        Demo03 s1 = new Demo03();
        System.out.println("==========");
        Demo03 s2 = new Demo03();
    }
}

静态导入包 :

import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Demo03 {
    public static void main(String[] args) {
        System.out.println((int)(Math.random()*50));
        //random()随机值，整数，范围（0-50）
        //使用静态导入包后可以直接System.out.println(random());
        System.out.println(PI);
    }
}

抽象类
abstract 修饰符修饰的方法或者类就是抽象方法和抽象类
“Abstract method in non-abstract class”
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
在这里插入图片描述
抽象类，不能new创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法；否则该子类也要声明为抽象类，然后由子子类实现抽象方法。
报错“Missing method body, or declare abstract”

★接口
理解 :
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：interface
只有规范！自己无法写方法，专业的约束！约束和实现分离：面向接口编程~
接口的本质是契约
就像我们人间的法律一样。制定好后大家都遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口 (详细看设计模式)

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。
eg : “如果你是天使，则必须能飞。如果你是汽车，则必须能跑。”

作用：
约束，规范
定义一些方法，让不同的人实现。多个人完成共同的工作。
接口中所有默认的方法public abstract
所有常量默认public static final
接口不能被实例化，接口中没有构造方法。
可以实现多个接口
必须要重写接口中的方法。
声明接口interface,实现接口implements，可以实现多个方法

内部类:
内部类就是在一个类的内部在定义一个类，eg : A类中定义一个B类，那么B累相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

用途 : 通常是为了实现多重继承

1.成员内部类 (类中加类)
内部类可以获得外部类的私有属性

//先实例化外部类，再用外部类实例化内部类
Outer outer = new Outer();//new外部
Outer.Inner inner = outer.new Inner();//new内部
inner.in();

2.静态内部类不能直接访问非静态的属性（static先与非静态类生成）
3.局部内部类

public void method(){
    class inner{
        public void in(){
            
        }
    }
}

4.匿名内部类没有名字去初始化类，不用将实例保存到变量中

//不起名直接使用
new Apple().eat(); 
//new接口
class Test{
    public static void main(String[] args) {
        new UserService(){
            
        };
    }
}
interface UserService{
    
}

面向对象三大特性 - 封装

定义:
封装即为数据的隐藏,应禁止直接访问一个对象中数据的实际显示,而是通过操作接口来访问

实现:
private 私有的
get(获得数据)方法 set(给数据赋值)方法私有属性提供一些可以操作属性的方法
get/set方法可以设置条件,规避一些不合理数据
eg:比如set为空就是只读属性

作用:
1.提高程序安全性保护数据
2.隐藏代码的实现细节
3.统一接口
4.提高系统的可维护性

面向对象三大特性 - 继承

定义 : extends ; Java只有单继承,没有多继承

作用 : 对某一批类的抽象,从而实现对现实世界更好的建模

注意点 :
1.父类(基类) 子类(派生类) is a 的关系
2.子类继承父类,就会拥有父类的全部方法(前提都是public)
3.Java默认直接或间接继承Object类

super - this
this 调用当前类，super 调用父类。
super注意点：
super 调用父类的构造方法，必须在构造方法的第一个
super 必须只能出现在子类的方法或者构造方法中!
super 和 this 不能同时调用构造方法！

方法重写
Override
重写都是方法的重写，和属性无关。
重写值和非静态方法有关，静态没用，只能 Public 。静态的方法和非静态的方法区别很大
需要有继承关系，子类重写父类的方法！
注:
重写，子类的方法和父类必须一致，方法名必须相同参数列表必须相同 ; 但方法体不同！
修饰符：范围可以扩大，但不能缩小；public > protected > Default > private
抛出的异常：范围，可以被缩小但不能扩大；ClassNotFoundException <— Exception(大)

补充:
四个修饰符 (★通常方法都不是私有的,属性通常是私有的!)
public
protected
default
private

Java默认直接或间接继承Object类

面向对象三大特性 - 多态

表现:
父类的引用可以指向子类，但不能调用子类独有的方法。
方法的调用只和左边定义的数据类型有关，和右边关系不大。

动态编译：
类型：可扩展性更强
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）

多态存在的条件
有继承关系
子类重写父类方法
父类引用指向子类对象

注：
多态是方法的多态，属性没有多态性
父类和子类，有联系才能转换，不然会异常！类型转换异常：ClassCastException
存在条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1 = new son();

不能重写的方法：
static 方法，属于类，它不属于实例
final 常量，被final修饰的无法修改，属于常量池
private 私有方法，不能被重写

instanceof 判断一个对象是什么类型。（类型转换—引用类型之间的转换）
System.out.println（x instanceof y）; ：true or false （能不能编译通过，看x所指向的实际类型是不是y的子类型）

注：
父类引用指向子类的对象，不可以子类引用指向父类。
把子类转换为父类，向上转型；
把父类转换为子类，向下转型，强制转换
方便方法的调用，减少重复的代码，简洁

//类型之间的转化 ： 父---子
//高               低
Person s1 = new Student();
//高转低可以直接转；低转高，需要强制转
//
Student s2 = (Student) s1;
s2.go();
//或((Student) s1).go();

异常

定义 :
Exception，意思就是例外。例外情况，或者叫异常，怎么让我们写的程序做出合理的处理，而不至于程序崩溃。

Error 和 Exception 的区别：
Error 通常是灾难性的致命错误，是程序无法控制和处理的，当出现这些异常时，Java 虚拟机（JVM）一般会选择终止线程；Exception 通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这类异常。

异常体系 :
在这里插入图片描述
异常处理机制
抛出异常
捕获异常
异常处理五个关键字
try、catch、finally、throw、throws
可以当出现异常时，捕获它，防止程序停止。

public static void main(String[] args) {
    int a = 1;
    int b = 0;
    //假设要捕获多个异常：从小到大！
    try {   //try 监控区域
        System.out.println(a / b);
    } catch (Error e) {   //catch（想要捕获的异常类型！）捕获异常
        System.out.println("Error");
    }catch (Exception e){//“e”,代表异常消息
        System.out.println("Exception");
    }catch (Throwable t){
        System.out.println("Throwable");
    }finally {    //处理善后工作，不管报不报异常，都会执行。
        System.out.println("finally");
    }
    //finally 可以不用，但是catch必须有。finally假设Io,资源，关闭工作
    //快捷键：选中需要包裹的代码，ctrl+alt+T
    /*
      try {
        System.out.println(a / b);
    } catch (Exception e) {
        System.exit(0);//程序结束
        e.printStackTrace();//打印错误的栈信息
    } finally {
    }
     */
}

throw

try {
    if (b==0){
        throw new ArithmeticException();//主动的抛出异常
    }

throws

public static void main(String[] args) {
    try {
        new linshi().test(1,0);
    } catch (ArithmeticException e) {
        e.printStackTrace();
    } finally {
    }
}
//假设这个方法中，处理不了这个异常。方法上抛出异常throws，由上一级捕获。
public void test(int a,int b)throws ArithmeticException{
    if (b == 0) {
        throw new ArithmeticException();//throw 主动的抛出异常,一般在方法内
    }
    System.out.println(a / b);
}

自定义异常
视实际情况而定
自定义异常类

//自定义异常类
    //假设传递数字>10异常
    private int tishi;//创建一个提示信息

    public Demo01(int a) {//创建一个构造器传递消息
        this.tishi = a;
    }
    //toString打印信息：异常的打印信息
    @Override
    public String toString() {
        return "异常{" + "tishi=" + tishi + '}';
    }

throws抛出方法捕获

//创建一个可能会存在异常的方法
   static void test(int a) throws Demo01 {
        System.out.println("传递的参数为："+a);
        if (a>10){
            throw new Demo01(a);
        }
        System.out.println("ok");
    }

    public static void main(String[] args) {
        try {   //赋值并捕获
            test(11);
        } catch (Demo01 e) {
            System.out.println("注意："+e);
        }
    }

throw方法内捕获

//创建一个可能会存在异常的方法
static void test(int a) {
    System.out.println("传递的参数为："+a);
    if (a>10){
        try {
            throw new Demo01(a);
        } catch (Demo01 e) {
            System.out.println("注意："+e);;
        }
    }
    System.out.println("ok");
}
public static void main(String[] args) {
    test(16);   //赋值
}

甜心小宇yu丶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE 02笔记流程控制、面向对象和异常

流程控制Scannerscanner扫描器对象用于接收键盘数据 ; 判断是否还有输入程序会等待用户输入凡是IO流的类用完了之后关闭以节约内存和空间scanner.next()一定读取到有效字符才可以结束输入 ; 以空白为结束符 ; next()不能得到带有空格的字符串scanner.nextLine() // 用的多以enter为结束符 , 把enter之前所有的字符的返回 ; 可以获得空白用户输入 : system ineg:scanner.hasNext()scanner
复制链接

扫一扫