二刷java {2020年7月20日22:33:58}

于 2020-07-13 22:23:42 发布
阅读量262 收藏
点赞数
分类专栏： 第一天 新手上路 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46025049/article/details/107326610
版权

一、Java入门

常用dos命令

返回上一级  cd..
进入文件夹：cd 文件名   
盘符切换：盘符:
查询所在文件夹所有文件：dir
新建文件： cd>文件全名
删除文件：del 文件全名
新建文件夹：md 文件夹名
移除文件夹：rd 文件夹名
清屏： cls
退出窗口： exit
查看电脑IP：ipconfig（需管理员权限）

打开应用：
计算器： calc
画图： mspaint
新建记事本：notepad

网址IP获取：ping 网址

1、java的特性和优势

  • 简单性

  • 面向对象

  • 可移植性

  • 高性能

  • 分布式

  • 动态性

  • 多线程

  • 安全性

  • 健壮性

2、java的三大版本

JavaSE：标准版（桌面程序、控制台开发…）核心

JavaME：嵌入式开发（手机、家电…）夕阳红

JavaEE：E企业级开发（web开发、服务器开发）使用量三者最高

3、JDK、JRE、JVM

  • dk：java代码工具（编译）

  • jre：java的运行环境（生存）

  • jvm：实现java跨平台的核心

**三者关系：**jdk<jre<jvm

4、JDK的安装与配置

详情点这里

一次配置，理论永久使用。

  • 安装配置玩之后，一定要检测：打开dos命令框：java version
  • 成功图：（有问题在去点一下“这里”）[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j9op53Ax-1594649177288)(C:\Users\000\AppData\Roaming\Typora\typora-user-images\image-20200713095620975.png)]

有些坑，不去走一遭，你永远不会知道，里面的世界有多精彩。

  • 有助于记忆加深

5、java的运行机制

  1. 手动写出的代码

  2. 通过java编译器编译后

  3. 生成计算机可以理解的数据文件

  4. 通过jvm的解释给计算机执行

二、java基础

1、注释

  • 注释并不会被执行，写注释是为了让我们短时间内回忆起代码功能。

    注释三种

    ①单行注释
  //单行注释
②多行注释
/*
  多行注释
 */
③文档注释
/**
 * 文档注释
 *
 * */

2、标识符、关键字、数据类型

①标识符命名规则

  • 以字母（大小写）、美元符（$）、下划线（_）开始。

  • 首字母以后可以是字母大小写、美元符、下划线或任何数字组合。

  • 不能使用关键字作为标识符。

  • 表示符要严格区分大小写。

②关键字1

在这里插入图片描述

③数据类6型

数据类型分为两大种：基本数据类型、引用数据类型

基本数据类型（primitive type）

  • 整数类型

    • byte

  • short

    • int （默认值为0）

  • long ：

    long l=100l;//使用时须在赋值末尾加上'L'声明。

*进制:注意看整数的本身和开头

二进制（0b开头）、八进制(0开头)、十进制 、十六进制（0x）

  • 浮点类型2

    • float

      float f=3.14f;//使用时必须在赋值末尾加上'F'声明。

    • double（默认值为0.0）

  • 字符型

    • char：长度占2个字节

      • dhar c='A';
//char类型是可以运算的因为char在ASCII等字符编码表中，有对e应的数值。对char类型字符运行时，直接当做ASCII表对应的整数来对待。

  • boolean类型

    • 默认值为flase，只有两个值（flase、true）

      		boolean b=fiase;
        boolean d=flase;
        System.out.println(d==b);
//两个boolean数据对比时，同为flase、true时结果就为true，反之不同则为flase。
引用数据类型3 （reference type）

  • 类

  • 接口

  • 数组

*字节：

  • 位（bit）：是计算机内部数据储存最小的单位，习惯用小写b表示。

  • 字节（byte）：是计算机中数据处理的基本单位，习惯用大写B来表示。

  • 1B=8bit、1k=1024B

