java面向对象的学习

面向对象编程oop

面向过程 & 面向对象

面向过程思想：

步骤清晰简单，第一步做什么，第二部做什么…
面向过程比较适合处理一些较为简单的问题

面向对象思想：

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索。

面向对象适合处理复杂的问题，适合处理需要多人协作的问题

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

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

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

抽象：把很多对象的共同点抽取出来形成类

三大特性：封装(把数据封装起来，对外提供一个接口用来访问）、继承(子类可以继承父类的所有东西)、多态()

从认识论角度考虑是先有对象后有类。对象是指具体的事物。类是抽象的，是对具体事务的抽象。比如狗就是一个类，是对所有的狗个体的抽象，而单独的一条狗就是一个对象。

从代码运行角度考虑是先有类后有对象，类是对象的模板。

回顾方法

• 方法的调用

package com.oop.demo01;
//Demo01 类
public class Demo01 {
    //main方法 用来启动程序
    public static void main(String[] args) {
        //静态方法 直接调用 类名.方法名
        Student.say();
        //非静态方法
        //先实例化这个类 new一个对象
        Student student = new Student();
        student.say2();
    }

    //static修饰的方法是和类一起加载的，出现的比较早
    public static void a(){
//        b(); 一个已经存在的去调用一个不存在的方法所以会报错
    }
    //类实例化之后才存在
    public void b(){

    }
}

package com.oop.demo01;

//学生类
public class Student {
    //静态方法  static
    public static void say(){
        System.out.println("aaa");
    }
    //非静态方法
    public  void say2(){
        System.out.println("bbb");
    }
}

• 值传递

package com.oop.demo01;

public class Demo02 {
    public static void main(String[] args) {
        int a = 1;
        change(a);
        System.out.println(a);//1，因为java是值传递
        
    }
    //返回值为空
    public static void change(int a){
        a = 10;
    }
}

• 引用传递

package com.oop.demo01;

//引用传递 一般传递一个对象 本质还是值传递
public class Demo03 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null
        change(person);
        //person.name引用的是person对象此时对象中的内容被更改过了
        System.out.println(person.name);//syan
    }
    public static void change(Person person){
        //person是一个对象；更改的是new出来的person对象
        person.name = "syan";
    }
}
//一个程序只能有一个public类
//定义了一个person类 有一个属性：name
class Person{
    String name;//null
}

类与对象的创建

使用new关键字创建对象，一个类中只有属性和方法两样东西

new一个对象时，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

package com.oop.demo02;
//学生类
public class Student {
    //属性：字段
    String name;
    int age;

    //方法
    //this就是指当前这个类
    public void study(){
        System.out.println(this.name+" is studying");
    }
}

package com.oop.demo02;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类是抽象的，需要具体的实例化出来
        //使用new把类实例化之后会返回一个自己的对象
        //student对象就是Student类的一个具体实例
        Student student = new Student();
        student.name = "syan";
        student.study();
    }
}

构造器

类中的构造器也称之为构造方法，实在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点：1.必须和类的名字相同 2.必须没有返回类型，也不能写void

没有显示定义的话，在生成class文件中也会默认加了一个没有返回值的Person方法

package com.oop.demo02;

//java-->java.class
public class Person {
    //一个类即使什么都不写也会存在在一个方法名和类名相同的方法(构造器)
    String name;
    int age;
    //显示的定义一个构造器
    //1.实例化初始值，使用new关键字本质是在调用构造器
    //2.构造器用来初始化值，也就是初始化上面定义的属性的值
    //无参构造器
    public Person(){
//        this.name = "syan";//不写的话默认为null
    }

    //有参构造,一旦定义有参构造，无参构造就必须显示定义，否则无参构造就无效了
    public Person(String name){
        this.name = name;
    }
}
    /* public static void main(String[] args) {
        Person person = new Person("syan");//这时候走的就是有参构造
        System.out.println(person.age);
        System.out.println(person.name);
    }
    alt+insert 快速生成
    */

创建对象内存分析

package com.oop.demo02;

public class Pet {
    String name;
    int age;
    public void shout(){
        System.out.println("wang!!!");
    }
}
/*
public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();//调用无参构造，初始化属性值
        dog.name = "旺财";
        dog.age = 1;
        dog.shout();

        Pet cat = new Pet();
    }
}
 */

第一步加载Application这个类存放在方法区(也属于堆的一部分)中，有静态方法的话一同加载，然后执行main()方法，执行 Pet dog = new Pet()时加载Pet这个类，在堆中存放一个dog引用变量名，同时在堆中开辟空间存储这个新new的dog，且用无参构造初始化值，然后从方法区中的常量池(3不属于常量)中把旺财赋值给name，把3赋值给age，从Pet中调用shout()方法。Pet cat = new Pet()同理…

封装

程序设计追求的就是“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉，低耦合是指，仅暴露少量的方法给外部使用。

封装(数据的隐藏)

