JavaSE学习日记

JAVA入门

java帝国的诞生

Day1

故事

java初生

java发展 

三高:高可用、高性能、高并发

day02

Java特性和优势

write once run ahywhere      

java 有异常机制

Java三大版本

jvm虚拟机    

JDK、JRE、JVM

JDK: Java Development Kit

JRE: Java Runtime Environment

JVM:JAVA Virtual Machine

 Java开发环境搭建

卸载jdk

1.找到系统中的环境变量 

2.找到名称为java_home

3.根据路径删除文件

4.删除完文件 开始删除环境变量

5.再找到名称为Path 里面还有跟Java名称有关的环境变量

6.测试是否删除干净 打开cmd输入java-vesion 识别不出 就是卸载成功

安装jdk

1.百度搜索jdk8,找到下载地址

2.下载电脑对应版本

3.得到安装包 安装 配置环境

4.记住安装路径

5.配置环境变量 系统JAVA_HOME 输入安装路径

6.配置path变量  新建路径 双% 引起JAVA_HOME

7.根据上一步再添加JAVA中的jre的bin目录

8.验证Java安装是否成功 java -version

下载notepad++

day03

hello World

1.新建一个文件夹,存放代码

2.新建java文件 后缀名为.java  Hello.java

3.系统如果没有显示文件后缀名,我们需要手动打开

4.使用notepad++编写

5.编写完代码去编译 打开cmd 输入 javac Hello.java

6.输入java Hello 来开始启动程序

注意

1.每个单词大小写不能出现问题,java是大小写敏感

2.使用英文的字符

public class Hello {
	public static void main(String[] args){
		System.out.print("Hello,World");
	}
	
	
}

编译型和解释型

区别就是解释的实际不同

编译型:用工具(编译器)整体翻译成计算机理解的语言 解释完再执行 例:c、c++

解释型:执行一段代码解释一段代码    执行的时候同时解释 例:网页

使用IDEA开发

IDE

集成开发环境,提供程序开发环境

idea快捷键

常用快捷键
功能 快捷键
1.执行(run) alt+r
2.提示补全(Class Name Completion) alt+/
3.单选注释 ctrl + /
4.多行注释 ctrl + shift + /
5.向下复制一行(Duplicate Lines) ctrl+alt+down
6.删除一行或选中行(delete line) ctrl+d
7.向下移动行(move statement down) alt+down
8.向上移动行(move statement up) alt+up
9.向下开始新的一行(start new line) shift+enter
10.向上开始新的一行(Start New Line before current) ctrl+shift+enter
11.如何查看源码(class) ctrl + 选中指定的结构或ctrl + shift + t
12.万能解错/生成返回值变量 alt + enter
13.退回到前一个编辑的页面(back) alt + left
14.进入到下一个编辑的页面(针对于上面那条来说的) (forward) alt + right
15.查看类继承关系(type hierarchy) F4
16.格式化代码(reformat code) ctrl+shift+F
17.提示方法参数类型(Parameter Info) ctrl+alt+/
18.复制代码 ctrl + c
19.撤销 ctrl + z
20.反撤销 ctrl + y
21.剪切 ctrl + x
22.粘贴 ctrl + v
23.保存 ctrl + s
24.全选 ctrl + a
25.选中数行,整体往后移动 tab
26.选中数行,整体往前移动 shift + tab
27.查看类的结构:类似于eclipse的outline ctrl+o
28.修改变量名与方法名(rename) alt+shift+r
29.大写转小写/小写转大写(toggle case) ctrl+shift+y
30.生成构造/get/set/toString alt +shift + s
31.查看文档说明(quick documentation) F2
32.收起所有的方法(collapse all) alt + shift + c
33.打开所有方法(expand all) alt+shift+x
34.打开代码所在硬盘文件夹(show in explorer) ctrl+shift+x
35.生成try-catch等(surround with) alt+shift+z
36.局部变量抽取为成员变量(introduce field) alt+shift+F
37.查找/替换(当前) ctrl+f
38.查找(全局) ctrl+h
39.查找文件 double Shift
40.重写父类方法(Override Method) ctrl+shift+o
41.抽取方法(Extract Method) alt+shift+m
42.打开Module setting窗口(Recently Changed Files) ctrl+E
43.关闭当前打开的代码栏(close) ctrl + w
44.关闭打开的所有代码栏(close all) ctrl + shift + w
45.快速搜索类中的错误(next highlighted error) ctrl + shift + Q
46.选择要粘贴的内容(Show in Explorer) ctrl+shift+V
47.查找方法在哪里被调用(Call Hierarchy) ctrl+shift+H
48.查看方法的多层重写结构(method hierarchy) ctrl+alt+h

Java基础语法

 

 注释

 ieda创建空项目里面存放练习的代码

创建新的module

项目结构 配置java版本

单行注释

双斜杠 //

//单行注释

多行注释

/*

多行   

*/

/*
多行注释
*/

JavaDoc:文档注释

/**

文档注释 

*/

/**
文档注释
*/

文档注释 可以增加描述 

day04

标识符

关键字

Java所有的组成部分都需要名字、类名、变量名以及方法名都被称为标识符

day05

数据类型

强类型语言

要求变量的使用要严格符合规定,所有变量都必须先定义后使用  (安全性高、效率低)

弱类型语言

Java的数量类型分为两大类

package com.feng.base;

public class demo1 {
    public static void main(String[] args) {
        //八大数据基本类型
        //整数
        int num1=10;
        byte num2=20;
        short num3=30;
        long num4=40L;//long型的数字后面要加L
        //小数:浮点数
        float num5=5.1F;//float型的数字后面要加F
        double num6=3.142323;
        //字符型
        char name='中';
        String name1="中国";//String 不是关键字 首字母要大写 是个类
        //布尔值 是非
        boolean falg=true;
        //boolean falg=false;
    }
}

什么是字节

数据类型拓展 

整数拓展

二进制0b 十进制 八进制0 十六进制0x

package com.feng.base;