*字符：
  • 是指计算机中使用的字母、数字、字、符号、

3、数据类型转换

  • 在这里插入图片描述
类型转换（两种）

①自动装换：由高到度

②强制装换：由低到高

int i1=10;
byte b=(int)i1;
*注意

  • boolean不能转换

  • 不能瞎转（一个胖子通过减肥可以成为瘦子，无法变成牲口不是)

  • 转换过程中可能存在内存溢出、精度丢失的问题！

内存溢出案例

//        数据类型的转换
        //年薪
        int i1=10_0000_0000;//jdk7版本的新特性数字中加入下划线不会影响输出方便数数。
        //工作年数
        int i2=20;
        // 计算工资总和（一）
System.out.println("计算工资总和（一）");
        int i3=i1*i2;
        System.out.println(i3)
   //输出结果：-1474836480
        //结果数据溢出数据类型最大值
System.out.println("计算工资总和（二）");
        long l1=i1*i2;//计算的时候已经溢出
        System.out.println(l1);
	//输出结果还是：-1474836480
        //结果还是不对，原因：代码执行的顺序，先计算，在赋值，在计算过后得出的还是int类型
System.out.println("(三)");
        long l2=i1*(long)i2;
        System.out.println(l2);
	//输出结果：20000000000
        //答案正确

精度丢失案例

//精度丢失案例
double d33=3.1;
int i=(int)d33;
System.out.println(i);
//输出结果：3

4、变量、常亮、作用域

  • 修饰符的顺序，对代码的运行没有影响。
常量：（关键修饰符 final）

  • 初始化后不能在改变！！！

    //语法示例：
final int aa=1;
变量：
  • 牵扯到空间分布，后头补上
//语法示例：
    String name ;
	int age;
	double dd;
	char cc;
	boolean bb;

  • 局部变量：在方法内声明的变量，必须初始化，才可以调用。作用域：最近的一组大括号内。

  • 实例变量：从属于对象，不初始化的话，是默认为数据类型的默认值。(在方法体内new出，才可以调用)

  • 类变量：在对象主方法内用static修饰符，修饰的变量。（可以在全文内直接调用！）

    //示例：
static String xm="lyx";
变量的命名规范

在这里插入图片描述

作用域：
  • 代码的作用（生存）范围

5、运算符

①算术运算符

  • +、-、*、/、%、++、–

  • ++、–运算符：运算符在前，先赋值在运算，在后先运算在赋值

  //示例：	 
        int i=4;
        int p=i++;//++在前先赋值在运算。
        System.out.println(i);
        int q=++i;//++在后先运算在赋值。
        System.out.println(p);
        System.out.println(q);
        //输出：4、6
②赋值运算符：

  • =

  • 运算顺序是从左往右的顺序，把运算符左边的值赋值给运算符右侧。

    ③关系运算符

  • ‘>’、<、<=、>=、==、!=

  • 前四个和数学同义

  • **==：**两个数字比较是否相等的运算符

  • **!=：**表示不等的关系运算符。

④逻辑运算符
  • && 、||、 ！ 分别对应与、或、非(反意)
Boolean a=false;
Boolean b=true;
System.out.println("a&&b:"+(a&&b));
//运算符两侧都为true，结果才为true，如果右侧为false，则不再计算左侧真假。
System.out.println("a||b:"+(a||b));
//运算符两侧有一侧为true，结果就为true;如果右侧为true，则不再计算左侧真假。
System.out.println("!(a||b):"+!(a||b));
/* 输出：a&&b:false
	    a||b:true
        !(a||b):false
*/
⑤位运算符

  • &、|、^、~、<<、>>、>>>(用于二进制运算)

  • 位运算效率较高

