面向对象编程（Object-Oriented Programming,OPP）本质：以类的方式组织代码，以对象的组织（封装）数据。抽象：编程思想三大特性：
封装继承多态 认识论的角度：先有对象后有类代码的角度：先有类后有对象 类与对象的创建 类与对象的关系
类是一种抽象的数据类型，它是对某一事物整体描述和定义，但并不能代表某个具体事务对象是抽象概念的具体实例 创建与初始化
使用new关键字创建对象
//学生类
public class Student {
//熟悉；字段
String name; //null
int age; //0
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认初始化以及对类中构造器的调用类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。构造器有以下两个特点：
必须和类名相同必须没有返回类型，也不能写void
//java --> class
public class Person {
//即使什么也不写也存在一个方法
//显示的定义构造器
String name;
//实例化初始值
//使用new关键字，本质上是调用构造器
//初始化值
public Person(){
}
//有参构造：一旦定义了有参构造，无参构造必须显示定义
public Person(String name){
this.name = name;
}
//快捷键：alt+insert
}
封装
该露的露，该藏的藏
“高类聚，低偶合”，高类聚：类的内部数据操作细节由自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用 封装（数据的隐藏）
通常，禁止直接访问一个对象中的数据的实际表示，而应该通过接口来访问，称之为隐藏信息 属性私有，get/set
//类
public class Student {
private String name; //名字
private int id; //学号
private char sex; //性别
private int age; //年龄
//提供一些可以操作这个属性的方法
//提供一些public的get、set方法
//get获得这个数据
public String getName(){
return this.name;
}
//set给这个数据赋值
public void setName(String name){
this.name = name;
}
//快捷键：alt+ins
public int getId() {
return id;
}
public char getSex() {
return sex;
}
public void setId(int id) {
this.id = id;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>120||age<0){
this.age = 3;
}else{
this.age = age;
}
}
}
继承
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extends的意思是”扩展“。子类是父类的扩展
Java中类只有单继承，没有多继承
继承是类与类之间的一种关系。除此之外还有依赖、组合、聚合等
继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends表示
子类和父类之间。从意义上具有”is a“的关系
在Java中，所有的类，都默认直接或间接继承Object类
super
注意点：
super调用父类的构造方法，必须在构造方法中的第一个super必须只能出现在子类的方法或构造方法中super和this不能同时调用构造方法
vs this:
代表的对象不同：
this：本身调用者这个对象super：代表父类对象的引用
前提：
this：没有继承也可以使用super：只能在继承条件才可以使用
构造方法：
this()：本类的构造super()：父类的构造
//在Java中，所有的类，都默认直接或间接继承Object类
public class Person {
public Person(){
System.out.println("Person无参执行了");
}
protected String name = "Yuki";
//私有的东西无法被继承
public void print(){
System.out.println("person");
}
}
//学生 is 人
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
public Student(){
//隐藏代码：默认调用了父类的无参构造
super(); //调用父类构造器，必须在子类构造器的第一行
System.out.println("Student无参执行了");
}
private String name = "yuki";
public void print(){
System.out.println("student");
}
public void test1(){
print(); //student
this.print(); //student
super.print(); //person
}
public void test(String name) {
System.out.println(name); //yooo
System.out.println(this.name); //yuki
System.out.println(super.name); //Yuki
}
}
**方法重写：**需要有继承关系，子类重写父类的方法！
- 方法名必须相同参数列表必须相同修饰符：范围可以扩大； public>Protected>Default>private抛出的异常：范围可以被缩小，但不能扩大； ClassNotFoundException–>Exception(大)
重写，子类的方法必须和父类一致，方法体不同
为什么需要重写？
父类的功能，子类不一定需要，或不一定满足！
快捷键：Alt + Ins: override（idea）
//重写都是方法的重写，和属性无关
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()");
}
}
多态
注意事项：
- 多态是方法的多态，属性没有多态父类和子类，有联系，类型转换异常！ClassCastException!存在条件，继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son()
以下无法重写：
static 静态方法，属于类，不属于实例final 常量private方法
public class Person {
public void run(){
System.out.println("run");
}
public void say(){
System.out.println("say");
}
}
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
instanceof
public class Application {
public static void main(String[] args) {
//Object > String
//Object > Person > Student
//Object > Person > Teacher
Object object = new Student();
//System.out.println(X instanceof Y); //能不能编译通过！
System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Object); //true
System.out.println(object instanceof Teacher); //False
System.out.println(object instanceof String); //False
System.out.println("==============");
Person person = new Student();
System.out.println(person instanceof Student); //true
System.out.println(person instanceof Person); //true
System.out.println(person instanceof Object); //true
System.out.println(person instanceof Teacher); //False
//System.out.println(person instanceof String); //编译报错!
System.out.println("==============");
Student student = new Student();
System.out.println(student instanceof Student); //true
System.out.println(student instanceof Person); //true
System.out.println(student instanceof Object); //true
//System.out.println(student instanceof Teacher); //编译报错
}
}
- 父类引用指向子类的对象把子类转换为父类，向上转型把父类转换为子类，向下转换，强制转换方便方法的调用，减少重复的代码；代码变得简洁
public class Application {
public static void main(String[] args) {
//类型之间的转换；父（高） 子（低）
//高
Person obj = new Student();
//student转换为student类型，就可以使用Student类型的方法了
Student student = (Student) obj;
student.run();
((Student)obj).run();
//子类转换为父类，可能丢失本来的一些方法
}
}
被final修饰的类，就不能被继承了
静态代码块public class Person {
//2：赋初值
{
//代码块（匿名代码块）
System.out.println("匿名代码块");
}
//1：只执行一次
static{
//静态代码块
System.out.println("静态代码块");
}
//3
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 = new Person(); //静态代码块 匿名代码块 构造方法
System.out.println("======");
Person person2 = new Person(); //匿名代码块 构造方法
}
}
静态导入包：
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
抽象类
- 不能new这个抽象类，只能靠子类去实现它；约束！抽象类中可以写普通方法抽象方法必须在抽象类中
存在意义：提高开发效率
//abstract 抽象类；类 extend：单继承 （但接口可以多继承）
public abstract class Action {
//约束
//abstract，抽象方法，只有方法名字，没有方法实现
public abstract void doSomething();
}
//抽象类的所有方法，继承了它的子类，必须要实现它的方法 除非该类也为抽象类，由子子类实现方法
public class A extends Action{
@Override
public void doSomething() {
}
}
抽象类存在构造器！
接口普通类：只有具体实现抽象类：具体实现和规范（抽象方法）都有！接口：只有规范！约束和实现分离：面向接口编程接口的本质是契约
//抽象的思维，Java 架构师
//interface 定义关键字，接口都需要有实现类
public interface UserService {
//常量
public static final int AGE = 99;
//接口中的所有定义都是抽象的 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
public interface TimeService {
void timer();
}
//抽象类：extend
//类可以实现接口 implments 接口
//实现了接口的类，就需要重写接口中的方法
//多继承 利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
作用：
- 约束定义一些方法，让不同的人实现接口中所有的方法都是public abstract 的所有的常量都是 public static final接口不能被实例化，接口中没有构造方法implements可以实现多个接口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.in(); //这是内部类方法
inner.getID(); //10
}
}
局部内部类：
- 用在方法内部，作用范围仅限于该方法中不能使用private，protected，public修饰符
public class Outer {
public void method(){
//局部内部类 用在方法内部，作用范围仅限于该方法中
class Inner{
}
}
}
//一个Java类可以有多个class类，但是只有一个public class类
class A{
}
匿名内部类：
public class Test {
public static void main(String[] args) {
//没有名字初始化类，不用把实例保存在变量中
new Apple().eat(); //1
UserService userService = new UserService() {
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
