Java面向对象编程（Object-Oriented Programming，OOP）

1、类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述，但是并不能代表某一个具体事物。

对象是抽象概念的具体实例。

2、创建与初始化对象

使用new关键字创建对象

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

test类

package demo1;

//一个项目应该只有一个main方法
public class test {
    public static void main(String[] args) {
        //类是抽象的，需要实例化
        Student student = new Student();
        System.out.println(student.name);

        student.name = "小明";
        student.age = 3;
        System.out.println(student.name);
        System.out.println(student.age);
    }
}

student类

package demo1;

//学生类
public class Student {
    //属性
    String name;
    int age;

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

构造器必须掌握
构造器：
1、和类名相同
2、没有返回值
作用：
1、new 本质在调用构造方法
2、初始化对象值
注意点：
1、定义有参构造后，如果想使用无参构造，显示定义一个无参构造

test类

package demo1;

//一个项目应该只有一个main方法
public class test {
    public static void main(String[] args) {
        //new 实例化一个对象
        Person person = new Person();

        System.out.println(person.name);
    }
}

Person类

package demo1;

//java ---> class
public class Person {
    String name;
    //即使一个类什么都不写，它也会存在一个方法
    //显示定义构造器
    //1、使用new关键字，必须要有构造器
    public Person(){
        //实例化初始值
        //用来初始化值
        this.name = "小王";
    }
    //有参构造 一旦定义了有参构造，无参构造就必须显示定义
    public Person(String name){
        //实例化初始值
        this.name = name;
    }

}

3、封装（数据的隐藏）

1、提高程序安全性，保护数据
2、隐藏代码实现细节
3、统一接口
4、可维护性增强

test类

package cn.oop.demo2;

public class test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("祈");
        System.out.println(s1.getName());

        s1.setId(01);
        System.out.println(s1.getId());
    }
}

Student类

package cn.oop.demo2;

public class Student {
    //属性私有
    private String name;//名字
    private int Id;//学号
    private char gender;//性别

    //提供一些可以操作这个属性的方法，右键 -> Generate -> getter and setter
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return Id;
    }

    public void setId(int id) {
        Id = id;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }
}

4、继承

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

#extends

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

#继承是类和类中的一种关系，除此之外还有依赖，组合，聚合等。

#继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends表示。

#object类
#super
#方法重写

test类

package cn.oop.demo3;

public class test {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.money);
    }
}

Person类

package cn.oop.demo3;

//父类
//在Java中，所有类都默认直接或者间接继承object
public class Person {
    public int money = 1000000000;
    public void say(){

        System.out.println("人类");
    }
}

Student类

package cn.oop.demo3;

//派生类
//拥有父类全部方法
public class Student extends Person { }

Teacher类

package cn.oop.demo3;

public class Teachaer extends Person{ }

输出：

人类
1000000000

super

注意点：
1、super调用父类的构造方法，必须放在构造方法的第一个。
2、super只能出现在子类的方法或者构造方法中！
3、super和this不能同时调用构造方法。
和this的区别是，代表的对象不同，
this：调用本身这个对象
super：代表父类对象的应用，只能在继承条件下才可以使用
this()；本类构造
super(); 父类构造

Person类

package cn.oop.demo3;

//父类
//在Java中，所有类都默认直接或者间接继承object
//私有成员无法被继承
public class Person {
    public Person(){
        System.out.println("Person 无参构造的调用");
    }
    protected String name = "祈";
    public void print(){
        System.out.println("Person");
    }
}

Student类

package cn.oop.demo3;

//派生类
//拥有父类全部方法
public class Student extends Person {
    public Student(){
        //隐藏代码，调用了父类的无参构造
        //super();//调用父类的构造器必须在子类构造器的第一行
        System.out.println("Student无参构造的调用");
    }

    private String name = "集";

    public void print(){
        System.out.println("Student");
    }