public class Demo2  {
    public static void main(String[] args) {
        // 整数扩展 二进制0b 八进制0 十进制 十六进制0x
        int a = 0b10;
        int b = 012;
        int c = 12;
        int d = 0x12;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println("=======================");
        //=======================================================
        //浮点数的扩展 银行业务的表示
        //BigDecimal 数学工具类
        //=======================================================
        //float    舍入误差 接近但不等于
        //double
        //最好完全使用浮点数进行比较
        float f = 0.1f;
        double g = 0.1;
        System.out.println(f == g);
        float d1 = 23232132133f;
        float d2 = d1 + 1;
        System.out.println(d1 == d2);
        System.out.println("=======================");
        //=======================================================
        //字符拓展
        //=======================================================
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1);
        System.out.println(c2);
        System.out.println((int)c2);
        //所有字符的本质还是数字
        //编码 Unicode 97=a 0-65536
        //Unicode表示方式 U0000 UFFFF;
        char c3='\u0061';
        System.out.println(c3);
        System.out.println("=======================");
        //转义字符
        // \t 分隔
        // \n 换行
        System.out.println("hello\nworld");
        System.out.println("=======================");
        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc == sd);
        //布尔值扩展
        boolean flag = true;
        //if (flag == true)
        //if (flag)             是相等的

    }
}

银行业务用 数学工具类BigDecimal表示 因为浮点数有误差

数据类型转换

由于Java是强类型语言,所以要进行有些运算的时候,需要用到类型转换

package com.feng.base;

public class Demo03 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;//内存溢出
        //强制转换
        System.out.println(i);
        System.out.println(b);
        /*
        * 1.不能对布尔值进行转换
        * 2.不能把对象类型转换为不相干的类型
        * 3.把高容量转换到低容量的时候,强制转换
        * 4.转换的时候可能存在内存溢出,或精度问题
        * */
        System.out.println("=========================");
        char c = 'a';
        int d = c+1;
        System.out.println(d);
        System.out.println((char)d);
        //操作数比较大的数的时候,注意溢出问题
        //数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years =20;
        int total = money*years;//-1435656,计算时候溢出了
        long total2 = money*years;//默认是int,转换之前已经存在问题
        long total3 = money*((long)years);//先把一个数转换为long
        System.out.println(total3);
    }
}

注意 

1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.把高容量转换到低容量的时候,强制转换
4.转换的时候可能存在内存溢出,或精度问题

操作数比较大的数的时候,注意溢出问题
数字之间可以用下划线分割

变量

package com.feng.base;

public class Demo04 {
    //属性;变量
    //实例变量;从属于对象 默认值为0.0
    //布尔值;默认值为false
    //除了基本类型,其余的值都是null
    String name;
    int age;
    static final double salary = 2500;
    static final int d = 2;
    //main方法
    public static void main(String[] args) {
        //局部变量:必须声明和初始化值
        int a = 1;
        int b = 2;
        int c = 3;//程序可读性
        String name = "fengyifan";
        char x = 'X';
        double pi = 3.14;
        //变量类型 变量名字 = new Demo08();
        Demo04 demo04 =new Demo04();
        System.out.println(demo04.age);
        System.out.println(demo04.name);
        //类变量 static
        System.out.println(salary);
        //final 常量
        //修饰符不存在先后顺序

    }
    //其他方法
    public void add() {

    }
}

    //变量
    //实例变量;从属于对象 默认值为0.0
    //布尔值;默认值为false
    //除了基本类型,其余的值都是null 

变量的作用域

常量

final  把变量修饰成常数   修饰符不存在先后顺序

  重点!!! 变量命名规范

day06

 运算符

Java语言支持如下运算符:

 取余运算(模运算):只能给整数取余。

instanceof

IDEA快捷键 ctrl+D 复制当前行到下一行            

cast转换

operator 运算符

代码示例

package com.feng.base;

public class Demo05 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        int c = 10;
        int d = 10;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);
        System.out.println("=============================");
        long e = 123434;
        int f = 123;
        short  g = 10;
        byte h = 8;
        System.out.println(e+f+g+h);//long
        System.out.println(f+g+h);//int
        System.out.println(g+h);//int
        int ab = 10;
        int ac = 20;
        System.out.println(ab>ac);
        System.out.println(ab<ac);
        System.out.println(ab==ac);
        System.out.println(ab!=ac);
        System.out.println(ab%ac);
    }
}

逻辑运算符、位运算符、条件运算符、扩展赋值运算符

逻辑运算符

逻辑与运算:两个变量都为真,结果才为true

逻辑或运算:两个变量有一个为真,则结果才为true

非运算就是取反运算

短路运算

与运算遇到0 或运算遇到1 都会触发短路

位运算

条件运算符(三元运算符)

扩展赋值运算符

+=        -=         *=         /=

字符串连接符 只要有string类型加起来 也会变成string 类型

运算符的优先级

自增自减运算符(一元运算符)

数学类Math

pow()   幂运算    很多运算,我们会使用一些工具类来操作!

代码示例
package com.feng.base;

public class Demo06 {
    public static void main(String[] args) {
        int a = 3;
        int b = a++;
        int c = ++a;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        //幂运算
        double pow = Math.pow(2,3);
        System.out.println(pow);
    }
}

包机制

相当于文件夹

 

 新建package (包)

作用:给写的代码文件装在一起

包里面新建文件  代码里面首行就是包的名字

要是想使用一个包的成员 得需要Java程序中明确导入该包,使用import完成此功能

package 必须在第一行    导入包的时候 避免导入包里面的名字和程序里面的名字重名

import com.kuang.base.*    意思就是base里面的所有文件都导入进来

阿里巴巴开发手册 认真看一遍

JavaDoc

 

将程序的注释信息 生成一个文档

如何生成呢 在.java的程序文件夹下打开cmd

就可以生成网页文件 就能查看里面的注释

使用IDEA生成JavaDoc文档!

第一步

打开IDEA的最上方工具栏的工具 (有一个生成JavaDoc)

第二步

点击生成JavaDoc

图中JavaDoc作用域就是生成文档范围

输出目录  就是生成文档的地方

区域设置 一般是zh_CN   (中国)

命令行参数  补充字符编码 -encoding UTF-8 -charset UTF-8

3.打开输出目录

就能看见成功生成

打开 index.html   (主页面) 便能看生成的文档

day07

Java流程控制

Scanner对象

package com.feng.scanner;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象,用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接受:");
        //判断用户有没有输入字符串
        if(scanner.hasNext()) {
            //使用next方式接收
            String str = scanner.next();//程序会等待用户输入完毕
            System.out.println("输出的内容为:"+str);
        }
        //凡是属于io流的类如果不关闭会一直占用资源,要养成好习惯 用完就关掉
        scanner.close();
       //next不能得到带有空格的字符串
    }
}

 

next() 一定要读取到有效字符后才可以结束输入、

               对输入有效字符之前遇到的空白,next()方法会自动去掉

  

功能特点
 next()获取输入的字符串遇到空格会结束,不会接收空格
