java基础中级版本

最新推荐文章于 2024-04-25 17:27:12 发布

莫莫虎

最新推荐文章于 2024-04-25 17:27:12 发布

阅读量121

点赞数

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

本文链接：https://blog.csdn.net/qq_46011969/article/details/117568737

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

java

javaME：Java Micro Edition 嵌入式开发（手机家电）
javaSE ：Java Standard Edition 标准版（桌面控制台开发） 核心基础
**javaEE **：Java Enterprise Edition 企业级开发（web端服务器开发）java的主要方向

JDK， JRE， JVM

JDK：java开发工具 java集成开发工具包
JRE：java运行环境
JVM：java虚拟机

JDK包含JRE包含JVM； API在JRE中

java开发环境搭建

卸载jdk

删除java JDK安装目录（安装包）
删除JAVA-HOME
删除path下关于java的目录（删除环境变量）
cmd中查看一下 java -version

安装jdk

官网下载：https://www.oracle.com/java/technologies/javase-downloads.html

oracle官网
找到jdk
下载，双击安装
一直下一步，记住安装的路径
配置环境变量
1. 我的电脑–>右键–>属性–>高级系统设置–>环境变量
2. 环境变量–>系统变量新建变量名JAVA_HOME–>变量值为jdk安装的路径（包路径）（C:\Program Files\Java\jdk-14.0.1）
3. 配置path变量–>系统变量打开path–>新建 %JAVA_HOME%\bin–>新建 %JAVA_HOME%\jre\bin(这一步看情况，可能不需要)
  
  %% 表示引用的意思表示变量JAVA_HOEME的值等价于（C:\Program Files\Java\jdk-14.0.1），， %JAVA_HOME%\jre\bin指向了JAVA_HOME下的bin目录
  1. 检查安装是否成功 cmd -->java -version
    
    java目录

bin 放了一些一些可执行的文件
include 一些c语言的头文件
jre java运行环境
lib java的库
src.zip 资源文件很多java类所有的类都在src里面可以看见源代码

（尽量将环境放在一起）

快捷键

win 加 + 放大镜

win 加R 打开运行

win 加E 打开我的电脑

ctrl shift esc 打开任务管理器

win tab 切换桌面

基本dos命令

dos控制台

打开cmd方式

开始+系统+命令提示符
win+R 输入cmd 打开控制台
在任意文件夹下，桌面下，按住shift+右键打开powershell窗口
资源管理器的地址栏前面加上cmd路径

管理员方式运行：开始界面 windows系统 cmd右键管理员身份运行

常用dos命令

#盘符切换  系统盘+：
#查看当前目录所以文件  dir
#切换目录  cd 
		cd .. 返回上一级
		cd /d E：\ide 跨磁盘跳转
		cd +文件名 进入一个文件
		cd>a.txt 新建一个文件
#删除文件 del
		del a.txt
#清理屏幕 cls  （clear screen）
#推出终端 exit
#查看电脑ip ipconfig
#打开应用
		calc  计算机
		mspaint 画图
		notepad 记事本
#ping命令
		ping www.baidu.com
#创建文件目录 md 
		md 文件目录  
#删除文件目录 rd
		rd 文件目录

Hello World

新建文件夹，存放代码
新建java文件
- 显示文件扩展名
- 文件名.java

编写代码

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

javac编译器编译 .java文件，会生成一个class文件 //需要点java
java运行class文件 //不需要点class

java程序运行机制

编译型：一次编译完
解释型：一次编译一段

IDEA安装

IDE：集成开发环境
IDEA优化

java基础语法

单行注释 //
多行注释 /* */

文档注释 javaDoc /** */

    /**
     * @Description  描述
   * @Author  作者
     * 
     */

数据类型

强类型语言（更安全速度慢）
- 要求变量先定义后使用
弱类型语言

java数据类型分为两大类
- 基本类型（primitive type）
  - long类型要在数字后面加个L
  - float类型要加一个F
  - String不是关键字，是一个类
  - boolean占一位（bit） 0或1
- 引用类型（reference type）
  - 类（String Integer Byte）
  - 接口
  - 数组
位（bit）0或1
字节（Byte）
1B=8bit

整数拓展 int

int i=10; //10
int i2=010;//八进制 8
int i3=0x10;//十六进制 16    0~9 A~F 16

浮点数拓展 float double 有限离散舍入误差大约 接近但不等于

避免浮点数进行比较

银行业务？用BigDecimal 数学工具类 表示数

字符拓展 char （编码表）

