java面向对象oop基本知识

面向过程&面向对象

面向过程

1、步骤清晰简单，第一步做什么，第二部做什么…

2、面对过程适合一些简单的问题

面向对象

1、物以类聚，分类的思维模式，思考问题首先会解决需要哪些分类

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

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

三大特性：

1.封装

2.继承

3.多态

public class Demo01 {
    public static void main(String[] args) {
        //可以直接调用
        Student.say();
        Student student=new Student();
        student.sayHello();
    }
}
//学生类
public class Student {
    //静态方法
    public static void say()
    {
        System.out.println("xiaohong say hello");
    }
    //非静态方法
    public  void sayHello()
    {
        System.out.println("xiaoming say hello");
    }
}

类于对象的关系

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

对象：对象是抽象概念的具体事例。

创建与初始化对象

用new方法创建对象。

public class Student {
    //属性:字段
    String name;
    int age;
    //方法
    public void study()
    {
        System.out.println(this.name+"在学习");
    }
}

public class Test {
    public static void main(String[] args) {
        Student xiaoming=new Student();
        xiaoming.name="小明";
        xiaoming.study();
    }
}

构造方法

1.每个类的都有一个没有参数的构造方法

2.构造方法名字必须与类名相同

3.没有返回值

封装

程序要追求“高内聚，低耦合”;

高内聚：就是类的内部数据操作细节由自己完成，不允许外部干扰。

低耦合：仅暴露少量的方法给外部使用。

属性私有，get/set方法.

/*
封装的意义？
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加
*/
public class Student{
    //私有属性
    private Srting name;
    //设置属性值
    public void setName(Srting name)
    { this.name=name;}
    //获取属性值
    public String getName()
    { return this.name;}
}

继承 （extends）

继承的本质是对一批类的抽象

java中只有单继承，没有多继承！

public(共有) proteced（受保护的） default(默认) private(私有)

所以类都默认直接或间接继承了object类

super 代表父类 this 表示当前类

注意点：

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

2、super只能出现在子类的方法或者构造方法中！

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

//父类
public class Person {
   protected String name="Maple";
}
//子类
public class Student extends Person {
   private  String name="xiaoming";
   public void say(){
       //打印当前name
       System.out.println(name);
       //打印子类name
       System.out.println(this.name);
       //打印父类name
       System.out.println(super.name);
   }
}
public class Test {
   public static void main(String[] args) {
       Student student = new Student();
       student.say();//xiaoming   xiaoming   Maple

   }
}

方法的重写（@Override）

父类的引用指向了子类

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

1.方法名必须相同

2.参数列表必须相同

3.修饰符：范围可以扩大但不能缩小 ：public>Protected>Default>orivate

4.抛出的异常范围可以被缩小，但不能扩大；

多态

存在的条件：

1.有继承关系

2.子类重写父类的方法

3.父类引用指向子类对象

//父类

public class A {
    public void test()
    {
        System.out.println("A->test");
    }
}

//子类
public class B extends A{
//方法重写
    @Override
    public void test() {
        System.out.println("b->test");
    }
}

public class test {
    public static void main(String[] args) {
        B b=new B();
        A a=new B();
        b.test(); //b
        a.test();//b子类重写了父类的方法，执行子类的方法
    }
}

注意：

1.多态是方法的多态，属性没有多态性。

2.父类和子类，有联系 类型转换异常！ ClassCastException 类型转换异常

3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！ father f1=new son（）；

static 方法、final常量、private方法不能重写；

instarceof （类型转换） 引用类型。

高（父）----------->低（子）

子类转换为父类：向上转型；

父类装换为子类：向下转型：强制类型转换

static

import static java.lang.Math.random;//静态导入包
public class Test{
    System.out.println(random());//可以直接调用方法 
}

抽象类（abstract）

抽象类不能被new，只能被继承。

接口(定义：interface ，实现：implements)

1.约束

2.定义一些方法，让不同的人实现

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

接口可以多继承，但是每一个方法都需要重写。

接口的本质是契约

//创建一个接口
public interface UserService {
    void add(String name);
    void delete(String name);
}
//实现接口
public class UserServiceImpl implements UserService {
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }
}

内部类

1.成员内部类

2.静态内部类

3.局部内部类

4.匿名内部类