nextLine()获取输入的字符串以enter为结束符
hasNext()判断是否还有输入的数据
hasNextLine()判断是否还有输入的数据

hasNext()  hasNextLine()   判断是否还有输入的数据

用完Scanner 要及时关闭,节省资源        scanner.close();

输入格式(固定格式)

package com.feng.scanner;
import java.util.Scanner;
public class Demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数据");
        String str = scanner.nextLine();
        System.out.println("输出的内容为:"+str);
        scanner.close();
    }
}

再详细用输入的话

可以用

hasNext+数据类型

package com.feng.scanner;
import java.util.Scanner;
public class Demo04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //从键盘接收数据
        int i = 0;
        float f = 0.0f;
        System.out.println("请输入整数;");
        //如果。。。那么
        if(scanner.hasNextInt()) {
            i = scanner.nextInt();
            System.out.println("整数数据为;"+i);
        } else {
            System.out.println("输入的不是整数数据!");
        }
        System.out.println("请输入小数;");
        //如果。。 那么
        if (scanner.hasNextFloat()) {
            f = scanner.nextFloat();
            System.out.println("小数数据;"+f);
        }else {
            System.out.println("输入的不是小数数据!");
        }
        scanner.close();
    }
}

输入多个数字求其总和与平均数

package com.feng.scanner;
import java.util.Scanner;
public class Demo05 {
    public static void main(String[] args) {
        //我们可以输入多个数字,并求其总和与平均数,每输入一个数字用回车确认,
        //通过输入非数字来结束输入并输出执行结果
       Scanner scanner = new Scanner(System.in);
       int m = 0;
       //计算输入了多少个数字
       double sum = 0;
       //和
       //通过循环判断是否还要输入,并且在里面对每一次进行求和统计
        while(scanner.hasNextDouble())
       {
           sum += scanner.nextDouble(); 
       //也可以定义double的变量 接收 sum再加double的变量
           m++;
           System.out.println("你输入了第"+m+"个数据,然后当前结果为sum="+sum);

       }
       System.out.println("个数的和为;"+sum);
       System.out.println("平均数为;"+(sum/m));

       scanner.close();
    }
}

顺序结构

 选择结构 !!

if单选择结构

equals:判断字符串是否相等 

尽量少用 == 去判断字符串

if双选择结构

if多选择结构 

 代码示例
package com.feng.struct;
import java.util.Scanner;
public class IfDemo01 {
    public static void main(String[] args) {
        //考试分数大于60就是及格,小于60分就不及格
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩;");
        int score = scanner.nextInt();
        if(score == 100) {
            System.out.println("恭喜满分");
        }else if(score<100 && score>=90) {
            System.out.println("A级");
        }else if(score<90 && score>=80) {
            System.out.println("B级");
        }else if(score<80 && score>=70) {
            System.out.println("C级");
        }else if(score<70 && score>=60) {
            System.out.println("D级");
        }else if(score<60 && score>=0) {
            System.out.println("不及格");
        }
        else {
            System.out.println("成绩不合法");
        }
    }
}

嵌套的if结构

 switch多选择结构

 代码示例

package com.feng.struct;

public class SwitchDemo01 {
    public static void main(String[] args) {
        //case的顺序执行
        char grade = 'A';
        switch (grade) {
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("及格");
                break;
            case 'D':
                System.out.println("再接再厉");
                break;
            case 'E':
                System.out.println("挂科");
                break;
            default:
                System.out.println("未知等级");
        }
    }
}

case穿透 如果没有break打断的 会顺序向下。

package com.feng.struct;

public class SwtichDemo02 {
    public static void main(String[] args) {
        String name = "一";
        //jdk7的新特性,表达式结果可以是字符串
        //字符的本质还是数字
        //反编译 java---class(字节码文件)----反编译IDEA
        switch (name) {
            case "一" :
                System.out.println("一");
                break;
            case "二二" :
                System.out.println("二二");
                break;
            default:
                System.out.println("什么也不是");
        }
    }
}

里面也可以用字符串比较

反编译 java---class(字节码文件)----反编译IDEA

反编译过程 

1.打开设置中的项目结构

2.然后复制编译器输出的路径

3. 打开已经在IDEA创建的文件夹   把class文件拖过去就能显示了

循环结构

while循环

 

package com.feng.struct;

public class WhileDemo02 {
    public static void main(String[] args) {
        //计算1+2+3....+100=?
        int i = 0;
        int sum = 0;
        while(i<=100) {
            sum += i;
            i++;
        }
        System.out.println(sum);
    }
}

do-while循环

 For循环

package com.feng.struct;

public class ForDemo01 {
    public static void main(String[] args) {
        //练习1;计算0到100之间的奇数和偶数的和
        int  oddSum = 0,evenSum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i%2 == 0) {
                evenSum += i;
            }else {
                oddSum += i;
            }
        }
        System.out.println("1-100奇数和为"+oddSum);
        System.out.println("1-100偶数和为"+evenSum);
    }
}
package com.feng.struct;

public class ForDemo02 {
    public static void main(String[] args) {
        //练习2:用while或for循环输出1-1000之间能被5整除的数,并且每行输出3个
        int i = 1,count = 0;
        while(i <= 1000) {
            if(i%5 == 0) {
                System.out.print(i+" ");
                count++;
            }
            if(count%3 == 0 && count != 0) {
                System.out.println();
            }
            i++;
        }
    }
}
package com.feng.struct;

public class ForDemo03 {
    public static void main(String[] args) {
        //打印九九乘法表
        //1.我们先打印第一列
        //2.我们把固定的1再用一个循环包起来
        //3.去掉重复项 i<=j
        //4.调整样式
        for( int i = 1;i<=9;i++) {
            for(int j = 1;j<=i;j++) {
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println("\n");
        }
    }
}

print输出完不换行

增强for循环

package com.feng.struct;

public class ForDemo05 {
    public static void main(String[] args) {
        int numbers[] = {1,2,3,4,5,6};
        //遍历数据元素
       for(int x:numbers) {  //增强for循环
           System.out.println(x);
        }
    }
}

break continue