可以强制转换为数字字符本质是数字数字与字符对应

转义字符

\t 制表符（相当于 tab）

\n 换行

…

String sa=new String(“Hello”);

String sb=new String(“Hello”);

sa不等于sb 比较的式地址地址不一样（对象内存）

String sc=“Hello”;

String sd=“Hello”;

sc等于sd

布尔值拓展

Boolean flag =true；

if（flag==true）{} //新手

if（flag）{} //上下一样

类型转换

java是强类型语言，所以进行有些运算时要用到类型转换

低 --------->高自动转换

byte，short，char——》int——》long——》float——》double

int i=2;
byte b=(byte)i;//强制转换 （转换类型）变量名  从高——》低
/*
1.布尔值不能转换
2.不能把对象类型转换为不相干的类型 （要用继承关系）
3.转换时可能存在内存溢出，或精度问题！ （小数点丢失）  （128转换为byte就是精度问题）
4.高转低 ，强制转换
*/

//操作比较大的数的时候，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
int money =10_0000_0000;//不会输出下划线
//超出范围时，先把一个数转换为更大的数

变量

作用域

public class Test {
    static int test =0;// 类变量(静态变量)
    String str= "hello";// 实例变量  （可以不初始化）
    
    public void  method(){
        int i = 0;//局部变量 (必须初始化)
    }
}

类变量 (静态变量) static修饰定义变量在类中在方法中可以直接使用没有static修饰的不行

可以直接使用，或类名.变量名使用
实例变量（类变量）：从属于对象，类如果不初始化默认值为int为0，小数为0.0或boolean为false 其余为null 方法中不能直接使用需要在方法中创建对象调出使用
局部变量：一个方法{ }里面 必须声明和初始化值

命名规范

类名：首字目大写和每个字母首字母大写
常量：大写字母 (全大写) 和下划线： MAX_VALLUE
其他的首字母小写，其他单词首字母大写

常量（初始化后无法变动的值）

关键字 final
常量名一般使用大写字符

final 与static可以一起使用

运算符

// Ctrl + D: 复制当前到后面

低位的运算结果默认为int，有long的默认为long，有double为double double>long

int a=3；//a初始为3，进过下面两次计算a为5

int b=a++；//先赋值，a再加1，b为3

int c=++a；//a先加1，再赋值，c为5

幂运算很多运算会使用工具类操作！（数学工具类Math）

double pow = math.pow（2.3）//2的3次方，会返回一个数

&&与 ||或！非逻辑运算符会产生短路运算 (第一个不满足直接为 false)

int c=5;
boolean d=(c<4)&&(c++<4);
System.out.print(d);//d为false
System.out.print(c);//c为5  因为短路运算 c++没有执行所以c还为5

位运算 跟二进制相关 一位一位的比较 效率高
- &与 |或 ^相同为0，不同为1 ~取反
- 《《左移相当于乘2
- 》》右移相当于除2

2<<3 相当于2乘2乘3次

a+=b；//a = a+b

a-=b；//a = a-b

字符串连接符 + ，String

int a = 10;
int b = 20;
System.out.print(""+a+b);//1020   字符串在前面  后面的数会拼接
System.out.print(a+b+"");//30   字符串在后面   前面的会运算
System.out.print(a+b+""+a+b)//301020   字符串前 会运算 后会拼接

三元运算符

// x？y：z

如果x==true (x可以是一个运算表达式 )，则结果为y，否则为z 会返回一个值

int score = 80;
String type = score < 60 ? "不及格":"及格";  // type 的值为 及格 或 不及格

包机制

更好的组织类，就是文件夹，解决重名问题
一般利用公司域名倒置作包名 //com.baidu.www
package开头加自己在的父子包名
Ctrl+鼠标左键看源码看源包
导包：将package换成 import 具体到类名 //.* 可以表示包下所有内容所有类导包类名与当前类名不要重复
```
import java.util.Date;
```

javaDoc

javadoc命令是用来生成自己的API文档的
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况

生成文档 cmd IEDEA 都可以生成API文档参考：IDEA 生成 javadoc 文档_Future_LL的博客-CSDN博客

官方在线文档：Java SE 文档 — API 和文档 | Oracle 中国

java流程控制

Scanner对象

实现程序和人的交互，java提供了一个工具类，获取用户的输入。 java.util.Scanner是java5的新特性，我们可以通过Scanner类来获取用户的输入
基本语法：

Scanner s = new Scanner（System.in）；

alt+enter补全对象

