[Java知识库]how2j学习总结-未完

Markdown

标题

#+空格+ 一级标题

字体

粗体 %两边两个*

斜体 %两边一个*

斜体+加粗 %两边三个*

删除线 %两边两个~

引用

文本引用效果 %用>+内容

分割线

%三个- 或者三个~

图片

% ! + [] + ()

超链接

点击跳转

%[] + ()

列表

1. A

2. B %数字+点+空格

• A
• B %减号+空格

表格

名字|性别|生日

–|--|–|

张三|男|7.2 %源代码模式删除空格

代码

public

%三个`

预科

冯诺依曼体系结构

系统软件

DOS(磁盘操作系统)、windows、Linux、Unix、Mac、Android、iOS

快捷键

alt + F4 %关闭当前窗口

win + E %打开我的电脑

win + D %最小化所有页面

DOS

1. win + R 输入cmd
2. 任意文件夹下面，按住shift+鼠标右键，打开powershell
3. 资源管理器地址栏前面加cmd

 D: %盘符+冒号进入磁盘
 dir %显示目录
 cd + 地址 %change directory进入
 cd + /d + D:\电影 %跨盘符切换
 cd.. %返回上一级
 cls %clean screen清理屏幕
 ipconfig %查看电脑ip config配置
 
 #打开应用
 calc
 mspaint
 notepad
 
 #ping 命令
 ping www.google.com
 
 #创建文件夹
 md
 
 #文件
 cd 空格 >a.txt
 del a.txt
 rd

摩尔定律

第三代语言

C语言时典型的面向过程的语言，C++、Java时典型的面向对象的语言。

Java入门

高可用 高性能 高并发

特性

简单性、面向对象、可移植性、高性能、分布式、动态性、多线程、安全性、健壮性

跨平台

write once、run anywhere

版本

JavaSE：标准版（桌面程序，控制台开发）

JavaME：嵌入式开发（几乎淘汰）

JavaEE：企业级开发（web端，服务器开发）

JDK、JRE、JVM

JDK：Java Development Kit %开发者工具箱

JRE：Java Runtine Environment %运行环境

JVM：Java Virtual Machine %虚拟机

安装开发环境

1. 配置环境变量JAVA_HOME
2. 配置path变量

测试安装成功

cmd–> java -version

目录

bin：可执行程序

include：引入C语言中的一些头文件

jre：运行环境

lib：库文件

src：资源文件 类

hello world

记事本编辑editplus配置：关闭文件类型及语法自动完成；关闭自动保存创建备份

public class hello{
	public static void main(String[] args){
		System.out.print("hello world");
	}
}

编译javac ().java

运行java ()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-olU8pZWX-1633015148278)(F:\学习\code\hello.png)]

Java程序运行机制

compile编译型 解释型

IDEA

集成开发环境IDE（Integrated Development Environment ）：用于提供程序开发环境的应用程序，一般包括代码编辑器、编译器、调试器和图形用户界面等工具。

Java基础

注释

1. 单行注释：//
2. 多行注释：/* ··· */
3. 文档注释：/** … */

有趣的代码注释

标识符

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

标识符以字母、美元符$、下划线开始。首字符之后可以是任意组合（字母、下划线、美元符、数字）。（变量可以中文）

大小敏感。

关键字列表：

数据类型

强类型语言：要求变量使用严格符合规定，所有变量必须先定义才使用。

弱类型语言：VB、JS

八大基本数据类型

byte：Java中最小的数据类型，在内存中占8位(bit)，即1个字节，取值范围-2^7 ~ 2^7-1（-128~127），默认值0

short：短整型，在内存中占16位，即2个字节，取值范围-2^15 ~ 2^15-1（-32768~32767），默认值0

int：整型，用于存储整数，在内在中占32位，即4个字节，取值范围-2^31 ~ 2^31-1 (-2147483648~2147483647)约21亿，默认值0

long：长整型，在内存中占64位，即8个字节-2^63~263-1，默认值0L

Java语言的整型常数默认为int型，声明long型常量可以后加‘ l ’或‘ L ’ 。

float：浮点型，在内存中占32位，即4个字节，用于存储带小数点的数字（与double的区别在于float类型有效小数点只有6~7位），默认值0

double：双精度浮点型，用于存储带有小数点的数字，在内存中占64位，即8个字节，默认值0

注意： 默认的小数值是double类型的

注意： 默认的小数值是double类型的
所以 float f = 54.321会出现编译错误，因为54.321的默认类型是 double，其类型 长度为64，超过了float的长度32
在数字后面加一个字母f，直接把该数字声明成float类型
float f2 = 54.321f,
这样就不会出错了

当以f或者F结尾的时候，就表示一个float类型的浮点数，否则就是double类型（以d或者D结尾，写不写都可以）。
浮点数还可以用E或者e表示（科学计数法）
e2表示10的二次方，即100
1.234e2 = 1.234x100

char：字符型，用于存储单个字符，占16位，即2个字节，取值范围0~65535，默认值为空

字符的字面值放在单引号中

字符串的字面值放在双引号中

需要注意的是，\表示转义，比如需要表示制表符，回车换行，双引号等就需要用 \t \r \n " 的方式进行

 public static void main(String[] args) {
     String name = "盖伦";
     char a= 'c';

     //以下是转义字符
     char tab = '\t'; //制表符
     char carriageReturn = '\r'; //回车
     char newLine = '\n'; //换行
     char doubleQuote = '\"'; //双引号
     char singleQuote = '\''; //单引号
     char backslash = '\\'; //反斜杠

 }
}

boolean：布尔类型，占1个字节，用于判断真或假（仅有两个值，即true、false），默认值false

byte short int long 
float double
char
boolean

public class Helloword {
        public static void main(String[] args) {
            long val = 26L; //以L结尾的字面值表示long型
            int decVal = 26; //默认就是int型
            int hexVal = 0x1a; //16进制
            int oxVal = 032; //8进制
            int binVal = 0b11010; //2进制
            System.out.println(oxVal+val);
        }
    }

引用类型

String：String类型其实并不是基本类型，但是它是如此广泛的被使用，常常被误以为是一种基本类型。
String类型是Immutable的，一旦创建就不能够被改变

类

接口

数组

数据类型拓展

System.out.println(Integer.toBinaryString(i2)); //查看一个整数对应的二进制的方法

整数拓展：二进制0b、十进制、八进制0、十六进制0x（0-9，A-F）

浮点数拓展：float有限、离散、舍入误差、大约、接近但不等于（最好不要使用float）；银行常用BigDecimal

System.out.println((int)c); //强制转码

所有字符本质还是数字

编码Unicode表：（97=a、65=A） 2字节 0-65536（2^16）

转义字符

\t 制表符（相当于键盘上按下TAB键之间的距离，一般为8个空格。）

使用制表符是把输出的切入点移动到下一个能被8整除的位置上。
即当打印小于八格的结果，用空格补足八格再打印下一个结果；当大于等于八格，小于十六格，补足十六格；以此类推。

\n换行符

public class text02 {
    public static void main(String[] args) {
        System.out.println("1234567 12345678 0.1234567 0.12345678");
        System.out.println("1234567\t12345678\t0.12345\t0.12345678");
        System.out.println("1234567 \n12345678\n0.1234567\n0.12345678");
    }
}

类型转换

小数的优先级大于整数

byte，short，char->int->long->float->double

//强制转换 （类型）变量名 高到低 要避免内存溢出

//自动转换 低到高

运算时如果有一个参数是L或者double，结果位L或者double

运算时如果比int低，结果均为int

注意

1. 不能对布尔值转换
2. 不能把对象类型转换为不相干类型
3. 高到低时，强制转换
4. 可能出现内存溢出或者精度问题

int money=10_0000_0000; JDK7新特性，数字之间可以用下划线分割

变量

type varName [=value] [{,varName[=value]}];//数据类型 变量名 =值；可以使用逗号隔开来声明多个同类型变量。

当一个变量被声明在类下面
变量就叫做字段 或者属性、成员变量、Field
比如变量i,就是一个属性。
那么从第2行这个变量声明的位置开始，整个类都可以访问得到
所以其作用域就是从其声明的位置开始的整个类

声明在方法内的变量，叫做局部变量
其作用域在声明开始的位置，到其所处于的块结束位置

声明在方法内的变量，叫做局部变量
其作用域在声明开始的位置，到其所处于的块结束位置

public class HelloWorld {
 
    public void method1() {
        int i  = 5;  //其作用范围是从声明的第4行，到其所处于的块结束12行位置
        System.out.println(i);
        {            //子块
            System.out.println(i); //可以访问i
            int j = 6;
            System.out.println(j); //可以访问j
        }
        System.out.println(j); //不能访问j,因为其作用域到第10行就结束了
    }
 
}

变量作用域

1. 类变量：从属类
2. 实例变量：在类里，从属于对象，如果不初始化，会变成默认值（基本类型0 0.0 Boolean默认false，此外都是null
3. 局部变量：在方法内，必须声明和初始化

public class Variable{
    static int salary = 2500; //类变量
    String str = "hello"; //实例变量
    int age;
    
    public void method(){
        int i = 0; //局部变量
        System.out.println(i);
        
        //实例变量 变量类型 变量名字 = new Variable();
        Variable variable = new Variable();
        System.out.println(variable.str); //输出null
        System.out.println(variable.age); //输出0
        
        //类变量 static
        System.out.println(salary);
    }
}

常量

初始化（initialize）后不能再改变值

final 常量名=值；//一般使用大写字母

如果在声明的时候未赋值，那么可以在后面代码进行唯一的一次赋值

inal 除了修饰变量，还可以修饰类，修饰方法

final修饰的类不能被继承 final定义的方法不能被重写 final定义的常量不能被重写赋值

final int[] a = {1,2,3} 这种栈里a变量空间存放的是堆内存的地址。地址是不可变的，但是数组里的值是可以变

final 修饰的变量在方法中，可以先初始化再赋值。 但是如果是全局变量，必须在初始化的时赋值，不然会报错。

当final修饰形参时，不能在方法里赋值，因为在调用方法的时候，就一定会第一次赋值了，后面不能再进行多次赋值

public class text03 {
    //修饰符，不存在先后顺序
    final static double PI = 3.14;
    //static final double PI = 3.14;

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

表达式

表达式是由变量、操作符以及方法调用所构成的结构。

; 也是一个完整的表达式

块

从**{** 开始 到对应的**}** 结束，即一个块

public class HelloWorld { //类对应的块
    public static void main(String[] args) { //主方法对应的块
        System.out.println("abc");
    }
}

命名规范

类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写

局部变量：首字母小写和驼峰原则

常量：大写字母和下划线：MAX_VALUE

类名：首字母大写和驼峰原则：GoodMan

方法名：首字母小写和驼峰原则：runRun()

运算符

算术运算符：+、-、*、/、%（模运算，取余）、++、–

赋值运算符：=

关系运算符：>、<、>=、<=、==、！=、instanceof

逻辑运算符：&&、||、！

& &&	长路与 和 短路与
| ||	长路或 和 短路或
!	取反
^	异或^

public static void main(String[] args){
//长路与  无论第一个表达式的值是true或者false,第二个的值，都会被运算
//短路与 只要第一个表达式的值是false的，第二个表达式的值，就不需要进行运算了

//长路或  无论第一个表达式的值是true或者false,第二个的值，都会被运算
//短路或 只要第一个表达式的值是true的，第二个表达式的值，就不需要进行运算了
int i = 2;
System.out.println( i== 1 | i++ ==2  ); //无论如何i++都会被执行，所以i的值变成了3
System.out.println(i);

}

位运算符：&、|、^、~、>>、<<、>>>（了解）

Integer.toBinaryString()	一个整数的二进制表达
|	位或
&	位与
^	异或
~	取非
<< >>	左移 右移
>>>	带符号右移与无符号右移

public class HelloWorld {
 public static void main(String[] args) {
     int i  =5;
     int j = 6;
     System.out.println(Integer.toBinaryString(i)); //5的二进制是 101
     System.out.println(Integer.toBinaryString(j)); //6的二进制是110
     System.out.println(i^j); //所以 5^6 对每一位进行或运算，得到 011->3

     System.out.println(i^0); //任何数和自己进行异或 都等于 0
     System.out.println(i^i); //任何数和0 进行异或 都等于自己
 }
}

条件运算符 ？、：

扩展赋值运算符：+=、-=、*=、/=

Ctrl+D 在IDEA中复制当前行到下一行

//运算时如果有一个参数是L或者double，结果位L或者double
//运算时如果比int低，结果均为int,包括char
public class Text04 {
    public static void main(String[] args) {
        long a = 123456789L;
        int b = 12356;
        short c = 100;
        byte d = 5;
        double e = 3.14;
        char f = 'g';
        System.out.println(a+b);//Long
        System.out.println(b+c);//Int
        System.out.println(c+d);//Int
        System.out.println(d+e);//Double
        System.out.println(d+f);//Int

    }
}

一元运算符
int b = a++; //执行完这段代码后，先给b赋值，再自增
int c = ++a; //执行完这段代码前，先自增，再赋值

幂运算需要使用工具类

Math.pow(3,2); //9

逻辑与会造成短路运算

public class Text05 {    
    public static void main(String[] args) {        
        boolean a = true;        
        boolean b = false;        
        System.out.println("a && b: "+ (a && b)); //逻辑与运算：两个都为真，结果真；若第一个为假，会造成短路运算
        System.out.println("a || b: "+ (a || b));        
        System.out.println("!（a && b）: "+ !(a && b));        //短路运算        
        int c = 5;        
        boolean d = (c<4) && (c++<4);        
        System.out.println(d);        
        System.out.println(c); //5    
    }
}

位运算是对二进制位的运算

A&B 与

A|B 或

A^B 异或（相同为0，不同为1）

~B 非

最快速度运算2*8（位运算，效率高）

0000 0000    00000 0001    10000 0010    20000 0100    40000 1000    8

<< 左移 （*2） >>右移（/2）

>>:带符号右移。正数右移高位补0，负数右移高位补1。比如：

4>>1，结果为2；

-4>>1，结果为-2.

>>>：无符号右移。无论正数还是负数，高位通通补0.

对于正数而言，>>和>>>没有区别。

负数转换为二进制，就是将其相反数（正数）的补码的每一位变反（1变0，0变1）最后将变完了的数值加1，就完成了负数的补码运算。这样就变成了二进制。

对于负数而言，-2>>>1，结果是2147483647（Integer.MAX_VALUE）

-1>>>1，结果是2147483647（Integer.MAX_VALUE）

a+=b; //a=a+b

a-=b; //a=a-b

+=即自加
i+=2;
等同于
i=i+2;
其他的 -= , *= , /= , %= , &= , |= , ^= , >>= , >>>= 都是类似

public class Text06 {    
    public static void main(String[] args) {        
        int a = 10;        
        int b = 20;        
        //字符串连接符 + ， String        
        System.out.println(a+b); //30        
        System.out.println(""+a+b); //1020        
        System.out.println(a+b+""); //30    
    }
}

三元运算符 条件运算符

x ？y ：z //如果x==ture，则结果为y，否则结果为z

public class Text07 {    
    public static void main(String[] args) {        
        int score = 80;        
        String type = score < 60 ? "不及格" : "及格";        
        System.out.println(type);    
    }
}

优先级

Java 语言中运算符的优先级共分为 14 级，其中 1 级最高，14 级最低。在同一个表达式中运算符优先级高的先执行。

**结合性：**当一个运算对象两侧的运算符优先级别相同时，则按运算符的结合性来确定表达式的运算顺序。

包机制

包的本质就是一个文件夹

一般使用公司域名倒置作为包名：com.baidu.www

为了使用某一个包的成员，我们需要再Java程序中明确导入该包。使用“import”语句可以完成此功能。

import package1.package2.classname;

import package1.package2.*; //导入这个包下所有的类

JavaDoc（/**… */）

加在类上面就是类的注释，加在方法上面就是方法的注释

@author

@version 版本号

@since 指明需要最早使用的jdk版本

@param 参数名

@return 返回值情况

@throws 异常抛出情况

打开cmd，进入该类所在的目录，然后输入

javadoc -encoding UTF-8 -charset UTF-8 Text08.java

• -encoding UTF-8：表示设置编码。
• -charset UTF-8：也表示设置编码。

IDEA

Java流程控制

Scanner对象

注意： 使用Scanner类，需要在最前面加上

import java.util.Scanner;

实现程序和人的交互，java.util.Scanner是Java5的新特征，可以通过Scanner类来获取用户的输入。

Scanner s = new Scanner(System.in);

通过Scanner类的next()与nextLine()方法获取输入的字符串

String str = scanner.nextLine();

读取前，需要使用hasNext()与hasNextLine()判断是否还有输入数据。

凡是属于IO流的类如果不关闭会一直占用资源 即输入输出流

scanner.close();

package com.wang.operator;

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()读取到空格结束；

nextLine()读取到enter结束；

next() 与 nextLine() 区别

next():

• 1、一定要读取到有效字符后才可以结束输入。
• 2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
• 3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
• next() 不能得到带有空格的字符串。

nextLine()：

• 1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
• 2、可以获得空白。

需要注意的是，如果在通过nextInt()读取了整数后，再接着读取字符串，读出来的是回车换行:"\r\n",因为nextInt仅仅读取数字信息，而不会读取回车换行"\r\n".

所以，如果在业务上需要读取了整数后，接着读取字符串，那么就应该连续执行两次nextLine()，第一次是取走回车换行，第二次才是读取真正的字符串

import java.util.Scanner;

public class HelloWorld {
 public static void main(String[] args) {
     Scanner s = new Scanner(System.in);
     int i = s.nextInt();
     System.out.println("读取的整数是"+ i);
     String rn = s.nextLine();
     String a = s.nextLine();
     System.out.println("读取的字符串是："+a);
 }
}

判断是否是整数与小数数据

package com.wang.operator;

import java.sql.SQLOutput;
import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); //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();

    }
}

输入多个数字，求和与平均值，enter确认，非数字结束并输出

package com.wang.operator;

import java.util.Scanner;

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

        Scanner scanner = new Scanner(System.in);

        double sum = 0;
        int m = 0;

        while(scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            m++;
            sum = sum + x;
            System.out.println("输入第"+m+"个数据，当前结果sum="+sum);

        }

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


        scanner.close();

    }
}

顺序结构

顺序执行，任何算法的基本结构。

选择结构

//如果只有一个表达式可以不用写括弧，看上去会简约一些

     if(b){
         System.out.println("yes1");
     }

     if(b)
         System.out.println("yes1");

在第6行，if后面有一个分号; 而[分号也是一个完整的表达式]
如果b为true，会执行这个分号，然后打印yes
如果b为false，不会执行这个分号，然后打印yes
这样，看上去无论如何都会打印yes

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

     boolean b = false;

     if (b);
         System.out.println("yes");

 }
}

1. if单选择结构
2. if双选择结构
3. if多选择结构
4. 嵌套的if结构
5. switch多选择结构：判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

package com.wang.operator;

import java.util.Scanner;

public class Demo04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("输入内容");
        String s = scanner.nextLine();

        //判断字符是否相等
        if (s.equals("Hello")){
            System.out.println(s);
        }else{
            System.out.println("不一致");
        }

        System.out.println("End");

        scanner.close();
    }
}

switch多选择结构：判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

变量类型可以是byte、short、int、char、String

注: 每个表达式结束，都应该有一个break;
注: String在Java1.7之前是不支持的, Java从1.7开始支持switch用String的，编译后是把String转化为hash值，其实还是整数
注: enum是枚举类型，在枚举章节有详细讲解

case标签必须为字符串常量或者字面量

case穿透：不加break就全输出

switch(expression){case value: break;default:}

package com.wang.operator;

public class Demo05 {
    public static void main(String[] args) {
        String name = "wang";

        switch (name){
            case "王":
                System.out.println("王");
                break;
            case "wang":
                System.out.println("wang");
                break;
            default:
                System.out.println("error");

        }
    }
}

反编译 查看class文件 ctrl+alt+shift+s打开项目结构

while循环结构

while(布尔表达式){

// 循环内容

}

我们大多数情况会让循环停止下来，需要一个让表达式失效的方式来结束循环。

**死循环：**while(ture){} / /等待客户端连接、定时检查

do…while循环（先执行后判断）和while（先判断后执行）相似，不同在于do…while循环至少执行一次。

package com.wang.operator;

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

        int a = 0;
        while (a < 0){
            System.out.println(a);
            a--;
        }
        System.out.println("===============");
        do{
            System.out.println(a);
            a--;
        }while(a<0 && a>-10);
    }
}

for循环结构

最有效、最灵活的循环结构（100.for+enter自动生成语句）

for(初始化；布尔表达式；更新){

//代码语句

}

死循环 for( ; ; ){}

// 计算0到100之间奇数与偶数和
package com.wang.operator;

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

        int oddSum = 0;
        int evenSum = 0;

        for (int i = 0; i < 100; i++) {
            if (i%2!=0){
                oddSum+=i;
            }else{
                evenSum+=i;
            }
        }

        System.out.println("奇数和："+oddSum+"\n"+"偶数和："+evenSum);

    }

}

print 输出完不会换行

println输出完会换行

//输出5的倍数，每行输出3个
package com.wang.operator;

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

        for(int i=1; i<=1000 ; i++){
            if(i%5==0){
                System.out.print(i+"\t");
            }
            if(i%15==0){
                System.out.println("\n");
            }
        }
    }
}

//打印九九乘法表
package com.wang.operator;public class Demo09 {    
    public static void main(String[] args) {        
        for(int i=1;i<=9;i++){            
            for(int j=1;j<=9;j++){                
                if(j<=i){                    
                    System.out.print(j+"*"+i+"="+(j*i)+"\t");                
                }else{                    
                    System.out.println();                    
                    break;                
                }            
            }        
        }    
    }
}
//利用j<=i的动态变化来优化
package com.wang.operator;public class Demo09 {    
    public static void main(String[] args) {        
        for(int i=1;i<=9;i++){            
            for(int j=1;j<=i;j++){                    
                System.out.print(j+"*"+i+"="+(j*i)+"\t");            
            }            
            System.out.println();        
        }    
    }
}

增强for循环：主要用于数组或集合的增强for循环。

for(声明语句：表达式){

//代码句子

}

package com.wang.operator;public class Demo10 {    
    public static void main(String[] args) {        
        int[] numbers = {10,20,30,40,50,60}; //定义了一个数组        
        for (int i=0;i<=5;i++){            
            System.out.println(numbers[i]);        
        }        
        System.out.println("========================");        
        //遍历数组的元素        
        for (int x:numbers){            
            System.out.println(x);        
        }    
    }
}

break、continue、goto

break用于强行退出循环，不执行循环中剩余的语句（可在switch中使用）

直接结束当前for循环

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

  //打印单数    
  for (int j = 0; j < 10; j++) {
      if(0==j%2) 
          break; //如果是双数，直接结束循环

      System.out.println(j);
  }
}
}

continue用于终止某次循环过程，接着进行下一次是否执行循环的判定

如果是双数，后面的代码不执行，直接进行下一次循环

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

  //打印单数    
  for (int j = 0; j < 10; j++) {
      if(0==j%2) 
          continue; //如果是双数，后面的代码不执行，直接进行下一次循环

      System.out.println(j);
  }
}
}

**标签：**指后面跟一个冒号的标识符，如：label：

package com.wang.operator;public class Demo11 {    
    public static void main(String[] args) {        
        //打印101-150之间所有的质数        
        //带标签的continue        
        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.print(i+" ");        
        }    
    }
}

使用标签结束外部循环

在外部循环的前一行，加上标签
在break的时候使用该标签
即能达到结束外部循环的效果

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

  //打印单数    
  outloop: //outloop这个标示是可以自定义的比如outloop1,ol2,out5
  for (int i = 0; i < 10; i++) {

      for (int j = 0; j < 10; j++) {
          System.out.println(i+":"+j);
          if(0==j%2) 
              break outloop; //如果是双数，结束外部循环
      }

  }

}
}

借助boolean变量结束外部循环
需要在内部循环中修改这个变量值
每次内部循环结束后，都要在外部循环中判断，这个变量的值

public class HelloWorld {
public static void main(String[] args) {
  boolean breakout = false; //是否终止外部循环的标记
  for (int i = 0; i < 10; i++) {

      for (int j = 0; j < 10; j++) {
          System.out.println(i + ":" + j);
          if (0 == j % 2) {
              breakout = true; //终止外部循环的标记设置为true
              break;
          }
      }
      if (breakout) //判断是否终止外部循环
          break;
  }

}
}

Java方法

一个方法只完成1个功能，这样有利于后期扩展。

ctrl+/注释

//形式参数，用来定义作用的

//实际参数，实际调用传递给他的参数

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

方法体

return 返回值；

}

值传递和引用传递： Java是值传递

//输入两个整数比较大小
package com.wang.method;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int num1 =0;
        int num2 =0;

        System.out.println("输入第一个整数：");
        if (scanner.hasNextInt()) {
             num1 = scanner.nextInt();
        }else{
            System.out.println("输入的不是整数数据");
        }

        System.out.println("输入第二个整数：");
        if (scanner.hasNextInt()) {
            num2 = scanner.nextInt();
        }else{
            System.out.println("输入的不是整数数据");
        }

        int result = max(num1,num2);

        if (result!=0) {
            System.out.println("更大的数为：" + result);
        }else{
            System.out.println("两数相等！");
        }
    }

    public static int max(int num1,int num2){

        int result = 0; //return要提取到最外面

        if (num1==num2){
            return 0; //终止方法
        }
        if (num1<num2){
            result=num2;
        }else{
            result=num1;
        }
        return result;
    }
}

重载

在一个类中，有相同的函数名称，但形参不同的函数。

方法名称相同时，编译器根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

规则：参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。

命令行传参

有时候希望运行一个程序时再传递给它消息。这要靠传递命令行参数给main()函数实现。

可变参数

在方法声明中，在指定参数类型后加一个省略号（…）。

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

package com.wang.method;

public class Demo02 {
    public static void main(String[] args) {
        //调用可变参数
        Demo02 demo02 = new Demo02();
        demo02.pringMax(12,13,2,3,4);
    }

    public void pringMax(double... numbers){ //在方法里，使用操作数组的方式处理参数 numbers 即可
        if (numbers.length == 0){
            System.out.println("No argument passed");
            return;
        }

        double result = 0;
        //排序
        for(int i=1;i< numbers.length;i++){
            if (numbers[i]>result){
                result=numbers[i];
            }
        }
        System.out.println("The max value is "+result);
    }
}

递归

A方法调用A方法。

递归结构：

1. 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
2. 递归体：什么时候需要调用自身方法。

package com.wang.method;

public class Demo03 {
    //阶乘
    public static void main(String[] args) {
        System.out.println(f(8));
    }

    public static int f(int n){
        if (n==1){
            return 1;
        }else{
            return n*f(n-1);
        }
    }
}

Java使用栈机制，递归会调用大量的函数，可能导致内存崩溃

计算器（结果尚未未实现整数输出功能）

写一个计算器，要求实现加减乘除功能，并且能够循环接受新的数据，通过用户交互实现

• 写四个方法：加减乘除
• 利用循环+switch进行用户交互
• 传递需要操作的两个数
• 输出结果

package com.wang.method;

import java.util.Scanner;

public class Demo04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        double num1 =0;
        double num2 =0;

        System.out.println("开始计算！");

        if(scanner.hasNextInt()){
            num1= scanner.nextInt();
        }else{
            if(scanner.hasNextDouble()) {
                num1 = scanner.nextDouble();
            }else {
                System.out.println("输入一个数!");
            }
        }

        String c="";
        if(scanner.hasNext()){
            c= scanner.next();
        }

        if(scanner.hasNextInt()){
             num2= scanner.nextInt();
        }else{
            if(scanner.hasNextDouble()) {
                 num2 = scanner.nextDouble();
            }else {
                System.out.println("输入一个数!");
            }
        }

        switch (c){
            case "+":
                System.out.println(num1+"+"+num2+"="+add(num1,num2));
                break;
            case "-":
                System.out.println(num1+"-"+num2+"="+sub(num1,num2));
                break;
            case "*":
                System.out.println(num1+"*"+num2+"="+mul(num1,num2));
                break;
            case "/":
                System.out.println(num1+"/"+num2+"="+div(num1,num2));
                break;
            default:
                System.out.println("不正确的运算符");
        }


    }

    //加
    public static int add(int num1,int num2){
        int result = num1 +num2;
        return result;
    }
    public static double add(double num1,double num2){
        double result = num1 +num2;
        return result;
    }
    //减
    public static int sub(int num1,int num2){
        int result = num1 -num2;
        return result;
    }
    public static double sub(double num1,double num2){
        double result = num1 -num2;
        return result;
    }
    //乘
    public static int mul(int num1,int num2){
        int result = num1 *num2;
        return result;
    }
    public static double mul(double num1,double num2){
        double result = num1 *num2;
        return result;
    }
    //除
    public static int div(int num1,int num2){
        if (num2==0) {
            System.out.println("error");
            return 0;
        }else{
            int result = num1 / num2;
            return result;
        }
    }
    public static double div(double num1,double num2){
        if (num2==0) {
            System.out.println("error");
            return 0;
        }else{
            double result = num1 / num2;
            return result;
        }
    }

}

数组

数组是相同类型数据的有序集合。每个数组元素可以通过一个下标来访问他们。

声明数组变量，才能在程序中使用数组。

dataType[] arrayRefVar; //声明一个数组。首选的方法、int[] nums;
dataType arrayRefVar[]; //效果相同，但不是首选方法（C和C++首选）

nums = new int[10]; //创建一个数组

Java语言使用new操作符来创建数组：

dataType[] arrayRefVar = new dataType[arraySizw]; //int[] nums = new int[10];

获取数组长度：

array.length

创建数组的时候，要指明数组的长度。
new int[5]
引用概念：
如果变量代表一个数组，比如a,我们把a叫做引用
与基本类型不同
int c = 5; 这叫给c赋值为5
声明一个引用 int[] a;
a = new int[5];
让a这个引用，指向数组

public class HelloWorld {
public static void main(String[] args) {
  //声明一个引用
  int[] a;
  //创建一个长度是5的数组，并且使用引用a指向该数组
  a = new int[5];

  int[] b = new int[5]; //声明的同时，指向一个数组

}
}

把一个数组的值，复制到另一个数组中

System.arraycopy(src, srcPos, dest, destPos, length)
src: 源数组
srcPos: 从源数组复制数据的起始位置
dest: 目标数组
destPos: 复制到目标数组的起始位置
length: 复制的长度

public class HelloWorld {
  public static void main(String[] args) {
      int a [] = new int[]{18,62,68,82,65,9};

      int b[] = new int[3];//分配了长度是3的空间，但是没有赋值

      //通过数组赋值把，a数组的前3位赋值到b数组

      //方法一： for循环

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

      //方法二: System.arraycopy(src, srcPos, dest, destPos, length)
      //src: 源数组
      //srcPos: 从源数组复制数据的起始位置
      //dest: 目标数组
      //destPos: 复制到目标数组的启始位置
      //length: 复制的长度       
      System.arraycopy(a, 0, b, 0, 3);

      //把内容打印出来
      for (int i = 0; i < b.length; i++) {
          System.out.print(b[i] + " ");
      }

  }
}

内存分析

堆：//创建数组、赋值

1. 存放new的对象和数组

2. 可以被所有的线程共享，不会存放别的对象引用

栈：//声明数组

1. 存放基本变量类型（会包含这个基本类型的具体数值）
2. 引用对象的变量（会存放这个引用在堆里面的具体地址）

方法区：

1. 可以被所有的线程共享
2. 包含了所有的class和static变量

三种初始化

如果指定了数组的内容，就不能同时设置数组的长度。

1. 静态初始化：创建+赋值

int[] a = {1,2,3,4,5,6,7,8,9};
Man[] mans = {new Man(1,1),new Man(2,2)};

2. 动态初始化：

int[] a = new int[2];
a[0]=1;
a[1]=2;

3. 数组的默认初始化：数组是引用类型，他的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

四个基本特点

1. 长度确定
2. 元素类型相同，不允许混合
3. 元素可以是任何数据类型，包括基本类型和引用类型
4. 数组变量属引用类型，数组可看成对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

数组边界

合法区间：[0,length-1]

ArrayIndexOutOfBoundsException：数组下标越界异常！

package com.wang.array;

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

        int[] nums = new int[10];
        nums[0] = 1;

        for (int i = 0; i < nums.length ; i++) {
            System.out.print(nums[i]+" ");
        }

        System.out.println(nums[10]);

        for (int num :nums){ // nums.for
            System.out.println(nums); //适合遍历输出，但是取不到下标
        }
    }
}

使用方法打印与反转整数与小数类型数组

package com.wang.array;

public class Demo02 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        double[] arrays2 = {1.1,2.2,3,4,5};

        int[] reverse = reverse(arrays);
        double[] reverse2 = reverse(arrays2);
        printArray(reverse);
        printArray(reverse2);
    }

    //打印数组
    public static void printArray(int[] arrays){
        for (int array : arrays) {
            System.out.print(array+" ");
        }
        System.out.println("");
    }
    public static void printArray(double[] arrays){
        for (double array : arrays) {
            System.out.print(array+" ");
        }
        System.out.println("");
    }

    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        for(int i=0, j=result.length-1; i < arrays.length;i++,j--){
            result[j]=arrays[i];
        }
        return result;
    }
    public static double[] reverse(double[] arrays){
        double[] result = new double[arrays.length];
        for(int i=0, j=result.length-1; i < arrays.length;i++,j--){
            result[j]=arrays[i];
        }
        return result;
    }
}

多维数组

多维数组可以看出是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

二维数组：

int a[][] = new int[2][5]; //两行五列

Java中使用多维数组不多，主要是面向对象！

package com.wang.array;

public class Demo03 {
    public static void main(String[] args) {
        int[][] a ={{1,2},{1,2,3},{1},{1,2}};
        System.out.println(a.length); //几行
        System.out.println(a[1].length); //二行几列
        
        for (int i=0; i<a.length;i++){ //遍历输出二维数组
            for(int j=0; j<a[i].length;j++){ //fori
                System.out.print(a[i][j]+" ");
            }
            System.out.println("");
            
        }
    }
}

Arrays类

Arrays是针对数组的工具类，可以进行 排序，查找，复制填充等功能。 大大提高了开发人员的工作效率。

数组的工具类：java.util.Arrays

import java.util.Arrays;

public class HelloWorld {
public static void main(String[] args) {
  int a[] = new int[] { 18, 62, 68, 82, 65, 9 };

  // copyOfRange(int[] original, int from, int to)
  // 第一个参数表示源数组
  // 第二个参数表示开始位置(取得到)
  // 第三个参数表示结束位置(取不到)
  int[] b = Arrays.copyOfRange(a, 0, 3);

  for (int i = 0; i < b.length; i++) {
      System.out.print(b[i] + " ");
  }

}
}

package com.wang.array;

import java.util.Arrays;

public class Demo04 {
    public static void main(String[] args) {
        int[] a = {1,2,4,6,4,234,5423};

        System.out.println(a); //[I@1b6d3586,hashcode

        //打印数组元素Array.toString
        System.out.println(Arrays.toString(a));

        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };//复制数组 
        // copyOfRange(int[] original, int from, int to)
        // 第一个参数表示源数组
        // 第二个参数表示开始位置(取得到)
        // 第三个参数表示结束位置(取不到)
        int[] b = Arrays.copyOfRange(a, 0, 3);

        Arrays.sort(a); //排序
        System.out.println(Arrays.toString(a));
        
        Arrays.fill(a,2,4,0); //数组填充,二到四个元素被零填充[2,4)左闭右开
        System.out.println(Arrays.toString(a));
        
        Arrays.fill(a,0); //数组填充
        System.out.println(Arrays.toString(a));
    }
}

给数组赋值：通过Arrays.fill方法

对数组排序：通过Arrays.sort方法，按升序

比较数组：通过Arrays.equals方法比较数组中元素值是否相等

查找数组元素：通过Arrays.binarySearsh方法能对排序好的数组进行二分查找法操作

查询元素出现的位置
需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序
如果数组中有多个相同的元素，查找结果是不确定的

import java.util.Arrays;

public class HelloWorld {
public static void main(String[] args) {
  int a[] = new int[] { 18, 62, 68, 82, 65, 9 };

  Arrays.sort(a);

  System.out.println(Arrays.toString(a));
  //使用binarySearch之前，必须先使用sort进行排序
  System.out.println("数字 62出现的位置:"+Arrays.binarySearch(a, 62));
}
}

冒泡排序

总共有八大排序。

冒泡排序和选择排序

1.冒泡排序是比较相邻位置的两个数，而选择排序是按顺序比较，找最大值或者最小值；

2.冒泡排序每一轮比较后，位置不对都需要换位置，选择排序每一轮比较都只需要换一次位置；

3.冒泡排序是通过数去找位置，选择排序是给定位置去找数；

冒泡排序可以借助boolean变量结束外部循环，

嵌套循环，时间复杂度O（n2）

package com.wang.array;

import java.util.Arrays;

public class Demo05 {
    public static void main(String[] args) {
        /*
        冒泡排序
        1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
        2.每一次比较，都会产生出一个最大，或者最小的数字
        3.下一轮则可以少一次排序
        4.依次循环，直到结束
         */
        int[] a={1,2,3,4};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));

    }

    public static int[] sort(int[] array){ //优化-当有一轮没有交换位置的时候，说明已经排序好了，则结束
        int temp = 0;

        //外层循环，判断要走多少次
        for (int i = 0; i < array.length-1; i++) {

            boolean flag = false; //通过flag标识位减少没有意义的比较

            //内层循环，比价判断两个数，如果第一个数，比第二个数大，则交换位置
            for (int j = 0;j < array.length-1-i;j++){
                if (array[j+1]<array[j]){ //flag的作用点在这里！
                    temp = array[j];
                    array[j]= array[j+1];
                    array[j+1]=temp;
                    flag = true;
               
            }

            if (flag==false){
                break;
            }
        }
        return array;
    }
}

稀疏数组

稀疏数组的存放和读取

package com.wang.array;

public class Demo06 {
    public static void main(String[] args) {
        int[][] a=new int[11][11];
        a[1][2]=1;
        a[2][3]=2;

        System.out.println("输出原始数组：");

        arraysPrint(a);

        System.out.println("===============");
        //转换为稀疏数组保存
        //获取有效值个数
        
        //1.计数不为零的个数
        int sum =0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if(a[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数："+sum);

        //2.创建一个稀疏数组
        int[][] a2=new int[sum+1][3];

        a2[0][0]=a.length;
        a2[0][1]=a[0].length;
        a2[0][2]=sum;

        //3.遍历二维数组，将非零值存放进去
        int count=0;//用来表示存放行数
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if(a[i][j]!=0){
                    count++;
                    a2[count][0]=i;
                    a2[count][1]=j;
                    a2[count][2]=a[i][j];
                }
            }
        }

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

        arraysPrint(a2);

        System.out.println("===============");
        System.out.println("还原：");

        //1.读取稀疏数组值
        int[][] a3= new int[a2[0][0]][a2[0][1]];
        //2.给其中元素还原值
        for (int i = 1; i < a2.length; i++) {
            a3[a2[i][0]][a2[i][1]]=a2[i][2];
        }
        //输出还原数组
        arraysPrint(a3);
    }

    public static void arraysPrint(int[][] arrays){
        for (int[] ints : arrays) { // a.for遍历输出
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

arrays.for遍历输出

面向对象编程OOP

引用的概念，如果一个变量的类型是 类类型，而非基本类型，那么该变量又叫做引用。

//创建一个对象
new Hero;
//使用一个引用来指向这个对象
Hero h = new Hero();
Hero h2 = h;  //h2指向h1所指向的对象

一个引用，同一时间，只能指向一个对象。

属性（这里的属性应该包含了构造器的定义）加方法变成一个类。

**面向对象思想：**抽象。物以类聚，分类的思维方式。对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

三大特性：

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

从认识论的角度：先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。

从代码运行的角度：先有类后有对象。类是对象的模板。

类与对象的创建

使用new关键字创建对象。

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

package com.wang.oop;

//学生类
public class Student {

    //属性：字段
    String name;
    int age;
    
    //这里有一个默认的构造器
    // public Student() {
    // }

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

package com.wang.oop;

//一个项目应该只存在一个main方法
public class Application {

    public static void main(String[] args) {

        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象！
        //student对象就是一个Student类的具体实例！
        Student xiaoming = new Student();
        Student xiaohong= new Student();

        xiaoming.name="小明";
        xiaoming.age= 3;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);


    }
}

构造器

通过一个类创建一个对象，这个过程叫做实例化

实例化是通过调用构造方法(又叫做构造器)实现的

类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

1. 必须和类的名字相同
2. 必须没有返回类型，也不能写void

类的创建

package com.wang.oop;

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器

    String name;
    int age;

    //实例化初始值
    //使用new关键字，本质是在调用构造器

    //无参构造 默认构造器
    public Person(){ //Person person = new Person();想使用这样new Person()时必须有这样一个构造器
    }

    //有参构造：一旦定义了有参构造，无参必须显示定义
    public Person(String name){ Person person = new Person("wang");自动判断，调用有参构造，相当于方法的重载
        this.name =name;//前面的name代表类，后面的代表传进来的参数
    }

    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
}
/*
     构造器：
        1.和类名相同
        2.没有返回值
     作用：
        1.new 本质在调用构造方法
        2.初始化对象的值
     注意点：
        1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

     Alt + Insert

     this. =  //this后面的指这一个类
 */

类的调用

package com.wang.oop;

public class Application02 {
    public static void main(String[] args) {
        Person person = new Person(); //因为使用了这个，所以需要显示定义一个无参构造
        Person person1 = new Person("wang");
        Person person2=new Person("wang",23);

        System.out.println(person.name);
        System.out.println(person1.name);
        System.out.println(person2.name+person2.age);
    }
}

this

this这个关键字，相当于普通话里的“我”
this即代表当前对象，也就是调用方法的对象

//参数名和属性名一样
//在方法体中，只能访问到参数name
public void setName1(String name){
  name = name;
}

//为了避免setName1中的问题，参数名不得不使用其他变量名
public void setName2(String heroName){
  name = heroName;
}

//通过this访问属性
public void setName3(String name){
  //name代表的是参数name
  //this.name代表的是属性name
  this.name = name;
}

如果要在一个构造方法中，调用另一个构造方法，可以使用this()

package com.wang.oop.demo01;

public class Hero {

String name; //姓名
float hp; //血量
float armor; //护甲
int moveSpeed; //移动速度

//带一个参数的构造方法
public Hero(String name){
  System.out.println("一个参数的构造方法");
  this.name = name;
}

//带两个参数的构造方法
public Hero(String name,float hp){
  this(name); //调用了一个参数的构造方法
  System.out.println("两个参数的构造方法");
  this.hp = hp;
}

public static void main(String[] args) {
  Hero teemo =  new Hero("提莫",383);

  System.out.println(teemo.name);

}

}

创建对象内存分析

如果一个变量是基本类型
比如 int hp = 50;
我们就直接管hp叫变量
=表示赋值的意思。
如果一个变量是类类型
比如 Hero h = new Hero();
我们就管h叫做引用。
=不再是赋值的意思
=表示指向的意思
比如 Hero h = new Hero();
这句话的意思是
引用h，指向一个Hero对象

栈：//声明数组

1. 存放基本变量类型（会包含这个基本类型的具体数值）
2. 引用对象的变量（会存放这个引用在堆里面的具体地址）

堆：//创建数组、赋值

1. 存放new的对象和数组

2. 可以被所有的线程共享，不会存放别的对象引用

方法区：

1. 可以被所有的线程共享
2. 包含了所有的class和static变量

理解Java的值传递

关于teemo为什么最终仍然指向“旧”提莫：
第31行调用revive方法，实参为teemo，teemo本身是一个引用，占用一个内存单元，其中存放“旧”提莫的地址值，而java为值传递，所以该调用只是将teemo的值，即“旧”提莫的地址值，将该值拷贝下来，复制给形参h，此时teemo显然仍指向“旧”提莫，h现在存放“旧”提莫的地址值，但是通过调用构造方法，新建了一个Hero对象，并将"新"提莫的地址值赋值给h。
结果：teemo指向“旧”提莫，h指向“新”提莫。
理解关键：java基于值传递而非引用传递。

public class Hero {

String name; //姓名        
float hp; //血量        
float armor; //护甲        
int moveSpeed; //移动速度     
public Hero(){         
}

public Hero(String name,float hp){
  this.name = name;
  this.hp = hp;
}

//复活
public void revive(Hero h){
  h = new Hero("提莫",383);
}

public static void main(String[] args) {
  Hero teemo =  new Hero("提莫",383);

  //受到400伤害，挂了
  teemo.hp = teemo.hp - 400;         
  teemo.revive(teemo); //teemo.hp = -17;因为形参h传递到了实参teemo的指向，即地址，然后又指向了新构造的对象        
  //问题： System.out.println(teemo.hp); 输出多少？ 怎么理解？         
}      
}

小结

1. 类与对象

   类是一个模板：抽象；对象是一个具体的实例

2. 方法

   定义、调用！

3. 对象的引用

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

   对象是通过引用来操作的：栈–>堆

4. 属性：字段Field 成员变量

   默认初始化：

   数字：0 0.0；char：u0000；boolean：false；引用：null

   修饰符 属性类型 属性名 = 属性值！

5. 对象的创建和使用

   必须使用new 关键字创造对象，构造器

   对象的属性 wang.name

   对象的方法 wang.sleep()

6. 类

   静态的属性 属性

   动态的行为 方法

封装

“高内聚，低耦合：”

高内聚，类的内部数据操作细节自己完成，不允许外部干涉；低耦合，仅暴露少量的方法给外部使用。

**封装（数据的隐藏）：**通常应禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏。

属性私有，get/set

/*

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

package com.wang.oop.demo05;

public class Student {

        //private:私有

        //属性私有
        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 getId() {
                return id;
        }

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

        public int getAge() {
                return age;
        }

        public void setAge(int age) { //封装可以规避这种不合法的数据
                if(age>130 || age<0){ //不合法
                        this.age = 0;
                }else {
                this.age = age;
                }
        }
}
/*
1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 提高系统的可维护性
 */

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

extends：扩展。子类是父类的扩展。

Java中类只有单继承，没有多继承！

package com.wang.oop.demo06;
//Java中，所有的类都默认直接或者间接继承Object类
//基类、父类
public class Person /*extend Object*/ {

    private int money = 10_0000_0000;

    public void say(){
        System.out.println("say hi");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
    //ctrl + H 打开继承项
}

package com.wang.oop.demo06;
//派生类、子类
public class Student extends Person{
}

package com.wang.oop.demo06;
public class Application {
    public static void main(String[] args) {
        Student student = new Student();

        student.say(); //可以调用Person类中的方法
    }
}

Super

public class Student extends Person{
    public Student() {
        super(); //隐藏代码，调用了父类的无参构造，且调用父类的构造器，必须要在子类构造器的第一行
        //当父类没有无参构造，子类无参构造需要显示的定义父类有参
    }


    private String name = "da";

    public void test(String name){
        System.out.println(name); //zhuang
        System.out.println(this.name); //da
        System.out.println(super.name); //wang
    }
}

/*
父类Hero提供了一个有参的构造方法:
public Hero(String name){
  this.name = name;
}
但是没有提供无参的构造方法
子类应该怎么处理？
*/
package charactor;   
public class Hero {
    public String name;
    protected float hp;
   
    public Hero(String name){
        this.name = name;
    }     
//    故意不提供无参的构造方法
//    public Hero(){
//    }     
    public static void main(String[] args) {     
    }       
}

//子类添加有参构造方法
public ADHero(String name) {
        super(name);
        System.out.println("adHero的构造方法");
         
}

重写

重写都是方法的重写，和属性无关。

重写：需要又继承关系，子类重写父类的方法！

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大： public > protected > default > private
4. 抛出的异常：范围 可以被缩小，但不能扩大； ClassNotFoundException --> Exception（大）

为什么要重写：父类的功能，子类不一定需要，或者不一定满足。

Alt + Insert ； override；

package com.wang.oop.demo07;
//重写都是方法的重写，和属性无关。
public class A extends B{
    //Override 重写
    @Override //注解：有功能的注释！
    public void test() {
        super.test();
    }
}

隐藏

与重写类似，方法的重写是子类覆盖父类的对象方法

隐藏，就是子类覆盖父类的类方法

package charactor;
  
public class Hero {
    public String name;
    protected float hp;
  
    //类方法，静态方法
    //通过类就可以直接调用
    public static void battleWin(){
        System.out.println("hero battle win");
    }   
}

package charactor;
public class ADHero extends Hero implements AD{  
    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }
     
    //隐藏父类的battleWin方法
    public static void battleWin(){
        System.out.println("ad hero battle win");
    }   
     
    public static void main(String[] args) {
        Hero.battleWin();
        ADHero.battleWin();
    }  
}

Hero h =new ADHero();

h.battleWin(); //battleWin是一个类方法
h是父类类型的引用
但是指向一个子类对象
h.battleWin(); 会调用父类的方法？还是子类的方法？

**父类引用指向子类对象: **

**静态方法, 引用是啥类型就输出啥类的方法; **

非静态方法, 对象是啥类型就输出啥类型的方法;

  //当继承的方法为静态方法时，父类指向子类，JVM使用的是静态绑定
  //当继承的方法不是静态方法时，父类指向子类，JVM使用的是动态绑定
  //想要继承的方法为静态的方法时，想要调用子类的重写方法，直接子类名称.静态方法
  //当出现private,final,static,以及构造器的时候，JVM会调用静态绑定

多态

操作符的多态
+ 可以作为算数运算，也可以作为字符串连接

同一个操作符在不同情境下，具备不同的作用
如果+号两侧都是整型，那么**+代表 数字相加**
如果+号两侧，任意一个是字符串，那么**+代表字符串连接**

类的多态: 都是同一个类型，调用同一个方法，却能呈现不同的状态
父类引用指向子类对象

要实现类的多态，需要如下条件

1. 父类（接口）引用指向子类对象
2. 调用的方法有 重写

/*
如果物品的种类特别多，那么就需要设计很多的方法
比如useArmor,useWeapon等等

这个时候采用多态来解决这个问题
设计一个方法叫做useItem，其参数类型是Item
如果是使用血瓶，调用该方法
如果是使用魔瓶，还是调用该方法
无论英雄要使用什么样的物品，只需要一个方法即可
*/
package charactor;

import property.Item;
import property.LifePotion;
import property.MagicPotion;

public class Hero {
  public String name;
  protected float hp;

  public void useItem(Item i){
      i.effect();
  }

  public static void main(String[] args) {

      Hero garen =  new Hero();
      garen.name = "盖伦";

      LifePotion lp =new LifePotion();
      MagicPotion mp =new MagicPotion();

      garen.useItem(lp);
      garen.useItem(mp);     

  }

}

动态编译：类型：可扩展性更强；

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

多态注意事项：

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

有些方法不能重写：

1. static 方法，属于类 不属于实例
2. final 常量
3. private 方法

package com.wang.oop;
import com.wang.oop.demo08.Person;
import com.wang.oop.demo08.Student;
public class Application {    
    public static void main(String[] args) {        
        //一个对象的实际类型是确定的        
        //可以指向的引用类型不确定：父类的引用指向子类        
        //Student 能调用的方法都是自己的或者继承父类的！        
        Student s1 = new Student();        
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法        
        Person s2 = new Student();        
        Object s3 = new Student(); //Object是所有子类的祖宗类        
        // 对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！        
        s1.eat();        
        ((Student)s2).eat(); 
        //强制转换 子类重写了父类的方法，执行子类的方法   
    }
}

Object

Object类是所有类的父类

声明一个类的时候，默认是继承了Object
public class Hero extends Object

toString

Object类提供一个toString方法，所以所有的类都有toString方法
toString()的意思是返回当前对象的字符串表达
通过 System.out.println 打印对象就是打印该对象的toString()返回值

        System.out.println(h.toString());
        //直接打印对象就是打印该对象的toString()返回值
        System.out.println(h);

finalize

当一个对象没有任何引用指向的时候，它就满足垃圾回收的条件

当它被垃圾回收的时候，它的finalize() 方法就会被调用。

finalize() 不是开发人员主动调用的方法，而是由虚拟机JVM调用的。

package charactor;
  
public class Hero {
    public String name;
    protected float hp;
      
    public String toString(){
        return name;
    }
     
    public void finalize(){
        System.out.println("这个英雄正在被回收");
    }
      
    public static void main(String[] args) {
        //只有一引用
        Hero h;
        for (int i = 0; i < 100000; i++) {
            //不断生成新的对象
            //每创建一个对象，前一个对象，就没有引用指向了
            //那些对象，就满足垃圾回收的条件
            //当，垃圾堆积的比较多的时候，就会触发垃圾回收
            //一旦这个对象被回收，它的finalize()方法就会被调用
            h = new Hero();
        }
 
    }
}

equals

equals() 用于判断两个对象的内容是否相同

假设，当两个英雄的hp相同的时候，我们就认为这两个英雄相同

package charactor;
  
public class Hero {
    public String name;
    protected float hp;
      
    public boolean equals(Object o){ //Hero类向上转型
        if(o instanceof Hero){
            Hero h = (Hero) o; //Object类向下转型
            return this.hp == h.hp; //this指的是当前对象，也就是调用equal方法的对象，所以this.hp指的是h1.hp
        }
        return false;
    }
      
    public static void main(String[] args) {
        Hero h1= new Hero();
        h1.hp = 300;
        Hero h2= new Hero();
        h2.hp = 400;
        Hero h3= new Hero();
        h3.hp = 300;
         
        System.out.println(h1.equals(h2));
        System.out.println(h1.equals(h3));
    }
}

hashCode

hashCode方法返回一个对象的哈希值，但是在了解哈希值的意义之前，讲解这个方法没有意义。

线程同步相关方法

Object还提供线程同步相关方法
wait()
notify()
notifyAll()
这部分内容的理解需要建立在对线程安全有足够的理解的基础之上，所以会放在线程交互 的章节讲解

getClass()

getClass()会返回一个对象的类对象，属于高级内容，不适合初学者过早接触，关于类对象的详细内容请参考反射机制

练习

重写Item的 toString(), finalize()和equals()方法
toString() 返回Item的name + price
finalize() 输出当前对象正在被回收
equals(Object o) 首先判断o是否是Item类型，然后比较两个Item的price是否相同

package com.wang.oop.demo11;

public class Item {
    public String name;
    protected float price;

    public String toString(){
        return this.name +"价格"+this.price;
    }
    public void finalize(){
        System.out.println("当前对象正在被回收");
    }
    public boolean equals(Object o){
        if (o instanceof Item){
            Item h = (Item) o;
            return this.price==h.price;
        }
        return false;
    }

    public static void main(String[] args) {
        Item s1 = new Item();
        s1.name="宝剑";
        s1.price=800;
        Item s2 = new Item();
        s2.name="好盾牌";
        s2.price=800;

        System.out.println(s1.toString());
        System.out.println(s1.equals(s2));
    }
}

final

final修饰类，方法，基本类型变量，引用的时候分别有不同的意思。

修饰类

当Hero被修饰成final的时候，表示Hero不能够被继承
其子类会出现编译错误

修饰方法

Hero的useItem方法被修饰成final,那么该方法在ADHero中，不能够被重写

修饰基本类型变量

final修饰基本类型变量，表示该变量只有一次赋值机会
修饰引用

final修饰引用
h引用被修饰成final，表示该引用只有1次指向对象的机会

常量

对象转型

子类转父类(向上转型)，说的通

父类转子类(向下转型)，有的时候行，有的时候不行，所以必须进行强制转换。强制转换的意思就是 转换有风险，风险自担。

以下是对完整的代码的关键行分析
14行： 把ad当做Hero使用，一定可以
转换之后，h引用指向一个ad对象
15行： h引用有可能指向一个ad对象，也有可能指向一个support对象
所以把h引用转换成AD类型的时候，就有可能成功，有可能失败
因此要进行强制转换，换句话说转换后果自负
到底能不能转换成功，要看引用h到底指向的是哪种对象
在这个例子里，h指向的是一个ad对象，所以转换成ADHero类型，是可以的
16行：把一个support对象当做Hero使用，一定可以
转换之后，h引用指向一个support对象
17行：这个时候，h指向的是一个support对象，所以转换成ADHero类型，会失败。
失败的表现形式是抛出异常 ClassCastException 类型转换异常

package charactor;

import charactor1.Support;

public class Hero {
public String name;
protected float hp;

public static void main(String[] args) {
  Hero h =new Hero();
  ADHero ad = new ADHero();
  Support s =new Support();

  h = ad;
  ad = (ADHero) h;
  h = s;
  ad = (ADHero)h;
}

}

没有继承关系的两个类，互相转换，一定会失败
虽然ADHero和APHero都继承了Hero，但是彼此没有互相继承关系
“把魔法英雄当做物理英雄来用”,在语义上也是说不通的

实现类转换成接口(向上转型)

接口转换成实现类(向下转型)

10行： ad引用指向ADHero， 而adi引用是接口类型：AD，实现类转换为接口，是向上转型，所以无需强制转换，并且一定能成功
12行: adi实际上是指向一个ADHero的，所以能够转换成功
14行： adi引用所指向的对象是一个ADHero，要转换为ADAPHero就会失败。

假设能够转换成功，那么就可以使用magicAttack方法，而adi引用所指向的对象ADHero是没有magicAttack方法的。

package charactor;

public class Hero {
public String name;
protected float hp;

public static void main(String[] args) {
  ADHero ad = new ADHero();

  AD adi = ad;

  ADHero adHero = (ADHero) adi;

  ADAPHero adapHero = (ADAPHero) adi;
  adapHero.magicAttack();
}

}

[Java 向上转型和向下转型](

1、把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。

如Father father = new Son();

2、把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型,要向下转型，必须先向上转型为了安全可以用instanceof判断。

如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =（Son）father；

其中father前面的（Son）必须添加，进行强制转换。

3、upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效，向上转型只能引用父类对象的属性，要引用子类对象属性，则要写getter函数。

4、向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。

**父类引用指向子类对象: **

静态方法, 引用是啥类型就输出啥类的方法;

非静态方法, 对象是啥类型就输出啥类型的方法;

package com.wang.oop.Demo09;
/*
向上转型后父类引用不能调用子类自己的方法，就是父类没有但是子类的方法，如果调用不能编译通过，比如子类的speak方法。
非要调用子类的属性呢？如果不向下转型就需要给需要的属性写getter方法。

class Male extends Human {
   String name = "Male";
   public String getName(){
       return this.name;
   }
}
非要调用子类扩展的方法，比如speak方法，就只能向下转型了。     
*/

public class Human {
   public void sleep() {
       System.out.println("Human sleep..");
   }
   public static  void doSleep(Human h){
       h.sleep();

   }//此时传递的参数是父类对象，但是实际调用时传递子类对象，就是向上转型。
   public static void main(String[] args) {
       Human h = new Male();// 向上转型
       doSleep(new Male());//此处匿名子类对象，当然实际应用时应该是用上面的向上转型公式，然后将子类对象传递进来，这样以后好在向下转型，此处没有向下转型，所以直接用了匿名类对象。
       doSleep(new Female());

   }
}


class Male extends Human {
   @Override
   public void sleep() {
       System.out.println("Male sleep..");
   }
}

class Female extends Human {
   @Override
   public void sleep() {
       System.out.println("Female sleep..");
   }
}

instanceof 和类型转换

用来测试一个对象是否为一个类的实例，用法为：

boolean result = obj instanceof Class // obj必须是引用类型，不能是基本类型

当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。

注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能确定类型，则通过编译，具体看运行时定。

package com.wang.oop;
import com.wang.oop.demo06.Teacher;
import com.wang.oop.demo08.Person;
import com.wang.oop.demo08.Student;
public class Application {    
    public static void main(String[] args) {        
        //Object > String        
        //Object > Person > Teacher        
        //Object > Person > Student        
        Object object = new Student();        
        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 String); //编译报错            
    }
}

x instanceof y

编译能不能通过取决于x与y有没有父子关系；看x引用的左边

结果是true还是false看的是x的子类型是不是y的子类型；即看x引用的右边

访问修饰符

private修饰属性

使用private修饰属性
自身：是可以访问的
同包子类：不能继承
不同包子类：不能继承
同包类：不能访问
其他包类：不能访问

注： 红色字体，表示不可行

package/friendly/default

没有修饰符即代表package/friendly/default
float maxHP; 血量上限

protected 受保护的

受保护的修饰符
protected float hp; 血量

public 公共的

公共的修饰符
public String name; 姓名
任何地方，都可以访问

总结

那么什么情况该用什么修饰符呢？
从作用域来看，public能够使用所有的情况。 但是大家在工作的时候，又不会真正全部都使用public,那么到底什么情况该用什么修饰符呢？

1. 属性通常使用private封装起来
2. 方法一般使用public用于被调用
3. 会被子类继承的方法，通常使用protected
4. package用的不多，一般新手会用package,因为还不知道有修饰符这个东西

再就是作用范围最小原则
简单说，能用private就用private，不行就放大一级，用package,再不行就用protected，最后用public。 这样就能把数据尽量的封装起来，没有必要露出来的，就不用露出来了