 goto代码示例
package com.feng.struct;

public class LabelDemo {
    public static void main(String[] args) {
        //打印101-150之间的质数
        int count = 0;
        //不建议使用
        outer:for(int i= 101;i<150;i++){
            for(int j = 2;j<i/2;j++){
                if(i%j==0){
                    continue outer;
                }
            }
            System.out.println(i+" ");
        }
    }
}

流程控制练习

打印三角形

package com.feng.struct;

public class TeskDemo {
    public static void main(String[] args) {
        //打印三角形 5行
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 4-i; j++) { //打印空格
                System.out.print(" ");
            }
            for (int j = 0; j < i*2+1; j++) { //打印星号
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

debug

逐步分析程序的每一步

第一步 选择断点

第二步 启动调试

Java方法详解 (c中的函数)

 何谓方法?

一个方法只完成一个功能,利于后期的扩展

package com.feng.method;

public class method {
    public static void main(String[] args) {
        int a=50,b=30;
        int sum=add(a,b);
        System.out.println("和为"+sum);
    }
    public static int add(int a,int b) {
        return a+b;
    }
}

方法的定义

实际参数:实际调用传递给他的参数

return 终止方法

方法的调用

值传递不会改变原本的值,引用传递可以改变原本的值

Java是值传递

比大小

package com.feng.method;

public class method02 {
//比大小
public static void main(String[] args) {
    int a=50,b=50;
    System.out.println("大的数为"+max(a,b));
}
public static int max(int a,int b) {
    int max = 0;
    if(a==b) {
        System.out.println("a==b");
        return 0;
    }else if(a > b) {
        max = a;
    }else if(b > a) {
        max = b;
    }
    return max;
}
}

方法的重载

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

package com.feng.method;

public class method {
    public static void main(String[] args) {
        int a=50,b=30,c=39,d=45;
        int sum=add(a,b);
        System.out.println("和为"+sum);
        sum=add(a,b,c);
        System.out.println("和为"+sum);
        sum=add(a,b,c,d);
        System.out.println("和为"+sum);
        //方法的重载
    }
    public static int add(int a,int b) {
        return a+b;
    }
    public static int add(int a,int b,int c) {
        return a+b+c;
    }
    public static int add(int a,int b,int c,int d) {
        return a+b+c+d;
    }
}

命令行传参

package com.feng.method;

public class method03 {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args["+i+"]="+args[i]);
        }
    }
}

可以通过给主函数传递参数 输出

1.打开method03所在的路径

2.打开cmd输入生成class文件

3.路径退到最外面的包路径,然后输入字符 程序就可以生成数据了

可变参数

不定项 必须在最后

package com.feng.method;

public class method04 {
    public static void main(String[] args) {
        printMax(123,34,34,3245,4354,545,33324,422);
    }
    public static void printMax(double... nums) {
        if(nums.length == 0) {
            System.out.println("没有输入数据");
            return;
        }
        double max=nums[0];
        //选出最大值
        for (int i = 1; i < nums.length; i++) {
            if(nums[i] > max) {
                max = nums[i];
            }
        }
        System.out.println("最大数为:"+max);
    }
}

 递归

容易理解

利用栈实现的

计算阶乘的方法

package com.feng.method;

import com.sun.scenario.effect.impl.sw.java.JSWBlend_SRC_OUTPeer;

public class method05 {
    public static void main(String[] args) {
           //计算5的阶乘
        int sum=factorial(5);
        System.out.println("5的阶乘"+sum);
    }
    public static int factorial(int n) {
        if(n==1){
            return 1;
        }else {
            return n*factorial(n-1);
        }
    }
}

 作业

作业代码

package com.feng.method;

import java.util.Scanner;

public class homework01 {
    public static void main(String[] args) {
      Scanner scnner = new Scanner(System.in);
      boolean exit = false;
      while(!exit) {
          System.out.println("请输入第一个数字");
          double a = scnner.nextDouble();
          System.out.println("请输入操作符(*,/,+,-)");
          String operator = scnner.next();
          System.out.println("请输入第二个数字");
          double b = scnner.nextDouble();
          double result=0;
          switch (operator) {
              case "*" : result=mul(a,b);break;
              case "/" : result=div(a,b);break;
              case "+" : result=add(a,b);break;
              case "-" : result=sub(a,b);break;
          }
          System.out.println("结果为:"+result);
          System.out.println("是否继续(y/n)");
          String k = scnner.next();
          if(k.equalsIgnoreCase("n")) {
              exit = true;
          }
      }
      scnner.close();
    }
    public static double add(double a,double b) {
        return a+b;
    }
    public static double sub(double a,double b) {
        return a-b;
    }
    public static double mul(double a,double b) {
        return a*b;
    }
    public static double div(double a,double b) {
        return a/b;
    }
}

Java数组

数组的定义

 数组的声明创建

package com.feng.arrays;

public class Demo01 {
    public static void main(String[] args) {

        int [] a; //1.定义 推荐用这种
        a = new int[10]; //2.创建数组
        //这里面可以存放10个int类型的数字
        //3.赋值
        a[0] = 1;
        a[1] = 2;
        a[2] = 3;
        a[3] = 4;
        a[4] = 5;
        a[5] = 6;
        a[6] = 7;
        a[7] = 8;
        a[8] = 9;
        a[9] = 10;
        //未被赋值的数组元素 默认值为零
        //获取数组长度:arrays.length
        //计算数组a的和
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            System.out.println(" "+a[i]);
        }
    }
}

三种初始化

package com.feng.arrays;

public class Dmeo02 {
    public static void main(String[] args) {
        //静态初始化:创建+赋值
        int [] a = {1,2,3,4,5};
        //动态初始化
        int[] b = new int[10];
        b[9] = 1;
        //b+0 ~ b+8 没被赋值 默认为0
        for (int i = 0; i < b.length; i++) {
            System.out.println(" "+b[i]);
        }
    }
}

内存分析

基本特点

 数组边界

数组的使用

普通for循环

int [] a = {25,16,95,46,64};
        System.out.println("for循环打印数组");
        for (int i = 0; i < a.length; i++) {
            System.out.println("a["+i+"]"+"="+a[i]+",");
        }

For-Each循环

使用方法:数组名.for

 System.out.println("for-each循环打印数组");
        for (int i : a) {
            System.out.println(i+",");
        }

数组作方法入参

public static  void  Printf(int [] a) {
        System.out.println("用方法入参打印数组");
        for (int i = 0; i < a.length; i++) {
            System.out.print("a["+i+"]"+"="+a[i]+",");
        }
        System.out.println();
    }

数组作返回值

public static int [] reverse(int [] a) {
        //数组逆置
        int [] result = new int [a.length];
        System.out.println("用方法返回数组,完成数组逆置");
        for (int i = 0; i < a.length; i++) {
            result[5-1-i] = a[i];
        }
        return result;
    }

以上四种的代码示例