通过Scanner类的next（）与nextLine（）方法获取输入的字符串，在读取前使用hasNext（）与hasNextLine（）判断是否还有输入的数据。

  public static void main(String[] args) {
        //创建一个扫描器对象，接收键盘数据
        Scanner scanner = new Scanner(System.in);
        //判断是否输入数据
            if(scanner.hasNext()){
                String str=scanner.next();//接收数据
                System.out.println("输出内容"+str);
            }
            scanner.close();//凡是属于IO流的类不关闭会一直占用资源。 (输入输出流)
    }

scanner.close（）；关闭Scanner
next()
- 读取不到空格之后的字符串 hello world //只能获取hello
- 不能获得空白
nextLine（）
- 可以读取输入回车前的所有字符，包括空格 hello world //能获取hello world
- 可以获得空白
可以不用if判断hasNext（），所有的输入为String类型，用String接收。

String s = scanner.nextLine();

nextInt（） hasNextInt（）只能输入整数
nextFloat（） hasNextFloat（）只能输入小数或整数

  public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        double sum=0;
        int m=0;
        while (scanner.hasNextDouble()){//如果输入不是double会停止循环
            double d = scanner.nextDouble();
            m++;
            sum = sum + d;
            System.out.println("你输入了"+m+"个数据,结果为"+sum);

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

            scanner.close();
    }

顺序结构

重上至下一句一句执行基本算法结构

选择结构

if单选结构

if(true){
    //执行语句
}
//equals方法:判断字符串是否相等    s.equals("Hello")  判断字符串等等与Hello

// 少用== 判断字符串

if双选结构

if(true){
     //执行语句
}else{
     //执行语句
}

if多选结构

if(){
     //执行语句
}else if(){
     //执行语句
}else if(){
     //执行语句
}else if(){
     //执行语句
}else{
    
}

嵌套的if结构

if(true){
    //执行语句
    if(true){
    //执行语句
	}
}

switch多选择结构

switch case 语句