/*
 A = 0011 0100`在这里插入代码片`
 B = 0100 1101
------------------------
 A&B = 0000 0100 //两个同位数二进制数字，对比同位数的数字是否相同 相同为1，否则取0。
 A|b = 0111 1101 //两个同位数二进制数字，对比同位数的数字是否相同 从同为0，不同为1。
 A^B = 0111 1010 //两个同位数二进制数字，对比同位数的数字是否相同 相同为0，不同为1。
  ~B = 1011 0010 // 相对于B取{0、1}的反值（1取0,0取1）
* */
  • 面试题：高效计算2的3次方？
   //高效计算2的3次方？
  System.out.println(2<<3);   	//2在二级制里是0000 0010，16在二进制中是0001 0000，在2的基础上左移的3位//输出：16
⑥扩展运算符

  • +=、-=、*=、/=

        int a=1;
    int b=2;
    b+=a;// b=b+a
    b-=a;// b=b-a
    b*=a;// b=b*a
    b/=a;// b=b/a
    
    System.out.println(b);
}
⑦三元运算符
//格式：条件?结果1:结果2;
int a=6;
String s=a>10?"大于10":"小于10";
System.out.println(s);
//输出：小于10
⑧包机制
  • 一般利用公司域名倒置作为包名。
⑨javaDoc
  • 用来生成自己APL文档

三、工具类

①输入函数Scanner4
  • //语法：
Scanner sc = new Scanner(System.in);
String name = sc.next();
sc.close();//关闭IO流节约资源。

  • 通过Scanner类中next()与nextLine()方法获取控制台输入的字符串。

  • next()与nextLine()方法的区别：前者默认空格运行到空格停止接收，而后者运行到空格，继续接受空格后的数据。

四、结构

①顺序结构

  • 最基本的算法结构

  • 语句与语句，框与框从上到下的顺序一一执行

    System.out.println("1111");
System.out.println("2222");
System.out.println("3333");
System.out.println("4444");
System.out.println("5555");
/*输出：1111
	   2222
	   3333
	   4444
	   5555
*/
②单、双、多if结构

  • 单选择

    if(boolean表达式){
    //如果Boolean结果为true,将会执行循环体内的语句。
}

  • 双选择

    if(boolean){
    //如果Boolean结果为true,将会执行这个循环体内的语句。
}else{
   // 如果Boolean结果为false,将会执行这个循环体里的语句。
}

  • 多选择

    if(boolean1){
    //如果Boolean结果为true,将会执行这个循环体内的语句，并结束跳出if判断语句！
    //如果为false则继续按照顺序结构接着往下运行。
}else if(boolean2){
    //如果Boolean2结果为true,将会执行这个循环体里的语句，并结束跳出if判断语句！
     //如果为false则继续按照顺序结构接着往下运行。
}else if(boolean3){
    //如果Boolean3结果为true,将会执行这个循环体里的语句，并结束跳出if判断语句！
     //如果为false则继续按照顺序结构接着往下运行。
}else{
    //如果上方Boolean（1~3）结果都为false,将会执行这个循环体里的语句，并结束跳出if判断语句！
}
③Switch选择结构
//语法示例
System.out.println("请输入大于0小于6的int：");
Scanner scanner = new Scanner(System.in);
int sc=scanner.nextInt();
//switch循环：匹配一个值。
//能够使用的变量类型：byte、short、int、char、String(五种)
switch (sc){
    //case标签只能接收字符串常亮或字面量
    case 1://匹配条件标签
          System.out.println("输入的是"+sc);
          break;//跳出循环
    case 2:
          System.out.println("输入的是"+sc);
          break;
    case 3:
          System.out.println("输入的是"+sc);
          break;
    case 4:
          System.out.println("输入的是"+sc);
          break;
    case 5:
          System.out.println("输入的是"+sc);
          break;
    default://以上case都没有匹配成功，执行这里的代码！
        System.out.println("输入超出范围！");
}
④循环结构（while、do…while、for）

  • while循环

    //语法：
while (boolean表达式){
    //当boolean表达式结果为false时break
}

  • do…while循环

    • 先循环、后判断。
    int a=1;