package com.feng.arrays;
​
public class Demo03 {
    public static  void  Printf(int [] a) {
        System.out.println("用方法入参打印数组");
        for (int i = 0; i < a.length; i++) {
            System.out.print("a["+i+"]"+"="+a[i]+",");
        }
        System.out.println();
    }
    public static int [] reverse(int [] a) {
        //数组逆置
        int [] result = new int [a.length];
        System.out.println("用方法返回数组,完成数组逆置");
        for (int i = 0; i < a.length; i++) {
            result[5-1-i] = a[i];
        }
        return result;
    }
    public static void main(String[] args) {
        int [] a = {25,16,95,46,64};
        System.out.println("for循环打印数组");
        for (int i = 0; i < a.length; i++) {
            System.out.print("a["+i+"]"+"="+a[i]+",");
        }
        System.out.println();
        System.out.println("for-each循环打印数组");
        for (int i : a) {
            System.out.print(i+",");
        }
        System.out.println();
        Printf(a);
       int [] b = reverse(a);
        System.out.println("逆置后的数组");
        Printf(b);
    }
​
​
}
​

多维数组

 代码示例

package com.feng.arrays;

import java.util.Scanner;

public class Demo04 {
    public static void main(String[] args) {
        int [][] a = new int[3][3];
        //输入数据
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < a.length; i++) {
            System.out.println("请输入第"+(i+1)+"行数组");
            for (int j = 0; j < a[i].length; j++) {
                System.out.println("请输入第"+(j+1)+"列");
                a[i][j] = scanner.nextInt();
            }
        }
        scanner.close();
        //输出数据
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j]+",");
            }
            System.out.println();
        }
    }
}

Arrays类

tostring打印数组

sort排序:默认给数组从小到大排序

fill方法:数组填充

填充结果

填充第二个元素之后到第四个元素 val就是要填充的值

类的学习

CTRL+点击arrays类

然后点击structure可以看见类中的各种方法

在线学习网址:Java 8 中文版 - 在线API手册 - 码工具

冒泡排序

 代码示例

package com.feng.arrays;

import java.util.Arrays;

public class Demo05 {
    public static int [] sort(int [] arrays) {
        int t;
        for (int i = 0; i < arrays.length-1; i++) {
            for (int j = 0; j < arrays.length-1-i; j++) {
                if(arrays[j+1]<arrays[j]) {
                      t = arrays[j];
                      arrays[j] = arrays[j+1];
                      arrays[j+1] =t;
                }
            }
        }
        return arrays;
    }
    public static void main(String[] args) {
        int [] a = {132,56,59,4,49,16,49,16,49,13,49,94,1,64,16};
        //利用冒泡排序给数据排序
        int [] b = sort(a);
        System.out.println(Arrays.toString(b));
    }
}

稀疏数组

介绍

代码示例

package com.feng.arrays;

public class Demo06 {
    public static void main(String[] args) {
        //稀疏数组
        //假设有1一个 11*11 的棋盘 而且 0代表没有棋子 1代表黑棋 2代表白棋
        //现在黑棋在第二行第三列 白棋在第三行第四列
        //因为数组下标从零开始 所以要-1
        int[][] a1 = new int[11][11];
        a1[1][2] = 1;
        a1[2][3] = 2;
        //存完棋子 输出
        System.out.println("输出棋盘");
        for (int i = 0; i < a1.length; i++) {
            for (int j = 0; j < a1[i].length; j++) {
                System.out.print(a1[i][j]+" ");
            }
            System.out.println();
        }
        //转换稀疏数组 首先判断有多少个有效值
        int sum = 0;
        for (int i = 0; i < a1.length; i++) {
            for (int j = 0; j < a1[i].length; j++) {
                if(a1[i][j] != 0) {
                    sum++;
                }
            }
        }
        // 0列 有效值的行值 1列 有效值的列值 2列 有效值
        //sum+1是因为 第0行要存储基本信息
        int[][] a2 = new int[sum+1][3];
        a2[0][0] = 11;
        a2[0][1] = 11;
        a2[0][2] = sum;
        //开始压缩
        int count = 0;
        for (int i = 0; i < a1.length; i++) {
            for (int j = 0; j < a1[i].length; j++) {
               if(a1[i][j] != 0) {
                   count++;
                   a2[count][0]=i;
                   a2[count][1]=j;
                   a2[count][2]=a1[i][j];
               }
            }
        }
        System.out.println("输出压缩后的数组");
        for (int i = 0; i < a2.length; i++) {
            for (int j = 0; j < a2[i].length; j++) {
                System.out.print(a2[i][j]+" ");
            }
            System.out.println();
        }
        //解压数组
        int[][] a3 = new int[a2[0][0]][a2[0][1]];
        for (int i = 1; i < a2.length; i++) {
            for (int j = 0; j < a2[i].length; j++) {
                a3[a2[i][0]][a2[i][1]] = a2[i][2];
            }
        }
        System.out.println("输出解压后的棋盘");
        for (int i = 0; i < a3.length; i++) {
            for (int j = 0; j < a3[i].length; j++) {
                System.out.print(a3[i][j]+" ");
            }
            System.out.println();
        }
    }
}

面向对象编程

 

面向对象的认知

面向过程&面向对象

 属性加方法构成一个类

类=属性+方法

什么是面向对象 OOP

抽象:把实体中的相似特征抽取出来组成一个类

回顾方法

代码

package com.feng.oop;

//Demo01就是一个类
public class Demo01 {
    //类中有许多的 方法
    //其中就有main方法 有且仅有一个
    public static void main(String[] args) {
    }
    /*
    * 修饰符 返回值类型  方法名(。。。) {
    * //方法体
    * return 返回值;
    * }
    *  */
    public String sayHello() {
        return "Hello,World";
    }
    //void 无返回值 return; 返回空
    public void pritt() {
        return;
    }
    public int max(int a,int b) {
        return a>b? a : b; 
        //三元运算符
    }
 //数组下标越界:Arrayindexoutofbounds
    public void readFile(String file) throws IOException {
        
    }
}

注意点:方法的数据类型 reutrn就返回什么数据类型

return 结束方法,返回一个结果

静态方法

+static

被另一个类调用,之间类名加方法名就能调用

package com.feng.oop;

public class Demo02 {
    public static void main(String[] args) {
        //静态方法 static
         Student.say();
        //非静态方法
    }
}
package com.feng.oop;
//学生类
public class Student {
    //方法
    public static void  say() {
        System.out.println("学生说话了");
    }
}

非静态方法

没有static的方法

实例化这个类 new

对象类 对象名=对象值

package com.feng.oop;

