Java面向对象

Java面向对象

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

抽象：封装、继承、多态、 抽象类、接口

构造方法：

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

package oop.constructorMethod;

public class Person {
    //一个类即使什么都不写它也会存在一个方法
    //显示的定义构造器
    
    String name;
    
    //实例化初始值
    //使用new 关键字，本质是在调用构造器
  
    //无参构造
    public Person(){
        this.name = "xiachen";
    }
    //有参构造
    public Person(String name){
        this.name = name;
    }
}

package oop.constructorMethod;

/*
构造器：
    1.和类名相同
    2.没有返回值
作用：
    1.new 本质在调用构造方法
    2.初始化对象的值
注意点：
    1.定义有参构造器之后，如果想使用无参构造器，就显示的定义一个无参的构造器
快捷键：
 fn+ control + enter 选中 Constructor

 this.name = name 左边的name是当前类的，右边的name是构造器参数传进来的
 */

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

    public static void main(String[] args) {
        //new 实例化了一个对象
//        Person person  = new Person();  //调用无参构造方法
        Person person  = new Person("xiaochen"); //调用有参构造方法
         System.out.println(person.name);
    }
}

封装（Encapsulation）

属性私有，get/set

package oop.Encapsulation;

//类    private：私有
public class Student {

    //属性私有
    private String name; //名字
    private int id;  //学号
    private char sex; //性别
    private int age; //年龄


    //提供一些可以操作这个属性的方法
    //提供一些 public 的 get、set 方法
    // fn + control + enter  点击 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) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

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

package oop.Encapsulation;

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


public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("小陈");
        System.out.println(s1.getName());
        s1.setAge(999); //不合法
        System.out.println(s1.getAge());


    }
}

继承（Inheritance）

类的继承格式： extands public class 子类 extends 父类 { }

package oop.inherit;

//在Java中，所有的类，都默认直接或者间接继承Object
//Person 人 ： 父类
public class Person {

    private int money = 10_0000_0000;

    public void say(){
        System.out.println("说类一句话 ");
    }

    //快捷键：fn+ control + enter Getter

    public int getMoney() {
        return money;
    }

    //快捷键：fn+ control + enter Setter
    public void setMoney(int money) {
        this.money = money;
    }

}

package oop.inherit;

//extends Java中只有单继承，没有多继承
//Student is 人
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {
}

package oop.inherit;


//一个项目应该只有一个main方法
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();  // 说了一句话
        System.out.println(student.getMoney());   //1000000000
    }
}

super

注意点：

1.super调用父类的构造方法，必须在构造方法的第一个

2.super 必须只能出现在子类的方法或者构造方法中

3.super 和 this 不能同时调用构造方法

VS this的注意点：

​ 代表的对象不同：

​ this：本身调用者这个对象

​ super：代表父类对象的应用

​ 前提：

​ this：没有继承也可以使用

​ super：只能在继承条件才可以使用

​ 构造方法：

​ this(); 本类的构造

​ super().; 父类的构造

方法重写（Override）

package oop.Override;

//重写都是方法的重写，和属性无关
public class B {
    public void test(){
        System.out.println("111");
    }
}

package oop.Override;

public class A extends B {
    //Override 重写
    @Override //注解：有功能的注释
    public void test() {
        System.out.println("重写方法");
    }
}

package oop.Override;

/*
方法重写：
需要继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大但不能缩小：Public > Protected > Default >Private
4.抛出的异常：范围，可以被缩小，但不能扩大；  ClassNotFoundException  --> Exception (大)
重写：子类的方法和父类必须一直，方法体不同！
为什么需要重写：
1.父类的功能，子类不一定需要，或者不一定满足！
idea快捷键：fn + control + enter 选中  Override
 */


public class Application {

    //静态的方法和非静态的方法区别很大
    //静态方法：方法的调用只和左边定义的数据类型有关
    //非静态方法：重写
    public static void main(String[] args) {

        //方法的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();  //A类

        //父类的引用指向子类
        B b = new A();  //子类重写类父类的方法
        b.test(); //B类

    }
}

多态（polymorphism）

package oop.polymorphism;

public class Person {

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

}

package oop.polymorphism;


public class Student extends Person {

    @Override
    public void run() {
        System.out.println("son");
    }

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

package oop.polymorphism;

/*
注意事项：

1.多态是方法的多态，属性没有多态
2.父类和子类，有联系，类型转换异常！ ClassCastException
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father  f1 = new Son();
1.static 方法，属于类，它不属于实例
2.final 常量；
3.private 方法；
 */

public class Application {

    public static void main(String[] args) {

        //一个对象的时间类型是确定的
        // new Student();
        // new Person();

        //可以指向的引用类型就不确定了，父类的引用指向子类的类型

        //Student 能调用的方法都是字节的或者继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();
    }
}

instsnceof

​ System.out.println(X instsnceof Y); //能不能编译通过！

类型转换

​ 1.父类引用指向子类的对象

​ 2.把子类转换为父类，向上转型；直接转换 Father f1 = new Son();

​ 3.把父类转换为子类，向下转型；强制转换 Son son = (Son) f1

​ 4.方便方法的调用，减少重复的代码！简洁

抽象类

//abstract 抽象类： 类extends：单继承～  （接口可以多继承）
public abstract class Action {

    //约束～ 又热帮我们实现～
    //abstract，抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();

    //1.不能new这个抽象类，只能靠子类去实现它：约束！
    //2.抽象类中可以写普通方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象：约束
}

接口

定义第一个接口

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

//实现了接口的类

//抽象类：entends～ 只能单继承
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法

//多继承-->利用接口实现多继承
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() {

    }
}


/*
作用：
    1.约束
    2.定义一些方法，让不同的人实现～  10个人就有10种不同实现的方式
    3.public abstract  方法默认
    4.pub static final  常量默认
    5.接口不能被实例化，接口中没有构造方法
    6.implements 可以实现多个接口
    7.必须要重写接口中的方法
 */