do {
    a++;
}while (a<1);
System.out.println(a);
//输出：2

  • For

    for (初始变量;boolean表达式;递归){
      //  bolean表达式结输出为ture，执行这里的代码，为false，退出
}
*嵌套

  • 与多选择结构相比，嵌套运算要快很多

  • 所有的语句、循环都可以嵌套使用

    //嵌套的if结构示例
int i=11;
if(i>5&&i<20){
    if(i>10&&i<20){
        System.out.println("i="+1);
    }
}

五、方法

  • 命名：小驼峰命名规则

  • 理解：方法包含在对象或类中，在程序中被创建，在其它地方被引用。

  • 原则：保持原子性，一个方法只能完成一个功能，便于后期的扩展。

①定义：

//方法的定义
修饰符 返回值类型 方法名(参数){
    				//形式参数：接受传递给方法的数据。  实参：传如方法的数据
            方法体。
        return 返回值;//不需要返回之时，需要void声明
    }

②调用：

public static void main(String[] args) {
		a();
	}
//创建一个输出“已调用”字符的方法a
		public static void a(){
 		   System.out.println("已调用");
		}
//在方法内使用static修饰符的方法，可以直接调用
//没有static修饰的方法，需要先new到方法所在的类

③重载：

  • 规则： 方法名必须 一致、参数的属性不能一致。

  • 实现理论： 方法名相同时，编译器会根据方法参数的个数、位置、类型等逐个去配对，选择方法。（如果都匹配不上，则编译器报错）

    public static void main(String[] args) {
       add(1,3);
       add(1.5,1.2);
    }
    public static void  add(int i,int a){
        System.out.println(i+a);
    }
    public static void  add(double i,double a){
        System.out.println(i+a);
    }
    //输出：4  2.7
}

④可变参数：

 //可变参数             such：这样的
 					// 可变参数：必须在参数栏最后，声明方法：参数类型... name（三个英文句号 ），接受的数据类型必须一致。
    public  static  void such(int... i){
        //  通过下标匹配
        System.out.println(i[0]);
    }//输出：1

⑤递归

  • 结构：
    • 递归头：什么时候不调用自身的方法，如果没有头，将陷入死循环。
    • 递归体：什么时候需要调用自身的方法。
  • 定义示例：
    //一般而言，兔子在出生两个月后，就有繁殖能力，一对兔子每个月能生出一对小兔子来。如果所有兔子都不死，那么一年以后可以繁殖多少对兔子？