public class Demo02 {
    public static void main(String[] args) {
        //非静态方法
        //实例化这个类 new
        Student student = new Student();
        student.say();
    }
}

package com.feng.oop;
//学生类
public class Student {
    //方法
    public  void  say() {
        System.out.println("学生说话了");
    }
}

静态方法如果过早的调用非静态方法就会报错

package com.feng.oop;
//学生类
public class Student {
    //方法
    public  void  say() {
        System.out.println("学生说话了");
    }
    //静态static 和类一起加载的
    public  static void a() {
        b();
    }
    //非静态方法 类实例化之后才存在
    public  void b() {

    }
}

实际参数和形式参数的类型要对应 

package com.feng.oop;

public class Demo03 {
    public static void main(String[] args) {
        //实际参数和形式参数的类型要对应
        int add = Demo03.add(2,3);
        System.out.println(add);
    }
    public static int add(int a,int b) {
        return a+b;
    }

值传递

package com.feng.oop;
//值传递
public class Demo04 {

    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);
        Demo04.change(a);
        System.out.println(a); //结果还是1

}
//返回值为空
    public static void change(int a) {
        a = 10;
    }

}

引用传递

package com.feng.oop;
//引用传递:对象,本质还是值传递

//对象,内存
public class Demo05 {
    public static void main(String[] args) {
        Perosn perosn = new Perosn();
        System.out.println(perosn.name); //null
        Demo05.change(perosn);
        System.out.println(perosn.name);//1
    }
    public static void change(Perosn perosn) {
        //perosn是一个对象,指向的的---》 Perosn perosn = new Perosn();
        
       perosn.name = "1";
    }
}
//定于了一个Perosn类,有一个属性name
class Perosn {
    String name;//null
}

类与对象的关系

 创建与初始化对象

使用new关键字 

package com.feng.oop.Demo02;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类:抽象的,实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体实例!
        //用c语言的话来说 类就相当于结构体 可以存函数的结构体
        Student xiaoming = new Student();
        Student xiaohong = new Student();
        xiaoming.name = "小明";
        xiaoming.age = 3;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
        xiaohong.name = "小红";
        xiaohong.age = 3;
        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);
    }
}
package com.feng.oop.Demo02;
//学生类
public class Student {
    //属性:字段
    String name; //默认值 null
    int age; // 默认值 0

    //方法
    public void study() {
        System.out.println(this.name+"在学习");
    }
}

构造器详解

1.和类名相同

2.没有返回值

作用:

1.new本质在调用构造方法

2.初始化对象的值

注意点:

1.定义有参构造之后,如果想使用无参构造,显示的定义一个无参的构造

快捷键:alt+insert

package com.feng.oop.Demo02;
//java---->class
// 实例化初始值
//构造器用法
//1.使用new关键字,必须要有构造器(本质是在调用构造器)
//2.用来初始化值
public class Person {
     //一个类即使什么都不写,它也会存在一个方法
    //默认的定义构造器

     String name;

    //alt+insert
    //无参构造器
    public Person() {
        this.name = "123";//将name的默认值改为123
    }

    //有参构造器:一旦定义了有参构造,无参就必须显示定义
    public Person(String name) {
        this.name = name;
    }
}

创建对象的内存分析

举例子

package com.feng.oop.Demo02;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
       Pet dog = new Pet();
       dog.name = "旺财";
       dog.age = 3;
       dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}
package com.feng.oop.Demo02;

public class Pet {
    String name;
    int age;
    public void shout() {
        System.out.println("叫了一声");
    }
}

 总结

 类与对象(小结)

1.类与对象
类是一个模板: 对象是一个具体的实例
2.方法
定义、调用!
3.对应的引用
引用类型:基本类型(8)
对象是通过引用来操作的:栈---->堆(地址)
4.属性:字段field 成员变量
默认初始化:
1)数字:0 0.0
2)char:u0000
3) boolean:false
4) 引用:null
修饰符 属性类型 属性名 = 属性值!
5.对象的创建和使用
1)必须使用new关键字创造对象,构造器 Person peoplename = new Person();
2)对象的属性 peoplename.name
3) 对象的方法 peoplename.sleep()
6.类:
静态的属性  属性
动态的行为  方法
封装、继承、多态

换句话说

类就是种类                       例子:人

对象是类的一个实际特征 例子:人属性有身高、出生日期 状态有吃饭、睡觉、说话

面向对象三大特性

封装

 封装的代码示例

package com.feng.oop.Demo04;

import com.feng.oop.Demo04.Student;

/*
* 封装的意义
* 1.提高程序的安全性,保护数据
* 2.隐藏代码的实现细节
* 3.统一接口
* 4.系统可维护性增加了
* */
public class Application {
    public static void main(String[] args) {
       Student s1 = new Student();

        s1.setName("名字");

        System.out.println(s1.getName());

        s1.setAge(999); //年龄999不合法
        System.out.println(s1.getAge());
    }
}
package com.feng.oop.Demo04;
//类 private:私有
public class Student {

    //属性私有
    //名字
    private  String name;
    //学号
    private  int id;
    //性别
    private  char sex;
    //年龄
    private int age;
    //提供一些可以操作这个属性的方法
    //提供一些public 的 get set方法
    //get 获得这个数据
    public  String getName() {
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name) {
         this.name = name;
    }
    //alt + insert 自动设置get set

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120 || age<0) {
            this.age = 3;
        }else {
            this.age = age;
        }
    }
}

继承

Java中 类只有单继承 一个儿子只能有一个爸爸

快捷键:ctrl+H 作用:显示父类与子类的关系 

Java种所有的类都默认直接或者间接继承Object

子类会继承父类的所有属性方法

如果父类用private定义  子类将继承不到

package com.feng.oop.Demo05;
//人 是student、teacher的父类
public class Person {
    //public
    //protected
    //default
    //private 私有 子类继承不到了 一般属性才是私有的
    public  int money = 1000000;
    public void say() {
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}
package com.feng.oop.Demo05;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println();
    }
}
package com.feng.oop.Demo05;
//学生 is 人
//student 是 person的派生类或者是子类
//子类继承了父类,就会拥有父类的全部方法
public class Student extends Person {

}
package com.feng.oop.Demo05;
//Teacher is 人
//teacher 是 person的派生类或者是子类
public class Teacher extends Person{

}
super

注意点:

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

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

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

this:

代表的对象不同:

this:本身调用者这个对象

super:代表父类对象的应用

前提

this:没有继承也可以使用

super:只能在继承条件才可以使用

构造方法

this():本类的构造

super():父类的构造