通常应该进制直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏。

package com.oop.demo03;

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

public class Student {
    //属性私有
    //名字 private :私有
    private String name;
    //学号
    private int id;
    //性别
    private char gender;
    //年龄
    private int age;

    //提供一些可以操作这些私有属性的方法
    //提供一些 public 的get 、set 方法
    //get：获取这个属性
    public String getName(){
        return this.name;
    }
    //set：个这个属性赋值
    public void setName(String name){
        this.name = name;
    }
    //alt + insert 快速生成


    public int getAge() {
        return age;
    }
    //在set方法中做数据的安全性的判断
    public void setAge(int age) {
        if(age>120 || age<0){
            this.age = 2;
        }else{
            this.age = age;
        }

    }
}
/*
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
//        student.name = "syan";因为name是私有属性不能直接调用
        student.setName("syan");
        String name = student.getName();
        System.out.println(name);

        student.setAge(888);//不合法的年龄
        System.out.println(student.getAge());
    }
}

 */

继承

什么是继承

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

extends 意思是“扩展”，子类是对父类的扩展。

Java中类只有单继承没有多继承。一个儿子只能有一个爸爸，一个爸爸可以有多个儿子，直接的只能继承一个但间接的可以继承多个，比如每个类都会直接或间接的继承Object类。

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

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

子类和父类之间，从意义上来讲因该具有“ is a ”的关系

Ctrl + h 打开继承树

package com.oop.demo04;
//人
//在Java中所有的类都默认直接或者间接继承Object类
public class Person {
    //public
    //private 父类私有的属性子类不可以继承,但可以操作get，set
    //default
    //protected 修饰的属性也可以被直接调用
    private int money = 10_0000_0000;
    public void say(){
        System.out.println("yayaya");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

package com.oop.demo04;
//学生也是人
public class Student extends Person{
}


package com.oop.demo04;
//老师也属于人 子类继承父类拥有父类的全部方法
public class Teacher extends Person{
}

package com.oop.demo04;
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.getMoney());
    }
}

super

super:

1.super调用父类的构造方法时，必须在子类构造方法中第一行
2.super 必须只能出现在子类的方法或者构造方法中。
3.super和this不能同时出现在构造方法中。

和this对比：

代表的对象不同：this是指本身调用者这个对象，super代表父类对象的引用。

前提条件：this没有继承也可以使用，super只能在继承条件下才可以使用

构造方法：this();本类的无参构造，super()；父类的无参构造。

package com.oop.demo05;
//父类
public class Person {
    protected String name = "syan";

    public Person() {
        System.out.println("Person的无参构造执行");
    }
    //private修饰的方法无法被继承
    public void print(){
        System.out.println("person");
    }

}

package com.oop.demo05;

//子类
public class Student extends Person {
    private String name = "ccc";

    public Student() {
        //new Student()时先调用了父类的无参构造
        //而且如果父类没有无参构造，子类也无法实现无参构造
        super();//隐藏代码 调用父类的构造器必须在子类的第一行
        System.out.println("Student无参构造执行");
    }

    public void print(){
        System.out.println("student");
    }
    public void test01(){
        print();
        this.print();
        super.print();
    }
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        //super 指的是父类
        System.out.println(super.name);
    }
}

//主函数
public class Application {
    public static void main(String[] args) {
        Student student = new Student();//Person的无参构造执行 Student无参构造执行
//        student.test("aaa");
//        student.test01();
    }
}

方法的重写

重写：需要有继承关系，子类重写父类的方法。

1.方法名必须相同，参数列表必须相同，方法体不同.

2.重写的方法的修饰符：范围可以扩大但不能缩小。 public>protected>default>private

3.抛出的异常：范围可以缩小但不能扩大。

为什么要重写？

父类的功能，子类不一定需要，或者不一定满足

快捷键 alt+insert --> override 快速生成重写方法

package com.oop.demo05;
//父类
//重写是方法的重写和属性没有任何关系
public class B {
    protected  void test(){
        System.out.println("B--test");
    }
}

package com.oop.demo05;
//子类
public class A extends B{
    public void test(){
        System.out.println("A--test");
    }
}

package com.oop.demo05;

public class Application {
    //静态方法和非静态方法的区别很大
    //使用静态方法时方法的调用只和左边定义的数据类型有关
    public static void main(String[] args) {
        A a = new A();
        a.test();
        //父类的引用指向子类
        B b = new A();//重写只能在非静态方法下而且还必须是public修饰
        b.test();//子类重写了父类的test方法

    }
}

多态

什么是多态？

多态即同一方法可以根据发送对象的不同而采用不同的行为方式。

一个对象的实际类型是确定的,但可以指向对象的引用的类型(父类，有关系的类)有很多。

多态存在的条件：有继承关系；子类重写父类方法；父类引用指向子类对象

多态是方法的多态，属性没有多态

package com.oop.demo06;

public class Person {
    public void test(){
        System.out.println("father");
    }
}

