第一部分 基础
一、注释
作用：对程序进行解释说明的文字，不影响程序的执行（编译后的class文件中没有注释了）
分类：
单行注释：//————
多行注释：/* */
文档注释：/** */
(注意：文档注释的内容将来可以提取到程序说明书当中去）
//我爱Java
/*我真的很爱Java
真的 真的*//**
这辈子都没这么爱过Java
*/
二、字面量（了解）
字面值：告诉程序员数据在程序中该怎么写
字面量分类：
1、整数、小数：生活中写法和程序中写法一样
2、字符：程序中必须使用单引号围起来，里面只能一个字符
3、字符串：程序中必须用双引号围起来，里面的内容可以随意
4、布尔值：false ，true
5、空值：null
三、变量
作用：内存中的一块区域，里面可以存储一个数据，存储的数据可以变化
格式： 数据类型 变量名称 = 初始值；
byte = 0；
short = 0;
int = 0;
long = 0;
float = 0.0;
double = 0.0;
char = 'a';
boolean = true;//boolean = false;
=赋值：从右边往左执行
变量使用的注意事项：
1、变量必须先声明才能使用
2、什么类型的变量只能存储什么类型的数据
3、变量从定义开始到 }有效，同一个范围类不能定义重名的变量
4、变量定义时可以没有初始值，但是使用必须有初始值
变量在计算机中的底层原理：
变量存储的是数据的二进制形式，除二取余
‘字符’-->ASCLL编码-->二进制
四、数据类型：
作用：约束变量只能存储什么类型的数据，帮助定义出不同类型的变量
数据类型分类：
（一）基本数据类型：
1、整型：
| 分类 | 所占空间 |
| 字节整型byte | 1个字节（-128--127） |
| 短整型short | 2个字节 |
| 整型int(默认） | 4个字节 |
| 长整型long | 8个字节 |
2、浮点型（小数）：
| 分类 | 所占空间 |
| float单精度 | 4个字节 |
| double双精度 | 8个字节 |
3、字符型：
| 字符型char | 2个字节 |
4、布尔型：
| true | 真 |
| false | 假 |
（二）引用数据类型：String（后面详细讲）
（三）注意事项：随便写整数字面量，默认是int类型，相当成long类型后面加L/l,相当成float类型后面加F/f
五、关键字、标志符
关键字：
Java自己使用的，不能拿来取名字
标识符：
我们自己取的名字
规则：不能数字开头，不能用关键字，区分大小写
六、类型转换
原因：开发中会存在不同类型的变量或者数据赋值给其他类型的变量，也存在不同类型的数据一起运算，其结果类型要确定下来
（一）自动类型转换
原理：小范围的变量可以直接赋值给大范围的变量
byte-->short-->int-->long-->float-->double
char-->int
注：float科学计数法，因而存储的数据范围较大
形式：
byte a = 20;
int b = a;
（二）表达式的自动类型转换
含义：在表达式中，小范围类型的变量会自动提升成大范围运算
结论：表达式的结果的最终数据类型是由表达式的最高数据类型决定的，最高数据类型是什么，其结果数据类型就是什么
注意：byte,short,char 在表达式中，在表达式中是直接提升成int运算的
byte b1 = 21;byte b2 = 22;
byte b3 = b1 + b2;//错误
int b3 = b1 + b2;//实际开发中用
byte b3 = (byte)(b1 + b2);
（三）强制类型转换
含义：大范围类型的变量或者数据不能直接复制给小范围类型的变量，否则报错，必须进行强制类型转换才可以
格式：数据类型 = （数据类型）其他类型的变量/数据
注意：强制类型转换可能出现数据据丢失，浮点类型的变量或者数据强者转换成整型，保留整数部分返回，小数部分直接不要
七、运算符
| 算数基本运算符：+ - * / % | 两个整数相除的结果一定是整数 | 3*1.0/2 //1.5 3/2*1.0 //1.0 |
| +做连接符 | 能算就算，不能算就在一起 | 'a' + "等级" = "a等级" |
| 自增自减运算符++ -- | ++ --只能操作变量，不能操作字面量；前置先自增自减1再运算，后置先运算再自增自减1 | a++；//√ 2++；//× |
| 赋值运算符=，+=，-=,*=,/=,%= | 隐含数据类型的转换 | byte b1 = 2; byte b2 = 3; byte b3 = (byte)(b1+b2)==>b1 += b2; |
| 关系运算符==,！=,>=,<= | 判断是否满足条件 | boolean rs = age>18; |
| 逻辑运算符&,&&,|,||,!,^ | &/&&:与，必须前后都是true 区别：&&如果发现前面的是false,后面不执行，性能更好，用的更多 |/||:或，前后只要有一个是true结果就一定是true 区别：||如果发现前面是true后面不执行，直接返回结果，性能更好，用的更多 | !取反：!false = true; !true = false; ^异或操作：前后一样返回false，不一样返回true |
| 三运算符 | 做分支选择的，关键是格式 | 条件表达式? 值1：值2 |
| 运算符优先级 | 运算符存在谁先后执行的情况 | （）优先级最高 */高于加减 &&高于|| |
八、键盘录入技术
Java自己提供好的程序给程序员调用的
API文档：应用程序编程接口，技术说明书，告诉我们该怎么使用Java的程序
1、导包（自动导包）：import java.utill.Scanner;
2、创建一个扫描器对象：Scanner sc = new Scanner(System.in);
3、等待用户的数据：int age = sc.nextInt();
String name = sc.next();
例：
//1、导包（并不需要自己写，以后通过工具导入更方便）
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
//键盘录入技术
//2、得到一个键扫描器对象
Scanner sc = new Scanner(System.in);
//3、调用sc对象的功能，等待接收用户的数据
System.out.println("请您输入您的年龄：");
int age = sc.nextInt();
//等待用户输入数据并按了回车键
System.out.println("您的年龄是：" + age);
System.out.println("请您输入您的姓名：");
String name = sc.next();
//等待用户输入数据并按了回车键
System.out.println("欢迎" + name);
}
}
请您输入您的年龄：
45
您的年龄是：45
请您输入您的姓名：
零零零零
欢迎零零零零
进程已结束,退出代码0九、程序流程控制
（一）顺序结构
（二）分支结构、
1、if
作用：可以判定条件来决定执行哪个分支
格式1：
if(条件表达式）{
语句体；
}
格式2：
if(条件表达式）{
语句体1；
}else{
语句体2；
}
格式3：
if(条件表达式1）{
语句体1；
}else if(条件表达式2){
语句体2；
}else if(条件表达式3){
语句体3；
}
.....
else{
语句体；
}
2、switch
作用：根据表达式的值来进行值匹配选择对应的分支进行
switch(表达式){
case 值1：
执行代码1；
break;
case 值2：
执行代码2；
break;
case 值3：
执行代码3；
break;
default:
执行代码3；
}
3、区别
if可判断区间功能更强大；switch可进行值匹配操作，结构清晰，性能较好
4、switch的注意事项
表达式类型：只能是byte,short,short,int,char,JDK5开始支持枚举，JDK7开始支持String,不支持double,float,long
case给出的值：不允许重复，只能是字面量，不能是变量
break：不加break会出现穿透现象
5、穿透现象
利用穿透现象：
import java.util.Scanner;
public class SwitchDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入月份：");
int yue = sc.nextInt();
switch (yue) {
case 1:
case 2:
case 3:
System.out.println("现在是春季");
break;
case 4:
case 5:
case 6:
System.out.println("现在是夏季");
break;
case 7:
case 8:
case 9:
System.out.println("现在是秋季");
break;
case 10:
case 11:
case 12:
System.out.println("现在是冬季");
break;
default:
System.out.println("输入不合法");
}
}
}
（三）循环结构
作用：控制一段代码执行多次
1、for循环
格式：
for(初始化语句; 循环条件;迭代语句）{
循环体语句；
}
例：输出三次 Hello World
for(int i = 0; i < 3; i ++）{
System.out.print("Hello World");
}2、while循环
格式：
初始化语句；
while(循环条件){
循环体语句；
迭代语句；
}
例：输出三次 Hello World
int i = 0;
while(i < 3）{
System.out.print("Hello World");
i++;
}3、do while循环
特点：一定会执行一次循环体语句
格式：
初始化语句；
do{
循环体语句；
迭代语句；
}while(循环条件);
例：输出三次 Hello World
int i = 0;
do{
System.out.print("Hello World");
i++;
}while(i<3)（四）跳转关键字
| break | 跳出并结束当前所在循环的执行，或结束所在switch分支的执行 |
| contcontinue | 用于跳出当前循环的当次执行，进入下一次循环 |
（五）案例技术
随机数Random类：
作用：产生一个随机数
步骤：
1、导包（自动做的）：import java.util.Random;
2、创建随机数对象：Random r = new Random();
3、开始得到随机数：int date = r.nextInt(10);//0-9
例：生成20个0-9的随机数
生成一个1-10的随机数
生成一个3-17的随机数
public class RandomDemol {
public static void main(String[] args) {
//目标：学会使用java提供的随机数类
//1、导包
//2、创建随机数对象
Random r = new Random();
//3、调用nextInt功能（方法）可以返回一个整型的随机数给你
for(int i = 0; i < 20; i++){
int date = r.nextInt(10) + 1;//0-9 不包含10的随机数（包前不包后）
System.out.println(date);
}
System.out.println("-------------------------------");
// 1-10 ==> -1 ==> (0 - 9) + 1
int date = r.nextInt(10) + 1;
System.out.println(date);
// 3 - 17 ==> (0 - 14) + 3
int date1 = r.nextInt(15) + 3;
System.out.println(date1);
}
}
例：
import java.util.Random;
import java.util.Scanner;
public class RedomTesr2{
public static void main(String[] args) {
//1、随机一个幸运号码 1 - 100之间
Random r = new Random();
int luckNumber = r.nextInt(100)+1;
//2、使用一个死循环让用户不断猜测，并给出提示
Scanner sc = new Scanner(System.in);
while(true){
// 让用户输入猜测
System.out.println("请您输入猜测的数据（1-100）：");
int guessNumber = sc.nextInt();
//3、判断这个猜测的号码与幸运号码的大小情况
if(guessNumber > luckNumber){
System.out.println("您猜测的数据过大");
}else if(guessNumber < luckNumber){
System.out.println("您猜测的数据过小");
}else {
System.out.println("恭喜你猜中了，可以去买单了~~~");
break;//直接跳出并结束当前循环
}
}
}
}
十、数组
（一）作用：
就是一个容器用于在程序中存储一批同种类型的数据
（二）定义：
静态初始化：
1、定义格式：
格式1：
数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，元素3，——}；
格式2：
数据类型[] 数组名称 = {元素1，元素2，元素3，——}；
2、特点：在定义数组的时候同时为数组确定了数据
动态初始化：
1、1、定义格式：
格式3：
数据类型[] 数组名称 = new 数据类型[长度]；
2、特点：一开始只确定数组的类型和长度，不确定具体存入的数据值
（三）数组的访问：
格式：数组名称[索引]；
取值：int date = arr[1];
赋值：arr[1] = 222;
长度：arr.length
（四）数组的遍历：
数组的遍历即一个一个的访问数据
int[] ages = {20,30,40,50};
for(int i = 0; i < ages.length; i++){
System.out.println(ages[i]);
}20
30
40
50
（五）数组使用常见问题：
1、不要访问超过数最大索引
2、空指针异常问题：
int[]arr = null;
Sytem.out.println(arr);// null
Sytem.out.println(arr.length);// 空指针异常（六）案例：
案例：求最值
public class Test1 {
public static void main(String[] args) {
//1、定义一个静态初始化的数组
int[] numbers = new int[]{23,65,12,54,76,23,12};
//2、定义一个变量存储最大值元素，建议使用第一个元素作为参考
int max = numbers[0];
//3、遍历数组元素，依次与max比较，若较大，则替换
for (int i = 1; i < numbers.length; i++) {
if(numbers[i] > max){
max = numbers[i];
}
}
//4、输出max
System.out.println("数组的最大值：" + max);
}
}十一、方法
作用：
封装一段代码的语法结构，可以被重复使用，以提高代码的复用性，提高开发效率，让程序逻辑更清晰
定义格式：
修饰符 返回值类型 方法名（形参列表）{
方法体代码；
return 返回值；
}
注意：
1、如果方法没有结果数据需要返回，返回值类型声明为void
2、方法与方法是平级关系，不能嵌套定义
方法的调用：
有返回值方法的调用：
1、赋值调用：定义变量接受方法的结果
2、输出调用：放在输出语句中调用
3、直接调用，不要返回值了
无返回值方法的调用：直接调用
方法的参数传递机制：
值传递：传输实参给方法的形参传输的不是实参本身，而是实参中存储的数据的一个副本
注：引用类型的参数传输的是存储的地址
方法重载：
同一个类中，方法名称相同，形参列表必须不同（形参的个数、类型、顺序），才是方法重载
优点：形参列表不同，提现功能的差异化，提高开发效率
return：跳出并立即结束当前方法的执行
public class Method {
public static void main(String[] args) {
test();
test("英语");
test("马克思",5);
}
public static void test(){
System.out.println("默认高数挂科1次");
}
public static void test(String subject){
System.out.println("默认" + subject + "挂科1次");
}
public static void test(String subject,int numbers){
System.out.println("默认" + subject + "挂科" + numbers + "次");
}
}默认高数挂科1次
默认英语挂科1次
默认马克思挂科5次十二、类和对象
（一）对象的设计和使用：
类：是抽象的概念集合，表示的是一个共性的产物，可理解为自定义数据类型，类之中定义的是属性（成员变量）和行为（方法）
对象：对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象
类的定义：
public class 类名称 {
属性 (变量) ;
行为 (方法) ;
}
例：
public class Person {
String name ;
int age ;
public void Print() {
System.out.println("姓名：" + name + "，年龄：" + age) ;
}
}
生成对象：
类名称 对象名称 = new 类名称 () ;
Person p1 = new Person();对象的使用：
访问属性：对象名.成员变量;
访问行为：对像名.方法名();
p1.name = "张三";
p1.age = 18;
p1.Print();注意事项：
一个学生类：
public class Student {
/*1、类名首字母建议大写，不能用关键字，必须是合法标识符，且有意义*/
String name;
char sex;
String hobby;
public void study(){
System.out.println("名称：" + name + ",性别：" + sex + "，爱好：" + hobby + "开始学习了");
}
}public static void main(String[] args) {
/* 2、一个Java文件中可以定义多个class类，但只能一个类是public修饰
而且public修饰的类名必须成为代码文件名
注意：实际开发还是建议一个代码文件只定义一个类
*/
/* 3、成员变量的完整定义模式是：修饰符 数据类型 变量名称 = 初始化值；
一般无需指定初始化值，存在默认值。
默认值的规则：
byte short int long 0
double float 0.0
boolean false
String等引用类型 null
*/
Student s = new Student();
System.out.println(s.name);
System.out.println(s.flag);
}（二）内存机制：
（三）构造器:
学习构造器的目的：
1、真正知道对象是通过调用什么代码得到的
2、能够掌握为对象赋值的其他简便写法
3、为以后学习面向对象编程的其他内容做支撑
作用：定义在类中，可以用于初始化一个类的对象，并返回对象的地址
格式：
修饰符 类名（形参列表）{
——
}
分类：
1、无参数构造器（默认存在的）：初始化对象时，成员变量的数据采用默认值
2、有参构造器：在初始化对象像时，同时可以接收参数为对象赋值
public class Car{
String name;
double price;
//无参构造器
public Car(){
——
}
public Car(String n,double p){
——
}
(四）this关键字：
1、可以出现在构造器、方法中
2、代表当前对像地址
package com.itheima.creatobject.thisdemo;
public class Car {
public Car(){
System.out.println("无参构造器中的this:" + this);
}
public void run(){
System.out.println("方法中的this:" + this);
}
}package com.itheima.creatobject.thisdemo;
public class Test {
public static void main(String[] args) {
//创建对象
Car c = new Car();
c.run();
System.out.println(c);
}
}无参构造器中的this:com.itheima.creatobject.thisdemo.Car@1b6d3586
方法中的this:com.itheima.creatobject.thisdemo.Car@1b6d3586
com.itheima.creatobject.thisdemo.Car@1b6d3586
作用：可以用于指定访问当前对象的成员变量，成员方法
this出现在有参构造器中的用法：
public class Car{
String name;
double price;
public Car(String name,double price){
this.name = name;
this.price = price;
}
}this出现在成员方法中的用法：
public class Car{
String name;
double price;
public void Car(String name){
System.out.println(this.name + "正在和" + name + "一起比赛！！");
}
}(五）static关键字：
static修饰的方法称作静态方法，静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，static修饰的成员变量和方法，从属于类，普通变量和方法从属于对象，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都必须依赖具体的对象才能够被调用。被static修饰的变量成为静态变量(类变量)或者实例变量
类变量：类变量随着类的加载而存在于date内存区
实例变量：实例变量随着对象的建立而存在于堆内存
特点：
1、随着类的加载而被加载
2、被所有对象共享
3、存放位置（后补充）
4、生命周期：类变量随着类的消失而消失；实例变量它是随着对象的消失而消失
使用：
1、static修饰成员变量
当属于同一个类的所有对象出现共享数据时,就需要将存储这个共享数据的成员用static修饰
2、static修饰成员方法
当功能内部没有访问到非静态的成员时(对象特有的数据)那么该功能可以定义成静态的
static代码块：
static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。
作用：优化程序性能，这是因为它的特性-->只会在类加载的时候执行一次
使用：将一些只需要进行一次的初始化操作都放在static代码块中进行
(六）JavaBean：
可称为实体类，其对象可以用于在程序中封装数据
标准JavaBean书写要求:
1、成员变量使用private修饰
2、提供成员变量对应的set(),get()方法
3、必须提供一个无参构造器，有参构造器是可写可不写的
（七）成员变量和局部变量的区别：
| 区别 | 成员变量 | 局部变量 |
| 类中位置不同 | 类中，方法外 | 常见于方法中 |
| 初始化值不同 | 有默认值，无需初始化 | 没有默认值，只用前需要完成赋值 |
| 内存位置不同 | 堆内存 | 栈内存 |
| 生命周期不同 | 随对象的创建而存在，随对象的消失而消失 | 随方法的调用而存在，随方法的运行结束而消失 |
| 作用域 | 不好界定 | 再所归属的大括号中 |
（八）综合案例：
十三、面向对象
（一）继承
概述：Java允许一个类通过extend与另一个类建立父子关系，这就是继承
格式：
子类 extends 父类
特点：子类继承父类后就可以得到父类的属性和行为
核心优点：提高代码的复用性，多个子类的相同代码可以放到父类中，增强了类的扩展性
（二）封装
封装思想：告诉我们，如何正确设计对象的属性和方法
有什么事，找对象，调方法就行，编程变得简单
降低学习成本，可以少记少学
封装的原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为
例：人画圆，给园对象提供画圆方法，有人来调用画圆方法
人关门，给门提供关门方法，人来调用关门方法
如何进行封装更好：
1、对成员变量使用private（私有、隐藏）关键字进行修饰（pivate修饰的成员只能在当前类中访问）
2、为每个成员变量提供配套的public修饰的getter、setter方法暴露其取值和赋值
public class Student {
//1、成员变量，使用private修饰
private int age;
//2、提供成套的getter,setter方法暴露其取值和赋值
public void setAge(int age){
if(age >= 0 && age <= 200){
this.age = age;
}else{
System.out.println("您的年龄是具有问题！！");
}
}
public int getAge(){
return age;
}
}public class Test {
public static void main(String[] args) {
Student s = new Student();
s.setAge(23);
System.out.println(s.getAge());
}
}23
（三）多态
多态体现为父类引用变量可以指向子类对象
前提条件：必须有子父类关系
格式:
父类类型 变量名=new 子类类型();
理解:
1、多态是同一个行为具有多个不同表现形式或形态的能力
2、多态就是同一个接口，使用不同的实例而执行不同操作
1128
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