public  static int Dome12(int i){
    if (i==1) {
        return 1;
    } else if(i==2){
        return 2 ;
    }else {
        return  Dome12(i-2)+Dome12(i-1);
    }

六、数组

1.特点

  • 数组是相同数据类型（包括引用类型）的有序集合

  • 数组的大小初始化之后 无法更改 。

  • 数组元素类型必须一致， 不能出现混合类型 。

  • 数组对象本身是在堆中。

  • 数组也是对象，数组元素相当于对象的成员变量。

2.语法

//数组的创建
int[] add;//常用的创建方法
int aaa[];//不常用的创建方法
//数组的初始化
add =new int[10];
  • .length:获取数组下标

3.初始化

//动态初始化：先声明一个数组并分配空间，在逐一赋值
int[] a1=new int[10];
a1[0]=1;

//静态初始化：声明一个数组，并填充数组数据
int [] a2={1,2,3,4,5,6,7,8,9,10};

//默认初始化：声明数组、分配空间，不赋值，数组元素默认为 类型默认值
int[] a3 =new int[10];

4.内存分析

5.数组的使用

/*  1，for循环打印、获取等操作数组
    2.for-each循环遍历出数组，无法获取下标等操作数组
    3，数组入参
    4，数组作返回值
* */
public static void main(String[] args) {
    int[] a={1,2,3,4,5,6,7,8,9,10};
   add(add3(a));
}
//遍历出数组的方法
public static void  add(int[] i){
    for (int s:i){
        System.out.println(s);
    }
}
//数组做返回值 计算数组和

public static  int add2(int[] i){
    int a=0;
    for (int b=0;b<i.length;b++){
        a+=i[b];
    }return a;

}
//数组翻转
public static  int[] add3(int[]i){
    int[] a =new int[i.length];
    for(int e=0,t=i.length-1;e<i.length;e++,t--){
        a[t]=i[e];
    }
    return a;
}

6.二维数组

    //二维数组:数组套数组，数组里的每一个数组元素，都是一个数组
    int[][] a={{1,2},{3,4},{5,6}};
    //遍历方法
    System.out.println(a[0][1]);
    //第一个[]是大数组元素的下标，第二个[]是小数组的下标。
    //输出2

7.Arrays工具类

  • 数组的工具类java.util/Arrays

  • Arrays类中的方法都是static修饰的静态方法，可以直接只用类名调用，也可以使用对象调用

  • Arrays类中常用方法：

    • toString();打印数组

    • fill();数组填充

    • sourt();升序排列数组元素。

    • equals();比较熟组中元素值是否相等。

8.稀疏数组

七、OOP（面向对象）

  • 属性加方法就是一个类。

    本质：以类的方式组织代码，以对象的组织（封装）数据。

  • 三大特性：封装、继承、多肽。

1、方法定义；

修饰符 返回值类型 方法名（参数）{
    方法体
    return 返回值；
}

2、方法的调用；

1.实例化：

        //java中类的实例化是通过new关键字来实现的。
        //对象类型 对象名=对象值；

        //非静态方法的调用方式
        Dome01 d=new Dome01();
                d.stu2();
                
        // 静态方法的调用
        Dome01.stu1();

2.静态与非静态方法的加载时机

//静态方法，和类一起加载的
public static void cc(){
    //！aa();异常
    //因为aa()；是类被实例化的时候加载，所以报错、
}
//非静态方法，在类被实例化的时候加载的
public void aa(){
    bb();
}
public void bb(){
}

3.形参与实参

  • 形式参数要和实际参数要一致。
public static void main(String[] args) {
        Dome03 d = new Dome03();
           //实参：调用方法是传入的参数
        d.add(1,2);
    }
                    //形参：新建方法时传入的参数
    public void add(int a,int b){
        System.out.println(a+b);
}

4.值传递、引用传递

  • **值传递：**bai传递是指在调用函数时将实du际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

  • **引用传递：**接把内存地址传过去，也就是说引用传递时，操作的其实都是源数据，

3、类与对象的创建

1.new：

  • 使用new关键字创建的时候，除了分配空间，还会给创建好的对象，进行初始化以及对类中构造器的调用

2.类的创建

public class Stu {
    //创建类：类是由属性和方法组成的
    //声明方法：修饰符 class关键字 类名{}
    //创建一个stu学生类，还有姓名、年龄的属性，学生玩手机的方法。

    String name;//姓名
    int age;//年龄

    //学生玩手机的方法
    public static void stu_add(){
        System.out.println("学生玩手机！");
    }
}

3.对象的创建

//创建对象对象：类是抽象的，类实例化后会返回一个自己的对象。
//stu对象就是Stu类的具体实例化。
//创建对象示例
public static void main(String [] args){
        Stu stu = new Stu();
        stu.name="张三";
        stu.age=15;
        System.out.println(stu.name);
        System.out.println(stu.age);
        stu.stu_add();
}

4.构造器

public class Dome01 {
    /*
    1、当类中没有构造方法的时候，idea会帮我们自动生成一个默认无参构造器
    2、但是如果在类中声明了有参构造器，idea就不在帮我们自动生成无参构造器
    3、构造器的特点：1.构造器名必须与类名一致
                  2.构造器不能有返回类型和void
    4、构造器的作用：1.new的本质是调用构造器
                 2.初始化对象的值。
     */
    public String name;
    public int age;
    public Dome01() {
    }
    public Dome01(String name, int age) {
        this.name = name;
        this.age = age;
    }
}


 public static void main(String[] args) {
        //使用new关键字实例化Dome01类
        Dome01 dome01 = new Dome01("张三",219);
        System.out.println(dome01.name);
        System.out.println(dome01.age);
    }//输出：张三
            219

* 小结：

1.类是模板、抽象的，对象是一个具体的实例。

2.方法：定义与调用

3.对应的引用：

  • 引用类型、基本类型

  • 对象是通过引用来操作的，是由栈指向堆

4.属性：字段final，成员变量

  • 默认初始化：

    • 数字：0、0.0

    • char：u0000

    • boolean：false

    • 引用：null

5.对象的创建和使用

  • 对象必需要通过关键字new来创建，构造器 类 对象名=new 类（）；

  • 对象的属性：对象名.类中属性名

  • 对象的方法：对象名.类中方法

6.类：

  • 静态属性：属性
  • 动态行为：方法

4、封装

  • 封装是一种隐藏技术，面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

  • 作用：增强了程序的 把对象的私有数据和公共数据分离开，保护了私有数据，减少了可能的模块间干扰，达到降低程序复杂性、提高可控性的目的。

    4.1、封装示例

//封装：关键修饰词  private：私有  Get'set 方法
public class Dome02 {
    //private修饰的属性或方法，只能在本类中引用
    private String name;
    private char sex;
    private int age;
    
    //get \set方法
    //（获取、设置）
    public String getName() {return name;   }
    public void setName(String name) {this.name = name;   }
    public char getSex() {return sex;   }
    public void setSex(char sex) {this.sex = sex;  }
    public int getAge() {return age;  }
    public void setAge(int age) {this.age = age; }
}

4.2、封装的调用

public static void main(String[] args) {
    //实例化封装类
    Dome02 dome02 = new Dome02();
    //调用封装类中，设置属性值的方法。
    dome02.setName("张三");
    //调用封装类中，获取属性值的方法。
    System.out.println(dome02.getName());
}

5、继承

1.关键字extends示例：

  • 私有属性、方法无法继承
  • 在子类的无参构造器中，调用自身或父类的无参构造器，必须在第一行，不能同时存在。
				//Dome03类继承了Dome02类
public class Dome03 extends Dome02{
}
//此时Dome02就是Dome03的父类（基类），Dome03就是子类（派生类）
//一个父类可以有多个子类，但是一个子类只能有一个父类。

2.Object祖父类

  • Object是所有类的父类，任何类都默认继承Object。

6.super与this的用法

###1.注意点：

  • 1.super调用父类的构造方法，必须在构造方法的第一个。

  • 2.super必须只能出现在子类的方法或者构造方法中！

  • 3.super和this 不能同时调用构造方法！

2.代表对象不同：

  • this ：调用自身
  • super：调用父类

###3 .前提：

  • this：没有继承也可以使用
  • super：需要继承了父类才可以调用

4.构造方法：

  • this();引用本身的构造。
  • super();引用父类的构造。

7、方法重写

7.1、为什么需要重写

  • 父类的功能子类不一定需要和满足！

7.2、重写规则

  • 必须要在有继承关系的前提下，子类重写父类的方法。

  • 子类的重写方法必须与父类的方法一致，方法体不同。

  • 方法名与参数列表必须一致。（参数列表不同就变成了重载）

  • 修饰符：范围只能扩大，不能缩小（修饰符范围大小：public>Protected>Default（没有修饰符时，默认Default）>private）

  • 抛出的异常：范围可以缩小，不能扩大。

  • idea重写快捷键：Alt键+Insete键 选择Override Methods

扩展：重写与重载的区别：

1.范围不同：重载的进行，是在同一个类中进行，而重写是子类重写父类的方法。

八、多态

  • 理解：相同的操作，但是在不同的环境中用不同的作用，满足不同的需求。

  • 一个对象的的实际类型是确定的，但可以指向对象的引用类型有很多种。【父类、有关系的类】

  • 父类型引用子类型对象，可以直接调用子类重写的方法，还可以间接调用子类扩展方法

  • 子类型对象，默认调用重写方法。

    //调用示例
//父类型  对象名= new 子类型；
Father s2 = new Son();
s2.方法名();

//调用子类扩展方法示例
((Son)s2).子类扩展方法();

  • 注意：

    • 多态是方法的多态，属性没有多态。

  • 前提：

    • 继承关系
    • 存在重写方法（static、final、private）静态、私有方法和常量不能重写
    • 父类引用指向子类
8.1、instanceof、类型装换

  • 判断对象和类的关系，有关系为true，没有为false。

    instanceof示例：
   public static void main(String[] args) {
        Object object = new Son();
        System.out.println(object instanceof Son);
        System.out.println(object instanceof Father);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof String);
        System.out.println("=================");
        Father father = new Father();
        System.out.println(father instanceof Object);
        System.out.println(father instanceof Father);
        System.out.println(father instanceof Son);
    }//输出结果： true