case 穿透

  char  grade='A';
        switch (grade){//可以是字符串 和八大基本类型 JDK7特性
            case 'A':
                System.out.println("优秀");
                break;//可选 没写的话会输出当前和下面的语句
            case 'B':
                System.out.println("良好");
                break;// 如果为B 会输出良好  不会输出下面的数据
            case 'C':
                System.out.println("及格");

            case 'D':
                System.out.println("挂科");

            default:// 参数都不满足 走default
                System.out.println("未知");

反编译用IDEA打开class文件（将class文件通过文件目录的形式，放入IDEA项目中）

循环结构

while循环如果不满足条件，则不能进入循环

while (true){
       //执行内容       
    }

do…while循环如果不满足条件，也至少执行一次
- ```
do{
    //执行
}while(true);
```

for循环

for (初始化; 布尔表达式 ; 更新) {// 初始化可以定义多个变量  
          
      }

//死循环
for（;;）{
    
}

//计算0到100之间奇数和偶数的和
int odSum = 0;
     int eveSum = 0;
        for (int i = 0; i < 100; i++) {
            if (i%2!=0){
                odSum+=i;//奇数和
            }else{java
                eveSum+=i;//偶数和
            }

//print输出完不换行
//printIn输出完换行

```

IDEA快捷创建方式数字.for （10.for 创建循环10次的for循环）

java5引入了主要对于数组或集合的遍历 增强for循环（适用于遍历）

for（声明语句 ：表达式）{
    //代码
}



   int[] mun = {10,20,30,40};

		for（int i=0；i<5;i++）{
            System.out.printIn(mun[i]);//普通for循环
        }

        for (int x:mun) {// 遍历mun  用 x 取出数据
            System.out.println(x);//增强for循环  简化
        }

break continue
- break可以在任何循环中 强行退出循环，不仅仅是在switch语句中
- continue用于终止某一次循环过程，接着进行下一次循环

java方法

何谓方法

System.out.printIn(),

类. 对象. 方法( )

java方法是语句的集合，它们在一起执行一个功能

//一个方法需要new一个类 点方法才能使用
   public static void main(String[] args) {

        text t = new text();
        System.out.println( t.add(1,2));

    }
    public  int add(int a,int b){
        return a+b;

    }

//一个方法加上static关键字后  可以直接使用方法  不用创建类
   
    public static void main(String[] args) {

        System.out.println( add(1,2));

    }
    public  static int add(int a,int b){
        return a+b;

    }

方法的定义及应用
- java方法类似其他语言的函数，用来完成特定功能的代码片段

方法重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数

public static void main(String[] args) {
       text t = new text();
       System.out.println( t.add(1.1,2.2));
  
   }
//方法重载  方法名字相同 参数不同
    public  static int add(int a,int b){//int型add方法
        return a+b;

    }
    public  static double add(double a,double b){//double型add方法
        return a+b;

    }

1. 方法名称必须相同
2. 参数列表必须不同

命令行传参 CMD (运行一个程序时再给他消息)

public static void main(String[] args) {
      for (int i = 0; i <args.length ; i++) {
          System.out.println("args["+i+"]:"+args[i]);
  
      }
  }
//程序编译以后通过 cmd命令行传递参数 需要从src目录出执行程序

可变参数不定项参数不规定你要传多少参数参数可以看作一个数组

Jdk1.5支持
方法声明中，指定参数类型后加一个省略号（…）

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

  public static void main(String[] args) {
        text t = new text();
        t.text(1,5,6,7);


    }
    public void text (int... i){//可变参数
        System.out.println(i[0]);//i相当与一个数组 通过下标取出数据
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
    }  
	public  void text(double j,int... i){

        
    }

递归

能不用递归就不要递归 小计算可用递归

递归就是自己调用自己

public static void main(String[] args) {
      System.out.println(f(5));
  }
  //阶乘 5! 5的阶乘
  public static int  f (int n) {
      if(n==1){//递归的边界
          return 1;
      }else {
          return n*f(n-1);//递归 有一个边界
      }

}

递归结构包括两个部分
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
- 递归体：什么时候需要调用自身方法

数组

数组的定义

数组是相同数据类型的有序集合
数组元素通过数组下标访问，从 0 开始

数组声明创建

首先声明数组变量

int[] mun1;//声明一个数组 首选 没有开辟空间  栈里面
     int mun2[];（不常用）

new创建数组

    int[] mun1;//定义 首选
        mun1 = new int[5];//创建一个数组 存放5个int类型数据  开辟了一个方5个int的空间   对象在堆里面

数组的元素索引从0开始

没赋值的int默认为0 string默认为null
获取数组长度：array.length 方法

java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常

三种初始化

静态初始化：创建+赋值

int[] a = {1,2,3,4,5,6};
 
Man[]  mans = { new Ma(1,1), new Ma(2,2)}//Man是一个创建的类

动态初始化：包含默认初始化

int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);

数组的四个基本特点

长度确定。一旦被创建大小不可改变。
元素类型相同
数组元素可以是任何数组类型
数组变量属于引用类型，数组可以看成对象。数组本身就是对象，java中对象是在堆中的。new出来的都是在堆中的。

数组边界

ArrayIndexOutOfBoundsException：数组下标越界异常

数组是相同数据类型的有序集合
数组也是对象。数组元素相当与对象的成员变量
数组长度越界报错

数组的使用

增强for循环，array.for 适合打印输出（遍历）不适合操作元素
普通For循环
数组作为方法入参
数组作为返回值

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，（数组里面包含了一个数组）

原来存一个数现在存一个数组

       int[][] a = {{1,2},{2,3},{3,4}，{4，5}};
        //[4][2]
	//	a[0]为一个数组	a[1]唯一数组	a[2]为一个数组 a[3]为一个数组

//        {1,2}  a[0]
//        {2,3}  a[1]
//        {3,4}  a[2]
//        {4,5}  a[3]
 
	a[0]中存了{1，2}  就是数据1和2 | a[0][0]中存了数据1
	// a.length   a[i].length

二维数组（数组嵌套）：一个数组数组内包含的另一个数组

Arrays类（数组的工具类）

数组工具类java.util.Arrays
toString（数组）方法打印数组元素（此方法数据是用[ ]括起来的）
sort(数组)方法数组进行排序（升序）
Arryas类方法都是static修饰的静态方法，可以直接类名点方法调用，不需要使用对象调用
fill(数组，填充数值) 方法数组填充

冒泡排序（八大排序）

1. 比较数组中两个相邻的元素如果第一个比第二个数大交换他们的位置**（大的数据右移）**
2. 每次比较产生最大值最小值
3. 下一轮减少一次排序
4. 一次循环到结束

两层循环，外层表示轮数。里层依次比较

时间复杂度O（n2）

 public static void main(String[] args) {
      int[] a = {5,8,2,6,7};// 5个数循环4次
      int[] b = sort(a);
      System.out.println(Arrays.toString(b));
      }
      public  static  int[] sort(int[] array) {
      //临时变量
          int temp = 0;
          //外层循环，判断走多少次
          for (int i = 0; i < array.length - 1; i++) {// 循环4次
              //内层循环，判断大小
                            
              for (int j = 0; j < array.length - 1 - i; j++) {//每次可以少判断一次
                  if (array[j+1]<array[j]) {
                      temp = array[j];
                      array[j] = array[j + 1];
                      array[j + 1] = temp;
                  }
              }
          }
          return array;
      }



// 优化 存疑
 public static void main(String[] args) {
      int[] a = {5,8,2,6,7};// 5个数循环4次
      int[] b = sort(a);
      System.out.println(Arrays.toString(b));

      }
      public  static  int[] sort(int[] array) {
      //临时变量
          int temp = 0;
          //外层循环，判断走多少次
          for (int i = 0; i < array.length - 1; i++) {// 循环4次
              //内层循环，判断大小
              
              boolean flag =false;// （优化）通过flag标识位减少没有意义的比较
              
              for (int j = 0; j < array.length - 1 - i; j++) {//每次可以少判断一次
                  if (array[j+1]<array[j]) {
                      temp = array[j];
                      array[j] = array[j + 1];
                      array[j + 1] = temp;
                      flag=true;
                  }
              }
              if(flag==false){
                  break;
              }
          }
          return array;
      }

稀疏数组

（数据结构）好好研究研究

当一个数组中大部分元素为0，或者为同一值的数组时，可以用稀疏数组来保存改数组
稀疏数组的处理方式：
- 记录数组一共有几行几列，有多少个不同值
- 把具有不同值的元素和行列记录在一个小规模的数组中，从而缩小程序的规模（压缩）

参考：

public class Test {
    public static void main(String[] args) {
        //创建一个二维数组  11*11  0：没有棋子   1：黑棋子   2：白棋子
        int[][] array1=new int[11][11];
        array1[1][2] =1;
        array1[2][3] =2;
        //输出原始的数组
        System.out.println("输出原始的数组");

        for (int[] ints : array1) {
            for (int anInt: ints) {// anInt 是个具体的值
                System.out.print(anInt+"\t");// \t 空格的意思
            }
            System.out.println();//换行
        }
        System.out.println("===============");
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数："+sum);

        //2.创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];
        // 稀疏数组的头
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;

        //遍历二维数组，将非零的值，存放稀疏数组中
        int count=0;
        for (int i = 0; i < array1.length; i++) {//array1.length 外层数组的长度
            for (int j = 0; j < array1[i].length; j++) {// array1[i].length内层数组的长度
                if (array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];

                }
            }
        }

        //输出稀疏数组
        System.out.println("稀疏数组");

        for (int i = 0; i < array2.length; i++) {// i=0 记录的是 有多少 行，列，值（头部信息）  i=1 才是第一个数
            System.out.println(array2[i][0]+"\t"
                    +array2[i][1]+"\t"
                    +array2[i][2]+"\t");
        }
        System.out.println("===============");

        System.out.println("还原");
        //1.读取稀疏数组的值
        int[][] array3=new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原他的值
        for (int i = 1; i < array2.length; i++) {//i=0是（头部信息）  从array2第一个记录的数开始   i=1 才是第一个元素的具体信息
            array3[array2[i][0]][array2[i][1]]=array2[i][2];

        }
        //3. 打印
        System.out.println("输出还原的数组");

        for (int[] ints: array3) {
            for (int anInt: ints) {// anInt 是个具体的值
                System.out.print(anInt+"\t");
            }
            System.out.println();//换行
        }
    }
}

输出结果

面向对象编程

面向对象

oop
面向对象编程的本质就是：以类的方式组织代码，以对象的形式组织（封装）数据。
抽象
三大特点
- 封装
- 继承
- 多态

方法

方法定义

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

//方法体

return 返回值；

}

异常抛出

方法的调用：（难点是递归）

静态方法static**（和类同时加载）** 和非静态方法 （对象创建才加载）

一个类中静态方法不可以调用非静态方法
一个类中静态可以调用静态

一个类中非静态可以调用非静态

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

//2
public static  void a(){
            b();
        };
public static  void b(){};

//3 a()无法调用b
public static  void a(){  //static和类一起加载
            b();//错误
        };
public   void b(){};  //类实例化 new对象后才加载

方法：形式参数（参数的名字）实际参数（参数的值）5

值传递和引用传递 （java都是值传递）

//void方法  
public static void main(String[] args) {
        int a = 1;
       change(a);
        System.out.println(a);// 输出a 值为1
        }
		// void方法   并没有返回值
        public static void change(int a){//形参 值传递
            a = 10;
        }

// int方法 返回值为a 
    public static void main(String[] args) {
        int a = 1;
        System.out.println(change(a));// 输出a 值为1
        //输出change(a) 值为10
    }
    // int方法 返回值为a  
    public static int change(int a){
    a = 10;
    return a;
}


//引用传递： 对象，本质还是值传递

public class text {
    public static void main(String[] args) {
        Person person = new Person();

        change(person);
        System.out.println(person.name);
        }
        public static void change(Person person){
      //person是一个对象；指向的-->Person（类）的 String name：类变量 
        //对象的属性可以赋值（改变）
           person.name ="莫莫虎";
        }


    }
class Person{//Person 类
    String name;//null
}

类与对象的关系

类是一种抽象数据类型对一类事物整体描述/定义不代表某个具体事物
对象是抽象概念的具体实例

//一个项目应该只存一个main方法

创建与初始化对象

使用new关键字创建对象(new之后类的变量才加载到堆中)

构造器构造方法

必须和类的名字相同
没有返回值不能写void

public class Person {
    String name;
    //无参构造
    //实例化初始值
    //1.使用new关键字，本质实在调用构造器
    //2.用来初始化值
    public Person(){

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

//alt+insert快捷键 自动生成构造器

创建对象内存分析

初略图

要new一个类，要先加载他的类才能创建出来(new创建对象之后类的变量才加载到堆中)

简单小结类与对象

类与对象

类是一个模板：抽象，对象是一个具体的实例
方法

定义，调用！
对应的引用

引用类型：基本类型（8）

对象是通过引用来操作的：栈 --（指向）–> 堆
属性：字段Field 成员变量

默认初始化：

数字： 0 0.0

char ： u0000

Boolean ： false

引用： null

修饰符属性类型属性名 = 属性值！
对象的创建和使用
- 必须使用new 关键字创造对象，构造器 Person k = new Person ();（使用new关键字，本质实在调用构造器）
- 对象的属性 k.name
- 对象的方法 k.sleep（）;
类：

静态的属性属性

动态的行为方法

封装继承多态

封装

// 封装为属性（属性私有）方法用不了多少封装

//类  privat ：私有
public class Person {
    //属性私有
   private String name;
   private int id;
   private char sex;

   //提供一些操作属性的方法
    //提供一些public的 get  set方法
    //get 获得这个数据
    public String getName(){
        return this.name;
    }

    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }

}


//alt + insert

提高程序的安全性，保护数据（信息隐藏）
隐藏代码的实现细节
统一接口 get/set
系统可维护型增加

继承

继承的本质是对某一批类的抽象
extends的意思是“扩展”。子类是父类的扩展。private（私有）修饰的东西子类无法继承 想要继承方法的话，一般是public声明方法
java中只有单继承，没有多继承。
继承是类和类之间的一种关系。类与类之间的关系还有依赖，组合，聚合等
object类
- java中，所有类，默认直接或间接继承object类

super父类对象 - this本身对象

public void test(String name){
      System.out.printIn(name);//调用方法时传入的值
      System.out.printIn(this.name);//本类中设置的值
      System.out.printIn(super.name);//父类中设置的值
}

public Student (){
//	super();  必须放在代码第一行//隐藏代码：默认调用了父类的无参构造
    super（）；
	System.out.printIn("Student无参执行了");
}
//父类有参构造 子类要调用有参构造

//ctrl+h  显示类的继承关系图

//super注意点

super调用父类构造方法，必须在构造方法内的第一个
super 必须只能在子类的方法或构造方法中
super和this不能同时调用构造方法

构造方法

this（）；本类的构造

super（）；父类的构造

/ctrl + F 查找

方法重写 非静态的public方法才能重写

@override // 注解：有功能的注解

//静态的方法和非静态的方法区别很大
  //静态方法 ： 对象的方法的调用只和左边，定义的数据类型（数据对象A，B）有关

public class B {
    public static void test(){
        System.out.println("B=>test()");
    }
}
public class A extends B{
    public static void test(){
        System.out.println("A=>test()");
    }
}
public class Person {
    public static void main(String[] args) {
        //对象的方法的调用只和左边，定义的数据类型（数据对象A，B）有关
        A a = new A();
        a.test();//A=>test()   为A类中的方法
        B b = new A(); 
        b.test();//B=>test()  为B类中的方法
    }
}


//非静态  ： 重写
public class B {
    public  void test(){
        System.out.println("B=>test()");
    }
}
public class A extends B{
    //Override 重写
    @Override //注解 ： 有功能的注释
    public  void test(){
        System.out.println("A=>test()");
    }
}
public class Person {
    public static void main(String[] args) {
       
        A a = new A();
        a.test();//A=>test()
        B b = new A();
        b.test();//A=>test()
    }
}

重写：需要有继承关系子类重写父类的方法

方法名相同
参数列表相同
修饰符：范围可以扩大: public>protected>default>private
抛出的异常：范围，可以缩小，不能扩大

alt + insert ： override；

//ctrl + H 继承树查看继承的关系（idea中）

多态

有继承关系
重写父类方法
父类引用指向子类对象

//父类Person  子类Student
//一个对象的实际类型是确定的
//可以指向 的引用类型就不确定了： 父类的引用指向子类

	//Student 子类型 能调用的方法都是自己的或在继承父类的
	Student s1 = new Student（）；
        
    //Person 父类型， 可以指向子类 但是不能调用子类*独有*的方法 只能调用子类重写的方法（父类的引用指向了子类）
    Person s1 = new Student（）；//对象 能执行那些方法 主要看左边
        //子类重写了父类的方法，父类会执行子类的方法  没有重写，会调用父类方法
    Object s1 = new Student（）；

多态注意事项

多态是方法的多态，属性没有多态
父类和子类，有联系类型转换异常（ClassCastException）
存在条件：继承关系方法需要重写，父类引用指向子类对象（引用）Father f1 = new Son（）；（对象）(对象能执行那些方法主要看左边)

//没有重写不是多态

static 方法属于类，它不属于实例
final 常量；
private方法；

instanceof （类型转换）引用类型，判断一个对象是什么类型是否有一条线的纽带

System.out.printIn(Object instanceof Student); // true
System.out.printIn(Object instanceof Person);// true
System.out.printIn(Object instanceof Object);// true


System.out.printIn(Person instanceof Student); // true
System.out.printIn(Person instanceof Person);// true
System.out.printIn(Person instanceof Object);// true


//System.out.printIn(X instanceof Y);是否为true 取决与是否存在父子关系 是否有一条线的纽带


Person obj = new Student（）；
    //转换obj类型   父类转子类
    （（Student）obj）.方法名();
    
    Student student = （Student）obj；
    student.方法名();
	//子类转父类   可能丢失字自己的本来的一些方法
	Student student = new Student（）；
        student.方法名（）；
        Person person =student；

   1. 父类引用指向子类的对象
   2. 子类转换为父类，向上转型
   3. 父类转换为子类，向下转型 ：  强制转型
   4. 方便方法的调用 ，减少重复代码  简洁
        
  抽象： 抽象的思想
        
        封装  继承  多态           抽象类  接口

static

静态的变量（多线程）

public class Person {
    //2： 赋初始值等
    {//对象创建  先走匿名代码块
        System.out.println("匿名代码块");
    }
    static {//1：只执行一次
        System.out.println("静态代码块");
    }
    public Person(){//3：再走构造方法
        System.out.println("构造方法");
    }

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

}
//运行结果：
            静态代码块
            匿名代码块
            构造方法
            =====
            匿名代码块
            构造方法

静态导入包

import static java.lang.Math.random;

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class text {

    public static void main(String[] args) {
        System.out.println(random());//返回一个随机数
        System.out.println(PI);//PI值
        }

    }

final

一个类被final定义了就不能再被继承了没有子类了（断子绝孙了）

抽象类（可以被继承只能单继承）

abstract 修饰方法或类，抽象类可以没有抽象方法，有抽象方法的一定是抽象类

abstract 抽象类：是一个类 extends ：只能单继承 ~ 接口可以多实现

//抽象类的所有方法，继承了它的子类，必须要实现它的方法除非它也是抽象类

public abstract class text {
    
    }

abstract 抽象方法只有方法名字没有方法的实现
```
public abstract void thing ();
```

//1. 不能new这个抽象类，只能靠子类去实现它；（约束！）

// 2. 抽象类里面可以写普通方法抽象方法必须在抽象类中

接口

普通类：只有具体实现
抽象类：具体实现个规范（抽象方法）都有
接口：只有规范！约束和实现分离：面向接口编程

//interface  定义的关键字 ，   接口都需要有实现类
public interface UserService {
    //接口中的所有定义的方法其实都是抽象的public abstract（默认）
    public void run();
    void run(int n);
    void sum();

    //静态的常量（默认为）public static final  很少在接口定义常量  属性默认定义的常量
    public static final int AGE = 99;//在实现类中可以直接使用

}



//抽象类 ： extends
// 类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
//多继承  利用接口实现多继承
public class UserServiceImp  implements UserService{
    @Override
    public void run() {

    }

    @Override
    public void run(int n) {

    }

    @Override
    public void sum() {

    }
}

作用：

约束
定义一些方法，让不同人实现
方法都是public abstract
都为静态常量public static final
接口不能被实例化， 接口中没有构造方法
implements 可以实现多个接口
必须重写接口中的所有方法

内部类

内部类就是在一个类的内部再定义一个类

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


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

成员内部类

public class

静态内部类

public static class

public class Outer {
    private int id=10;
    public  void  out(){
        System.out.println("这是一个外部类的方法");
    }
    public static class Inner{
        public  void in(){
            System.out.println("这是一个内部类的方法");
        }
        //获得外部类的私有属性
        public  void getID(){
            System.out.println(id);// id 就拿不到了
        }
    }java
}

局部内部类

方法内部class 类

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

匿名内部类

public class Application {
    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();
}

public class Application {

}
//一个java类中可以有多个class类，但是只能有一个public class
class A{
    public static void main(String[] args) {

    }
}

多线程 lamda表达式

异常

java把异常当作对象来处理，并定义了一个基类java.lang.Throwable作为所有异常和错误的超类
java API定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception

Exception分支中有一个重要的子类RuntimeException（运行时异常）

异常处理机制

抛出异常
捕获异常
异常处理五个关键字
- try，catch，finally，throw，throws

finally始终会运行 ，可以不要finally，假设IO~Scanner ，资源，需要关闭！处理善后工作

catch（Throwable e） 可以捕获异常和错误 可以多个catch范围大的写在后边

public static void main(String[] args) {
    int a=1;
    int  b=0;
    try{//try控制区域  可能抛出异常的语句
        System.out.println(a/b);

    }catch (Error e){//假设捕获多个异常：   从小到大依次
        System.out.println("Error");
    }
    catch (Exception e){//catch(范围大的写在后边)
        System.out.println("Exception");
    }
    catch(Throwable e){//catch（想要捕获的异常类型  最高的为Throwable）  捕获异常
        System.out.println("Throwable");
    }finally {//处理善后工作  无论出不出异常 都会执行
        System.out.println("finally");
    }
    //finally  可以不要finally ， 假设IO，资源，关闭！

}

//ctrl +alt +T  快捷键（选中代码）  可以快捷的生成异常语句包裹被选中的代码



  public static void main(String[] args) {
        try {//异常捕获以后 程序有异常也会继续执行
            new text().test(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();//打印错误的栈信息
        }
    }
    //假如这个方法中，处理不了这个异常，方法上抛出异常throws
    public void test(int a , int b) throws  ArithmeticException{
        if(b==0){// throw  throws
            throw new ArithmeticException();//throws主动抛出异常   一般在方法中使用
        }
    }

  int b=0;

    public void eat(int b) throws ArithmeticException{// 假如方法处理不了异常  方法上抛出异常 但没有进行处理
            if (b==0);{
                throw  new ArithmeticException();//主动抛出异常  有异常的话不会执行方法会抛出异常 （一般在方法中抛出异常）
            }
        }

idea 选中代码ctrl alt+T ：可以快速生成代码块包裹选择的代码（if，try…）

     System.exit(0);
     System.exit(1);
//让程序执行或结束

自定义异常

创建自定义异常类**（需要继承Exception类）**
在方法中通过throw关键字抛出异常对象
可以用try-catch捕获异常并处理，或者在方法声明处通过throws抛出异常给方法调用者
在异常方法调用者中捕获并处理异常

//自定义的异常类   继承Exception
public class MyException  extends Exception{
    //传递数字>10 时抛异常
    private  int detail;
    public MyException(int a){
        this.detail = a;
    }
    //toString: 异常的打印信息
    @Override
    public  String toString(){
        return "MyException{" + detail + '}';
    }

}

e 为定义异常时toString里面的内容

没有异常会输出ok 有异常不会输出 ok

莫莫虎

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础中级版本

javajavaME：Java Micro Edition 嵌入式开发（手机家电）javaSE ：Java Standard Edition 标准版（桌面控制台开发）核心基础**javaEE **：Java Enterprise Edition 企业级开发（web端服务器开发）java的主要方向JDK， JRE， JVMJDK：java开发工具 java集成开发工具包JRE：java运行环境JVM：java虚拟机JDK包含JRE包含JVM； API在JRE中java
复制链接

扫一扫