方法重写

重写:需要有继承关系,子类重写父类的方法! 1.方法名必须相同

2.参数列表必须相同

3.修饰符:范围可以扩大 public>protected>default>private

4.抛出的异常:范围可以被缩小 但不能扩大:ClassNotFoundException》Excetion(大)

重写,子类的方法和父类必须要一致,方法体不同

为什么需要重写

1.父类的功能,子类不一定需要,或者不一定满足! 快捷键alt+insert : override

package com.feng.oop.Demo05;

public class A extends B{

    //Override重写
    @Override //注解 有功能的注解
    public int hashCode() {
        return super.hashCode();
    }

    public void test() {
        System.out.println("A=>test()");
    }
}
package com.feng.oop.Demo05;


//重写都是方法的重写,和属性无关
public class B {
    public void test() {
        System.out.println("B=>test()");
    }
}
package com.feng.oop.Demo05;
import com.feng.oop.Demo05.A;
import com.feng.oop.Demo05.B;
public class Application {
    //静态的方法和非静态的方法区别很大
    //静态方法:方法的调用只和左边,定义的数据类型有关
    //非静态方法:重写
    public static void main(String[] args) {
      A a = new A();
      a.test();
      //A

        //父类的引用指向了子类
      B b = new A(); //子类重写了父类的方法
      b.test();
      //B
    }
}

/* */

多态

多态注意事项
1.多态是方法的多态,属性没有多态
2.父类和子类,有联系 类型转换异常  ClassCastException!
3.存在条件:继承关系,方法需要重写, 父类引用指向子类对象 Father f1 = new Son();

没有办法重写
1.static 方法,属于类,它不属于实例
2.final 常量
3.private方法

package com.feng.oop.Demo06;

public class Application {
    public static void main(String[] args) {
        //一个对象实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了
        //Student 能调用的放法都是自己的或者是继承父类的
        Student s1 = new Student();
        //Person 父类型,可以指向子类,但是不能调用子类独有的方法
        Person s2 = new Student();

        Object s3 = new Student();

        //对象能执行哪些方法,主要看对象左边的类型,和右边关系不大!
        s2.eat(); //子类重写了父类的方法,执行子类的方法
        s1.eat();
    }
}
package com.feng.oop.Demo06;

public class Person {
    public void run() {
        System.out.println("run");
    }
}
package com.feng.oop.Demo06;

public class Student extends Person{
    public void run() {
        System.out.println("son");
    }
    public void eat() {
        System.out.println("eat");
    }
}
 instanceof 和类型转换
package com.feng.oop.Demo06;

public class Application {
    public static void main(String[] args) {
        //类型之间的转化:父 子
        //高                  低
        Person obj = new Student();
        //student将这个对象转换为Student类型,就就可以使用student类型的方法了
        Student student = (Student)obj;
        student.go();
        ((Student) obj).go();
        //子类转换为父类,可能丢失自己的本来一些方法!
        Student student1 = new Student();
        student1.go();
        Person person = student1;
    }
    /*
    * 1.父类引用指向了子类的对象
    * 2.把子类转换为父类,向上转型
    * 3.把父类转换为子类,向下转型:强制转型
    * 4.方便方法的调用,减少重复的代码!简洁
    * 抽象:封装、继承、多态!  抽象类 ,接口
    * */
}
package com.feng.oop.Demo06;

public class Person {
public void run() {
    System.out.println("run");
}
}
package com.feng.oop.Demo06;

public class Student extends Person{
public void go() {
    System.out.println("go");
}
/*
*       //Object > String
        //Object > Person > Student
        //Object > Person > teacher
    Object object = new Student();

        //System.out.println(x instanceof y); 能不能编译通过!
        //x跟y父子关系
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
        System.out.println("==========================");
    Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
        // System.out.println(person instanceof String);//编译报错
        System.out.println("==========================");
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher); 编译报错
        //System.out.println(student instanceof String); 编译报错
* */
}

static详解

package com.feng.oop.Demo07;

//static :
//非静态方法可以调用静态方法
//静态方法不可以调用非静态方法!!!
public class Student {
    private static int age;//静态的变量  多线程
    private double score;//非静态的变量
    public  void run() {

    }
    public static void go() {

    }
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);
        //System.out.println(Student.score);
        System.out.println(s1.age);
        System.out.println(s1.score);
        new Student().run();
        go();
    }
}
package com.feng.oop.Demo07;
//有final 就不能有子类了!!!
public class Person {
    //2:赋初值
    {
        //代码块(匿名代码块)
        System.out.println("匿名代码块");
    }
    //1:只执行一次
    static {
        //静态代码块
        System.out.println("静态代码块");
    }
    //3
    public Person() {

        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("==========");
        Person person2 = new Person();

    }
}
package com.feng.oop.Demo07;
//静态导入包~
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {

    public static void main(String[] args) {
        System.out.println(Math.random());
        System.out.println(PI);
    }
}

抽象类

package com.feng.oop.Demo08;

//abstract 抽象类 :类 extends:单继承   接口可以 多继承 (插座)
public abstract class Action {
    //约束 有人帮我们实现
    //abstract 抽象方法:只有方法名字,没有方法实现
    public abstract void doSomething();
    //1.不能new这个抽象类,只能靠子类去实现它:约束!
    //2.抽象类中可以写普通方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象:约束

    //思考题? 抽象类不能new对象存在构造器吗?
    //抽象类存在的意义??
}
package com.feng.oop.Demo08;

public class Application {
    public static void main(String[] args) {
        //new Action(); 不可以
    }
}
package com.feng.oop.Demo08;
//抽象类的所有方法,继承了它的子类,都必须要实现它的方法

public class A extends Action{
    public void doSomething() {

    }
}

 思考题

抽象类不能new对象 那么它存在构造器吗?

存在

抽象类存在的意义?

抽象类本质是一个类,没问题,那么类里面一般都是有方法的,方法包括方法名和方法体,这是常识对不对,那么什么是抽象类呢?如果一个类里面有一种方法只有方法名却没有方法体,这样的类就是抽象类!

首先简单的介绍一下抽象类:

定义是很简单的,我们这里不写官方的语言,我自己看着都烦,我们就用白话介绍,抽象类本质是一个类,没问题,那么类里面一般都是有方法的,方法包括方法名和方法体,这是常识对不对,那么什么是抽象类呢?如果一个类里面有一种方法只有方法名却没有方法体,这样的类就是抽象类!

举个例子:

public abstract class TestAbstract {
    //这是一个抽象方法,
    public abstract void run(); 
    //当然这里面也可以是普通的方法
    public void eat() {
        System.out.println("我是一个在抽象类里面的普通方法");
    }
}
这里为了区别普通的类,我们一般加abstract这个关键字,我们就认为他是一个抽象类。既然是一个类,那么普通类的属性他都有,它也可以写普通的方法。

这里就有人说了,那这个有什么用呢?没有实现体,就是调用也没用啊,JDK也想到这个了,所以呢他是不让你直接实例化调用的,因为没用啊,对吧,这也是为什么抽象类不可以直接实例化自己,这里说实例化自己有些人不明白,说人话就是不可以自己创建一个自己的对象出来,他只能是子类的引用来创建父类的对象。

举个例子:

    public static void main(String[] args) {
        /**
         * 抽象类是不可以自己实例化自己的,只能实例化自己的子类,因为只有子类才有方法的实现,自己实例化自己是没有意义的。况且就是自己
         * 里面有普通方法的实现,他的子类都是可以使用的。
         */
        TestAbstract t = new TestA01();
        
    }
回到之前的话题,既然有些方法不可以实现,写了做什么呢?难道就为了那几个可以实现的方法?当然不是的,这里的抽象类是为了子类更好的实现。

我们举个简单的例子:我们有一个动物的类,里面有一个Run的方法,这个时候我们需要继承他,一只狗说我会跑,老虎说我也会跑,孔雀说我也会跑,这个时候每一个子类都要继承他,而且由于Run方法已经被父类实现了,所以每一个都要重写方法体,是不是很麻烦,这个时候JDK就说了,既然那么多类需要继承他,我直接不实现这个方法,你们谁用谁实现算了。这个就是抽象类存在的意义!

说的比较官方一些的话,就是抽象类可以将设计和实现分离,你写你的抽象类,我写我的实现方法。这也是为什么说抽象方法必须被继承才有意义!

举个例子:

class TestA01 extends TestAbstract{
    /**
     * @Override 是注解,JDK5.0以后的新特性,重写的意思,也就是说,如果是注解了的话,就是重写的方法,名字是不可以改的, 如果去掉注解,说明不是重写的方法
     * 名字是可以改掉的。
     */
    @Override
    public void run() {
        System.out.println("我是子类的run()");
    }
    
}
总结一下:

 有抽象方法的类必然是抽象类
 抽象类不可以被实例化,不能被new来实例化抽象类
 抽象类可以包含属性,方法,构造方法,但是构造方法不能用来new实例,只能被子类调用
 抽象类只能用来继承
 抽象类的抽象方法必须被子类继承
————————————————
版权声明:本文为CSDN博主「何处锦绣不灰堆」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/qq_41485414/article/details/83059774

接口

接口的作用
1.约束
2,定义一些方法,让不同的人实现,10----》 1
3.public abstract
4.public static final
5.接口不能被实例化 :接口中没有构造方法
6.implements可以实现多个接口
7.必须要重写接口中的方法 

package com.feng.oop.Demo09;

//抽象的思维
//接口interface 定义接口的关键字
//接口都需要有实现类
public interface UerService {
    //接口中定义的都是常量 public static final
    int AGE = 99;


    //接口中的所有定义其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}
package com.feng.oop.Demo09;

//抽象类extends
//类可以实现接口 implements 接口
//实现了接口中的类 必须实现接口的方法

//多继承 利用接口实现多继承
public class UserServiceImpl implements UerService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}
package com.feng.oop.Demo09;

public interface TimeService {
    void timer();
}

内部类

知道就好 不推荐写

 第一种成员内部类

package com.feng.oop.Demo10;

public class Outer {
    private  int id;
    public void out() {
        System.out.println("这是外部类的放法");

    }
    class Inner {
        public  void in() {
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public  void  getID() {
            System.out.println(id);
        }
    }
}
package com.feng.oop.Demo10;

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

第二种静态内部类

package com.feng.oop.Demo10;

public class Outer {
    private  int id = 10;
    public void out() {
        System.out.println("这是外部类的放法");

    }
    public static class  Inner {
        public  void in() {
            System.out.println("这是内部类的方法");
        }

    }
}
}

第三种匿名内部类

package com.feng.oop.Demo10;


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

        UserService userService = new UserService() {
            @Override
            public void hello() {

            }
        };
    }
}
class Apple {
    public  void eat() {
        System.out.println("1");
    }
}
interface UserService {
void hello();
}

第四种局部内部类

package com.feng.oop.Demo10;

public class Outer {

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

            }
        }

    }
}

异常机制 Exception 

什么是异常

循环调用的错误 a调用b b调用a 会无线循环下去 

package com.exception;

public class Demo01 {
    public static void main(String[] args) {
        new Demo01().a();
    }
    public void a() {
        b();
    }
    public void b() {
        a();
    }
}

异常的简单分类

异常体系结构

Error 

 Exception

异常分为:运行时异常 和 非运行时异常 

异常处理机制

处理异常的使用

package com.exception;

public class Test {
    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) {
            System.out.println("Exception");
        }catch (Throwable t) {
            System.out.println("Throwable");
        }
        finally { //处理善后工作
            System.out.println("finally");
        }

        //finally 可以不要finally 假设IO、资源、关闭!

    }
    public void a() {
        b();
    }
    public void b() {
        a();
    }
}

方法中的抛出异常

package com.exception;

public class Test02 {
    public static void main(String[] args) {
        new Test02().test(1,0);
    }
    //假设这个方法中,处理不了这个异常。方法上抛出异常
    public void test(int a,int b) throws ArithmeticException{
        if(b==0) {
            // throw throws(方法上的抛出异常)
            throw new ArithmeticException();//主动的抛出异常,一般在方法中使用
        }
        System.out.println(a/b);
        }
    /*
    int a = 1;
    int b = 0;
    //快捷键 Ctrl + Alt + T
        try {
        if(b==0) {
            //主动的抛出异常 throw throws
            throw new ArithmeticException();
        }
        System.out.println(a/b);
    } catch (Exception e) {
        e.printStackTrace();//打印错误的栈信息
    } finally {
    }
    */
}

自定义异常

 异常处理

package com.exception.demo02;

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);
        }
    }
}
package com.exception.demo02;

//自定义的的异常类
public class MyException extends Exception {

    //传递数字 >10;
    private int detail;

    public MyException(int a) {
        this.detail = a;
    }
    //toString:异常的打印信息 alt+insert
    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }

}

实际应用中的经验总结

本文章学习的视频来自于狂神说Java

  • 24
    点赞
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值