//              true
//              true
//              false
//        =================
//              true
//              true
//              false
类型转换示例
    //Father父类、Son子类、abb子类里中的扩展方法
	public static void main(String[] args) {
        //父类引用指向子类对象
        Father  son = new Son();
        //调用子类扩展方法，需要大转小（强转）
        //强转注意：可能会造成方法丢失
        ((Son)son).abb();
    }

九、Static修饰符

9.1static属性

public class Stat_01 {
    public static String naem;//静态变量
    public int age;//非静态变量 

    public static void main(String[] args) {
       System.out.println(Stat_01.naem);//从这里可以看到，在方法中可以直接调用static修饰的静态属性
//     System.out.println(Stat.age);//却不能调用非静态的属性。
        
	   //非静态属性的调用
        Stat_01 stat = new Stat_01();
        System.out.println(stat.naem);
        System.out.println(stat.age);
    }
}

9.2、static方法

    //Static 静态方法
    public  static void add(){

    }
    //非静态方法
    public void  aaa(){

    }
public static void main(String[] args) {
    //调用静态方法
    add();//静态方法可以直接调用

    //调用非静态方法
    new Stat_02().aaa();//需要先 实例化建立通道才能使用。
}

9.3、string代码块

  • 代码块与构造无参器的运行顺序
