java基础

1.类与对象
*类是方法与属性的集合，是一种抽象的概念
*对象是对该类事物的具体体现形式，具体存在的个体
student stu1=new student(); student为类名 stu1为对象名=new student()为该类的构造方法

2.成员变量和局部变量
*成员变量：在类中方法外
*可以定义在任何位置，通常会定义在开头位置
*随着对象的创建而存在，随着对象的消息而消失
*有默认初始化值null
*局部变量：在方法定义中或者方法声明上
*随着方法的调用而存在，随着方法调用结束而结束
*没有默认初始化值，必须定义赋值，才能使用
*局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则
/*
class Student{
String name; 定义一个成员变量 [String]数据类型 name为变量名
void delimt(){ 编写一个方法
String name="小于" 定义一个局部变量 局部变量的优先级更高
this.name 如果要访问成员变量，[this].+变量名
}
}
*/

3.成员方法
*格式：
*[作用域] [final] 返回值类型 方法名(0-n个参数【形式参数】){
方法体
}
*void：表示没有返回值，不能返回任何值，但是可以return提前结束方法
*其他的数据类型：必须使用return返回1个值
成员方法不可以加：static关键字 若是加了static就叫做类方法
*重载方法：
*出现在同个类中
*与方法名一样
*参数不一样
*参数的数据类型不一样
*参数的个数不一样
*参数的数据类型的顺序不一样
/*
class Student{ 创建一个类
public final void delimt(){ 编写一个成员方法 [public]作用域 [final]唯一的 [void]数据类型 delimt方法名（）{}
}
public final void delimt(String name){ 重载方法 (String name)为添加参数
}
}
*/

4.封装
*为什么使用封装
*如果直接给成员变量赋值，可能会赋一些非法的数据 stu.age=1000 学生的年龄是1000岁不可能
*所以采用一个专门的方法来管理相关属性的赋值，并实行校验
*方法
*如果不禁止成员变量的直接调用，则无法保证使用方法对属性赋值
*应强制使用方法进行赋值并校验
*如果只提供了set（赋值）的方法，那么外部没办法获取对象中的属性
*如果只提供了get（取值）的方法，那么外部没办法对对象中的属性进行赋值
*封装概述：
*隐藏对象的属性和实现细节，仅对外提供公共的访问方法
*对属性进行分装：将属性私有化（private），根据需要提供公共的访问方法（get/set）方法
*对方法进行封装：将方法私有化（private），提供公共的访问方法
*将不需要对外提供的内容都隐藏起来
*把属性隐藏，提供公共的访问方法
*好处：
*隐藏实现细节，提供公共的访问方式
*提高了代码的复用性
*提高安全性

5.构造方法
*构造方法的方法名与类名一样（包括大小写）
*构造方法没有返回值类型
*一般用void表示无返回值
*构造方法是一个特殊的方法，用于实例化对象所需要调用的方法
*每个类至少有一个构造方法，如果没有明确写出构造方法，系统就会默认提供一个无参构造构造方法
*如果我们明确定义了构造方法，那么系统就不再提供默认构造方法
*构造方法可以重载s
*重载
*在同一个类中
*方法名一样
*参数的类型不一样
*参数的个数不一样
*参数的类型的顺序不一样
*需要成员变量赋初值，需要做一些初始化操作
*每一个类都有一个构造方法，说明每一个类都可以实例化
*如果要防止类被实例化：将构造方法进行封装（private）
*在单例模式中可以使用
*静态工厂方法中可以使用（static）

6.static关键字
*可以用于修饰
成员变量---->类变量（静态成员变量）
成员方法---->类方法（静态方法）
*内部类
*随着类的加载而加载
*类什么时候被加载
*当类第一次使用时就会加载这个类
*加载类实际上是由JAM调用类加载把.class文件加载在内存中
*存放在方法区中
*当类被加载时，类变量就会被加载
*方法区：存储程序执行过程中只有一个变量
*本地方法区：存储的不是Java代码，而是存放Java之外的东西，比如C语言的代码
*优先于对象存在，static修饰的东西与对象无关
*被类的所有对象共享，可以通过对象来调用static修饰的东西
*可以通过类名直接调用
*静态成员变量（类变量）
*被所有的对象所共享
*静态成员方法（类方法）
*被所有对象所共享，可以通过对象来调用
*类方法中不能使用this关键字，this关键字代码1个特定的对象
*类方法只能访问类变量或方法

7.this关键字
*this是一个关键字
*this表示当前对象，用于调用对象的成员变量与成员方法（比如set方法）
public void setName(String name){
this.name=name;
}
*哪个对象调用了成员方法，那么this就代表哪个对象
*this如何表示当前对象
*Java的对象在调用方法时，会给方法传入1个我们看不到的参数（默认）
*这个参数的位置在方法参加中的第一个，参数名可以理解为（this），this接收的实参为调用这个方法的对象
*Java中调用类方法时，不会传入默认的参数，所以不能使用this关键字