    public void test1(){
        print();
        this.print();
        super.print();
    }

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

test类

package cn.oop.demo3;

public class test {
    public static void main(String[] args) {
        Student student = new Student();
//        student.test("零");
//        student.test1();
    }
}

方法重写

需要有继承关系，子类重写父类的方法。
1、方法名必须相同
2、参数列表必须相同
3、修饰符：范围可扩大但不能缩小 public > protected > default > private
4、抛出异常：范围可以被缩小，但不能被扩大

5、多态

即同一个方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类有很多。
多态存在的条件：
1、有继承关系
2、子类重写父类方法
3、父类引用指向子类对象
注意：只有方法有多态，属性没有多态。
static方法属于类，它不属于实例
final：常量
private 私有的
以上三种类型都不能被重写

Person类

package cn.oop.demo3;

public class Person {
    public void run(){
        System.out.println("P-run");
    }
}

Student类

package cn.oop.demo3;

public class Student extends Person {
    @Override
    public void run() {
        System.out.println("S-run");
    }

    public void study(){
        System.out.println("learning...");
    }
}

test类

package cn.oop.demo3;

public class test {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //可以指向的引用类型就不确定
        //子类可以调用自己和父类继承过来的方法
        Student s1 = new Student();

        //父类的引用指向子类
        //可以指向子类，但不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        s2.run();//子类重写了父类的方法，执行子类的方法
        s1.run();

        //s2.study()直接调用会报错，因为父类没有study方法
        //对象能执行的方法主要看定义的数据类型
        ((Student) s2).study();//强制类型转换
    }
}

instanceof和类型转换

这块只要理清关系还是很好理解的

package cn.oop.demo3;

public class test {
    public static void main(String[] args) {
        //关系：
        //Object -> String
        //Object -> Person -> Teacher
        //Object -> Person -> Student
        Object o = new Student();
        System.out.println(o instanceof Student);//true
        System.out.println(o instanceof Object);//true
        System.out.println(o instanceof String);//false
        System.out.println(o instanceof Person);//true
        System.out.println(o instanceof Teachaer);//false
        System.out.println("-----------------------");
        Person p = new Student();
        System.out.println(p instanceof Student);//true
        System.out.println(p instanceof Object);//true
       // System.out.println(p instanceof String);//编译报错
        System.out.println(p instanceof Person);//true
        System.out.println(p instanceof Teachaer);//false
        System.out.println("-----------------------");
        Student s = new Student();
        System.out.println(s instanceof Student);//true
        System.out.println(s instanceof Object);//true
        //System.out.println(s instanceof String);
        System.out.println(s instanceof Person);//true
        //System.out.println(s instanceof Teachaer);
    }
}

static关键字。。。。。。

============================================

抽象类

abstract修饰符可以用来修饰方法也可以用来修饰类，如果修饰方法，那么该方法就是抽象方法；同理抽象类也是一样。

抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。

抽象类不能使用new关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法声明，没有方法实现，让子类实现。

子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

接口

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）
接口：只有规范

作用：
1、约束
2、定义一些方法，让不同的的类实现
3、public abstract
4、public static final
5、接口不能被实例化
6、implements可以实现多个接口
7、必须要重写接口中的方法

UserService接口

package demo04;

//关键是抽象思维
//接口都需要有实现类
public interface UserService {
    //接口中的所有东西都是抽象的
    //public abstract void run();
    //void run();//这样写就是默认和上面一样，即public abstract void run();

    //所有定义的方法其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

TimeService接口

package demo04;

public interface TimeService {
    void timer();
}

UserServiceImpl

package demo04;

//利用接口可以实现多继承
//实现了接口的类，就需要重写接口中的方法
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() {

    }
}

6、内部类

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

Outer类

package demo05;

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);
        }
    }

}

Application类

package demo05;

public class Application {

    public static void main(String[] args) {
        Outer outer = new Outer();

        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();//内部类访问外部类私有属性
    }
}

//一个Java类中可以有多个class类，但只能有一个public class