//static代码块
{
    //代码块
    System.out.println("常规代码块！");
}
//只执行一次
static{
    System.out.println("static代码块！");
}

public Dome01() {
    System.out.println("无参构造器！");
}

public static void main(String[] args) {
    Dome01 dome01 = new Dome01();
 }
 //输出结果：static代码块！
 //       常规代码块！
 //       无参构造器！

十、抽象类

//抽象类；abstract
//意义：提高开发效率
public abstract class Dome_1 {
    //abstract 类不能实例化，只能靠子类实现它，可以理解为：约束
    //abstract 类中可以有方法
    public void add(){

    }
    //抽象方法没有方法体，抽象方法只能在抽象类、接口中
    public abstract void abb();
    //抽象类也会自动生成无参构造器
}

十一、接口

  • 接口可以理解为是一种约束、制度、规则。

1.接口示例：

//接口：interface  可以理解为是一种约束、制度、规则
//接口不能被实例化，没有构造方法。
public interface inteface__01 {
    //接口属性：public static final变量的默认修饰符  --可以不写
    public static final String name ="姓名";
    //接口方法:只能有抽象方法 没有实现方法
    // public、abstract是接口中方法的默认修饰  --可以省略。
    public abstract  void  add();
    void acc();
}

2.接口的实现

public class test implements inteface__01,inerface__02{
    //implements可以继承多个接口
    //继承接口必须要重写接口中的所有方法
    @Override
    public void add() {

    }
    
    @Override
    public void acc() {

    }

    @Override
    public void aaa() {

    }
   @Override
    public  void aff(){

    }
}

八、内部类

1、声明示例：