package com.oop.demo06;

public class Student extends Person{
    @Override
    public void test() {
        System.out.println("son");
    }
}

package com.oop.demo06;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
//        new Student();
//        new Person();

        //可以指向的引用类型是不确定的 ：父类的引用指向子类
        //子类能使用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //父类型可以指向子类，但不可以调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法主要看对象左边的类型，父类有的子类没有重写就调用父类的
        s2.test();//子类重写了父类的方法，执行子类的方法
        s1.test();
    }
}

instanceof关键字

instanceof 关键字 （a instanceof b）首先得a和b得有关系否则编译就不通过，如果a是b的实例则输出的就是true否则是false

package com.oop.demo06;

public class Application {
    public static void main(String[] args) {

        //Object---String
        //Object---Person---Student
        //Object---Person---Teacher
        Object object = new Student();
        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);//不可以比较person和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);//student和Teacher根本无关
//        System.out.println(student instanceof String);//
    }
}
package com.oop.demo06;
public class Teacher extends Person {
}

package com.oop.demo06;
public class Student extends Person{
}

引用类型转换

方便方法的调用，简化代码

package com.oop.demo06;

public class Application {
    public static void main(String[] args) {
        //类型转换  父(高)   子(低)
        //Person(高)       Student(低)---不需要强制转换
        Person person = new Student();
        //将person强制转换成Student类型就可以使用Student里面的方法了
        Student s1 = (Student) person;//转换的其实都是对象
        s1.run();
        //子类转父类 会丢失一些自己本来的方法
        Student student = new Student();
        Person p = student;
        
    }
}

static关键字

静态变量和静态方法

package com.oop.demo07;

public class Student {
    public static String name;//静态变量
    public int age;//非静态变量
    public void run(){
    }
    //静态方法
    public static void go(){

    }
    //有static修饰符的属性和方法是和类一起加载的
    public static void main(String[] args) {
        System.out.println(Student.name);//可以直接调用
        System.out.println(new Student().age);//需要new对象来使用
        go(); //直接使用
        new Student().run();//需要new对象
    }

}

静态代码块

package com.oop.demo07;

public class Person {
    //匿名代码块 第二个执行 一般可以用来赋初始值 和对象一起产生
    {
        System.out.println("匿名代码块");
    }
    //静态代码块 第一个执行和类一起加载而且只执行一次
    static {
        System.out.println("静态代码块");
    }
    //第三个执行
    public Person() {
        System.out.println("无参构造");
    }

    public static void main(String[] args) {
        new Person();
        System.out.println("*********");
        new Person();
        /*执行结果：
        静态代码块
        匿名代码块
        无参构造
        *********
        匿名代码块
        无参构造*/
    }

}

静态导入包

package com.oop.demo07;
//静态导入包
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);
    }
}

抽象类

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

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

抽象类不能使用new关键字来创建对象，它是用来让子类继承的

抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。

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

package com.oop.demo08;

//抽象类  类 extends 单继承 但接口可以多继承
public abstract class Action {
    //抽象方法，只有方法名没有方法体 像是一种约束 等着子类实现
    public abstract void doSth();
}

package com.oop.demo08;
/*抽象类的所有方法，继承了它的子类必须要实现它的抽象方法
  除非子类也是一个抽象类 */
public class A extends Action{
    @Override
    public void doSth() {

    }
}

接口

普通类只有具体实现；抽象类具体实现和规范(抽象方法)都有

接口：只有规范，自己无法写方法，是一种专业的约束。约束和实现分离：面向接口编程

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。

接口的本质就是契约，就像法律一样，制定好大家都遵守。
oo的精髓就是对对象的抽象，最能体现这一点的就是接口。

接口不能被实例化，接口中也没有构造方法。

package com.oop.demo09;
//使用interface关键字定义关键字  接口都需要有实现类
public interface UserService {
    //接口中定义的属性默认就是常量 一般不定义属性在接口中
    public static final int age = 1;

    //接口中的所有定义其实都是抽象的 默认为 public abstract
    public abstract void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

package com.oop.demo09;

public interface TimeService {
    void time();
}

package com.oop.demo09;

//类 可以实现接口 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 time() {

    }
}

内部类

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

• 成员内部类

package com.oop.demo10;

public class Outer {
    private int age = 1;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    //成员内部类 可以获得外部类的私有属性 私有方法
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        public void getAge(){
            System.out.println(age);
        }
    }
}

package com.oop.demo10;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getAge();
    }
}

• 局部内部类

package com.oop.demo10;

public class Outer {
    //局部内部类
    public void method(){
        class Inner{
        }
    }
}

• 匿名内部类

package com.oop.demo10;

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类,不用实例保存在变量中
        new Apple().eat();
        //其实这个方法会返回一个UserService对象
        UserService userService = new UserService() {
            @Override
            public void a() {
            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("eat");
    }
}
interface UserService{
    void a();
}