8.继承（extends）
*继承的优点
*多个类存在相同属性和行为，将这些相同的内容提取到独立的一个类中，实现多个类无需重复定义这些属性与方法，通过继承来实现
*Java中的类是单继承的，但接口可以多继承，类也可以实现多个接口
*java中的类是单继承的
*如果一个类继承了两个类，但是这两个类中有相同的方法，那么子类调用，无法确定应该调用哪个方法。
*接口可以多继承
*因为接口只有抽象方法，具体方法只能由实现接口的类实现，在调用的时候始终只会调用实现类（也就是子类覆盖的方法）的方法（不存在歧义），
因此即使继承的两个接口中的方法名是一样的，最终调用的时候也都是调用实现类中的那个方法，不会产生歧义。
*类也可以实现多个接口
*一个子类可以同时实现多个接口，那么实际上就摆脱了Java中的类单继承局限。
*object类是java中所有类的直接或间接父类
*一个类如果没用明确的继承一个外类，那么这个类默认继承object类。

9.作用域修饰符
*主要用于控制属性与方法的访问权限
*体现在：同一个类中，同一个包中，不同包，继承关系
*public（公有） protected（保护） private（私有） default （默认）
*权限表
同一个类 同一个类 继承 不同包
public | ✔ | ✔ | ✔ | ✔ |
protected | ✔ | ✔ | ✔ | |
default | ✔ | ✔ | | |
private | ✔ | | | |

10.重写
*子类中出更与父类一样的方法，称为方法重写（方法覆盖，方法复写）
*只有方法重写，没有属性重写
*方法重写特点
*在子类中，方法名一样
*参数一样
*参数类型一样
*参数个数一样
*参数类型的顺序一样
*返回值类型一样
*重写时，子类的作用域不能小于父类的作用域
* @override:用于标记方法为重写方法，如果不是重写方法会报编译异常
class people //父类people class student extends people //子类student继承父类people
{ { @override
String name; public void study() //重写study方法
int age; {
public void study() //方法study System.out.println("我是学生");
{ } }
System.out.println("我是人类");
} }

*方法重载
*参数类型不一样
*参数个数不一样
*参数类型的顺序不一样
*与返回值类型无关
class teacher extends people //子类student继承父类people
{
public void study(int age) //重写study方法
{
System.out.println("我是老师，今年"+age+"岁");
} }

11.final关键字
*final：终态，不能改变（独一无二的）
*修饰局部变量：局部变量
*修饰成员变量：：成员常量
*修饰方法：终态方法，方法的最终形态，不能被重写
*修饰类：终态类，类的最终形态，不能被继承
*编写String类的子类，然后增加***功能
*static final 属性/方法：常量/类终态方法

12.继承的优缺点
*继承时：把公共的属性与行为提取到父类中，子类不用重复的编写这些属性与方法
*优点
*提高代码的反复性，一段代码，多次使用2021/6/30
*提高代码的可维护性
*使用多态的前提
*缺点
*类与类之间产生关系，提高代码的耦合性
*在项目开发中：高内聚，低耦合
*内聚：在一个类中能够独立完成一些功能
*耦合：需要其它的类配合才能完成一些功能
13.多态
（1）多态概述
*字面理解：多种状态
*某一个对象在不同条件下表现出不同的状态
*使用多态的条件
*继承关系/接口关系
*子类重写父类方法
*父类引用子类的对象
*当使用父类的引用来调用重写的方法时，调用到子类的方法
*重写
*子类中出现与父类一样的方法定义
*方法名一样
*方法的参数一样
*返回值类型一样
*子类中定义的方法作用域应不小于父类中定义的方法的作用域

（2）方法调用
*子类引用子类对象 // student stu=new student();
父类有，子类也有：执行子类方法
父类有，子类没有：执行父类方法
父类没有，子类有：执行子类方法
*父类引用子类对象 // person per=new student();
父类有，子类也有：执行子类方法
父类有，子类没有：执行父类方法
父类没有，子类有：报编译异常
*父类描述的范围比子类的大，范围大的可以引用范围小的
*范围小的描述范围大的，强制类型转换 //person per=new student();
//student stu=(student) per;
（3）属性调用
*子类引用子类的对象
父类有，子类也有：调用子类属性
父类有，子类没有：调用父类属性
父类没有，子类有：调用子类属性
*父类引用子类的对象
父类有，子类也有：调用父类属性
父类有，子类没有：调用父类属性
父类没有，子类有：报编译异常