public class Dome02 {
    //外部类变量、方法
     private int a=10;
    public void name(){
        System.out.println("外部类");
    }
    //声明一个内部类
    public class Nei{

        public void name2(){
            //内部类可以直接引用外部类的私有方法、变量
            System.out.println(a);
            System.out.println("内部类");
        }
    }
}

2.调用示例

public class test1 {
    public static void main(String[] args) {
        //外部类的实例化
        Dome02 dome02 = new Dome02();
        
        //内部类需要通过外部类的对象来实例化
        Dome02.Nei nei = dome02.new Nei();
        //调用内部类方法
        nei.name2();
    }//输出结果：10、内部类
}

3.总结：

  • 内部类需要通过外部类的对象来实例化。
  • 内部类可以直接调用外部类的私有方法和变量。

九、异常机制

  • Throwable： 有两个重要的子类：Exception（异常）和 Error（错误）

    • **Error（错误）: **是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。
    • **Exception（异常）😗*是程序本身可以处理的异常。

  • java异常结构层次图[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GrhClb8z-1595300651381)(C:\Users\000\AppData\Roaming\Typora\typora-user-images\image-20200721094444798.png)]

9.1、示例

  • public static void main(String[] args) {
    int  a=0;
    int b=1;
    try {//捕获异常的区域
        System.out.println(b/a);
    }catch (ArithmeticException e){
        //如果异常监控区，出现异常。则执行本代码块
        System.out.println("代码异常！");
    }finally{
        //一定执行的代码块，可以省略不写
        //多用于IO流的关闭资源。
        System.out.println("Finally代码块");
    }
}

###9.2、异常类型获取

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mVyhGSUu-1595300651388)(C:\Users\000\AppData\Roaming\Typora\typora-user-images\image-20200720223122485.png)]

9.3、多异常

  • 捕捉异常的顺序：由小到大

  • 示例

          try {//捕获异常的区域
                 System.out.println(b/a);
             }catch (ArithmeticException e){
                 //如果异常监控区，出现异常。则执行本代码块
                 System.out.println("代码异常！(ArithmeticException)");
             }catch (Throwable t){
                 System.out.println("THrowable 异常提示！");
             } finally{
                 //一定执行的代码块，可以省略不写
                 //多用于IO流的关闭资源。
                 System.out.println("Finally代码块");
   }

9.4、idea快捷键

  • 选中监控代码 ctrl+alt+T

9.5、throw、throws的使用

public void  add(int a,int b)throws ArithmeticException{//方法上主动抛出异常：throws 异常类型

    if (a==0) {
        throw new ArithmeticException();//方法中主动抛出异常：throw new异常方法类型

    }

9.6、自定义异常

  • 自定义异常示例
public class exception_06 extends Throwable{
  
    //自定义异常类（判断接收参数不能大于10）
    
    private  int a;
    public exception_06(int i){
            this.a=i;
    }
    //ToString打印方法
    @Override
    public String toString() {
        return "exception_06{" + "a=" + a + '}';
    }
}
  • 验证自定义异常
//可能存在异常的方法
    public static void  s(int b) throws exception_06 {
        System.out.println("参数："+b);
        if(b>10){
            throw new exception_06(b);//抛出
        }
        System.out.println("ok");
    }
    public static void main(String[] args){
        try {
            s(14);
        } catch (OOP_03.exception_06 e) {
            System.out.println("exception_06-->"+e);
        }
    }//输出结果：参数：14
   //          exception_06-->exception_06{a=14}

  1. java关键字是对java编译器有特殊含义的字符串，编译器中关键字有固定的类型、类、方法特性等信息； ↩︎

  2. 浮点数的舍入误差，接近但不等于的特性。类似于“约等于”的意思。不能用来做准确的数值对比 ↩︎

  3. 除了基本数据类型，其他都是引用类型 ↩︎

  4. IO流的类使用过后，不关闭就会一直占用资源。浪费可耻！！！ ↩︎

待人要善
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值