（4）父类域子类的类型转换
*父类可以直接引用子类的对象
*子类如果要引用父类的对象，必须进行强制类型转换
*被转换的对象属于子类的对象
*强制类型转换时，要注意类型的匹配
*对象 instanceof 类：判断对象不是类的一个对象
*per instanceof Student
*在参数传值的时候，会使用数据类型最匹配的方法
*匹配的时引用的类型，而不是对象的实际类型

（5）多态的优缺点
*优点
*提高代码的可维护性
*提高代码的可扩展性
*缺点
*只能调用父类中有定义的方法，不能调用子类特有的方法
*如果要调用子类特有的方法，必需通过强制类型转换来实现
*使用instanceof关键字来判断类型

14.面向对象小结
*对象用于描述现实世界中的事物
*把一系列相似的对象进行抽取-->得到类
*使用类的时候，需要先对类进行实例化，实例化的结果是一个对象
*对象具有属性与方法-->对相应的成员变量与成员方法
*封装：类的一些成员变量与成员方法不希望对外提供方法，只在类的内部使用
*子类只需要继承父类，就能得到父类中定义的属性与方法（extends关键字）
*多态，用父类引用子类对象，通过父类的引用可以调用到子类的方法
*前提：子类重写父类的方法

15.抽象类
（1）抽象简介
*在使用面向对象思想对问题进行分析处理过程中，如果得到一系列看上去不一样，但本质上相同的具体概念，通常会采用抽象类来处理
*抽象是一种功能不完全的类，不能被实例化
*在定义类是，通过abstract关键字来修饰，被修饰的类就是抽象类
*抽象类的大部分用法跟非抽象类是一样的
*抽象类一样有属性、方法、构造方法
（2）属性
*属性：使用方式与非抽象类一样
（3）构造方法
*构造方法：实例化对象时调用
*抽象类不能实例化
*抽象类中的构造方法只能被子类调用 //super(***);
（4）方法
*抽象类中包含两种方法
*抽象方法：没有方法体的方法，在定义方法的时候，使用abstract关键字进行修饰
* public abstract void eat();
*抽象方法只能出现在抽象类中，非抽象类中不能定义抽象方法
*子类（非抽象类）必需重写父类中定义的抽象方法
*子类（抽象类），可以继承父类中定义的抽象方法，可以不用重写，可以重写
*非抽象方法
*使用方式与普通的类中的方法一样
*子类可以重写，也可以不重写
（5）非法关键字组合
*abstract：
*修饰类：只能做为父类
*修饰方法：必须被重写
*final：
*修饰类：最终类，不能别继承，不能作为父类
*修饰方法：最终方法，不能被重写
*private
*只能在类内部使用
*static
*修饰方法：类方法，随着类的加载而加载

16.接口
（1）接口概述
*接口本身不具备任何功能，只是定义了相关的一些规范，接口中所有的功能都由实现类来提供
*定义类时，使用class关键字：定义接口使用interface关键字
*接口本身不具备任何功能，所以不能被实例化，也没有构造方法
*多借口，一个类可以多个接口
*public class student implements A,B,C;
*接口之间时可以继承，多继承
*public interface C extends A,B；

（2）属性
*类/抽象类
*成员变量
*成员常量：如果没有特殊需求，通常使用类常量
*类变量（静态常量） //常量：在程序中固定不变的值，是不能改变的数据
*类常量（静态变量）
*接口：只能定义类常量
*如果没有使用public、static、final修饰，默认会帮助我们添加
*只能使用public做为作用域
*接口是定义常量最好的地方
（3）方法
*非抽象类中，只能定义非抽象方法
*抽象类中，可以定义抽象方法，可以定义非抽象方法
*接口中，只能定义抽象方法
*自动加上：abstract关键字
*只能使用public，如果不写，会自动加上
*实现类（非抽象类），必须实现接口中定义的所有方法（重写）
*public class student implements person{ }
*person是接口
*student是person接口的实现类
*实现类（抽象类），可以实现接口中的方法，也可以不实现接口中的方法
*抽象类本身就可以有抽象方法
（4）多态
*接口可以更好的实现多态
*接口理解成为父类
*实现类理解成为子类
*用父类引用子类的对象，父类的引用可以调用子类中重写父类的方法
*用接口引用实现类的对象，接口的引用可以调用导实现类中的实现的接口中的方法
（5）默认方法
*JDK8.0新特性，允许接口中定义默认方法
*原来：接口中只能定义抽象方法，不能写方法体
*现在：接口中可以在默认方法中写方法体
*默认方法：用default来修饰方法
*public default void say() { **** }
(6)接口的优点
*一个类可以有多个接口
*继承：只能有一个父类
*更容易搭建程序框架
*设计与具体的实现完全分离
*更容易更换实现类
*更自然的使用多态