Java面向对象精讲-优快云博客

java面向对象学习（个人参考学习）

java核心思想就是面向对象(OOP)

面向对象和面向过程

面向过程思想：

步骤清晰简单，第一步，第二步。。。。

面向过程适合处理一些简单的问题

面向对象思想：

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

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

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

什么是面向对象

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

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

抽象

面向对象三大特性：封装，继承，多态。

从认识论角度考虑是先用对象后有类。对象是具体事物。类是抽象的，是对对象的抽象。

从代码运行的角度上是先用类在有对象。类是对象的模板。

方法的加深学习

方法分为两种一种静态方法（static）一种非静态方法

//非静态方法只能通过实例化来调用
public class Demo{
public void f(){
    System.out.println("这是一个非静态方法");
}
//静态方法可以通过类名.方法名称来调用
public static void f1(){
    System.out.println("这是一个静态方法");
}
}
//非静态方法调用
Demo demo=new Demo()
demo.f();
//静态方法调用
Demo.f1();

static是和类一起加载的当类已经存在static就已经存在了静态方法是无法调用非静态方法非静态方法可以调用静态方法。

值传递和引用传递

java中都是值传递。

 public static void main(String[] args) {
        P p = new P();
        int a = 1;
        c(a);
        c(p);
        //输出1值未改变值
        System.out.println(a);
        //输出10此对象值已经改变
        System.out.println(p.name);

    }

    //这里值传递后在方法里面改变了a的值并没有改变主方法里面的值所以主方法还是会输出1
    public static void c(int a) {
        a = 10;
    }

    //引用传递：对象本质还是值传递这里的p代表  P p = new P();这个对象所以值可以受到改变
    public static void c(P p) {
        p.name = "10";
    }

    static class P {
        String name;
    }

类与对象的关系

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

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

使用new关键字创建对象

构造器

一个类即使什么都不写也会存在一个方法这个方法就是无参构造方法，构造方法必须和类名相同，也不能有返回值，也不能写viod。

构造器可以初始值。使用new 关键字本质就是调用构造器。一旦定义了有参构造，无参构造就必须自己定义。

public class OopDemo {
    //无参构造
    public OopDemo() {
    }

    //有参构造一旦定义了有参构造，无参构造就必须自己定义。
    public OopDemo(String name) {
        System.out.println(name);
    }
}

封装

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

通常，应禁止直接访问一个对象中的数据的实际表示而是通过接口来访问，这称之为信息隐藏。

属性私有化：get,set.*。private(私有)

封装的好处：

提高代码的安全性，保护数据。

隐藏代码实现细节。

统一接口。

系统可维护性增加。

public class OopDemo {
    //属性私有化
    private int age;
    private int name;

    //提供一些可以操作私有化属性的方法
    //get方法获取到年龄
    public int getAge() {
        return age;
    }

    //set方法设置年龄
    public void setAge(int age) {
        this.age = age;
    }

    public int getName() {
        return name;
    }

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

继承

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

extends关键字，子类是父类的扩展。

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

java中所有类都默认继承Object类

//父类
public class OopDemo {
    //属性私有化
    private int age;
    private int name;

    //提供一些可以操作私有化属性的方法
    //get方法获取到年龄
    public int getAge() {
        return age;
    }

    //set方法设置年龄
    public void setAge(int age) {
        this.age = age;
    }

    public int getName() {
        return name;
    }

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

//子类继承父类并且子类没有任何方法
public class OopDemo2 extends OopDemo {

}
//使用子类调用父类方法（父类方法必须是public才能被子类调用）
    public static void main(String[] args) {
        //实例化
        OopDemo2 oopDemo=new OopDemo2();
        oopDemo.setAge(1);
    }

super和this

this代表当前类中的，super代表父类中的。私有的东西无法使用super,默认调用了父类的无参构造

super注意点：

1. super调用父类构造方法必须在构造方法第一行。

2. super只能出现在子类的方法或者构造方法中。
3. super和this不能同时调用构造方法。

public class OopDemo2 extends OopDemo {
    private int age = 10;

    public void sys(int age) {
        //输出传递过来的age值
        System.out.println(age);
        //输出本类中的age值
        System.out.println(this.age);
        //输出父类中的age值
        System.out.println(super.age);

    }
}

方法的重写

重写都是方法的重写和属性无关，父类的引用可以指向子类。

重写至和非静态方法有关。

重载是同一类里，方法名相同，参数类型不同。重写是子父类间，子类重写父类的方法，alt+insert，方法名相同，方法内容不同。使用public方式，且不使用static方式。

重写：需要继承关系，子类重写父类方法，方法名必须相同，参数列表必须相同，修饰符范围可以扩大但不能缩小。

//父类
public class OopDemo {

    public void sys() {
        System.out.println("我是父类");
    }


}
//子类
public class OopDemo2 extends OopDemo {

    //重写父类方法
    @Override
    public void sys() {
        System.out.println("我是子类");
    }
}

多态

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

一个对象的实际类型是确定的，但可以指向对像的引用类型有很多。

多态存在的条件

有继承关系。

子类重写父类方法。

父类引用指向子类对象。

多态是方法的多态性而不是属性。

多态需要注意事项：

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

2. 父类和子类有联系
3. 必须有继承关系，方法需要重写，父类引用指向子类对象，static 方法无法重写，final无法重写，private 无法重写。

//父类
public class OopDemo {

    public void sys() {
        System.out.println("我是父类");
    }
}
//子类
public class OopDemo2 extends OopDemo {

    //重写父类方法
    @Override
    public void sys() {
        System.out.println("我是子类");
    }

    public void a(){
        System.out.println("s");
    }
}
//调用
 public static void main(String[] args) {
        //实例化
        //对象能执行哪些方法主要看对象左边的类型，和右边关系不大 
        OopDemo oopDemo=new OopDemo2();
        OopDemo2 oopDemo2=new OopDemo2();

        //父类只能调用自己的方法 子类重写了父类的方法执行子类的方法
        oopDemo.sys();
        //子类可以调用继承父类的方法和自己的方法
        oopDemo2.sys();
        oopDemo2.a();

    }

static关键词

static（静态）static修饰过后的方法或者属性都会随着类加载而被加载使用static修饰符后可以使用类名.属性来调用。静态代码块会最先加载，其次是匿名代码块最后是构造方法。

//静态变量
private static int a;
//非静态变量
private  int b;

public void a(){
    System.out.println("非静态方法");
}
public static void a(){
    System.out.println("静态方法");
}
//静态代码块
static {}
//匿名代码块
{}

抽象类

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

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

抽象类不能使用new关键字来创建，它是用于子类继承的，抽象方法只有声明方法没有方法实现，它是用来让子类实现的，子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否者该子类也要声明成抽象类,抽象类可以写普通方法，抽象类中是有构造方法的

//抽象类
public abstract class AbstractDemo {
    /**
     * 抽象方法
     */
    public abstract void doSomething();
	/**
	 *非抽象方法
	 */
    public  void doSomething2(){
    };
}
//子类
public class Demo1 extends AbstractDemo {
    /**
     * 子类重写父类抽象方法
     */
    @Override
    public void doSomething() {
    }
}

接口

接口只有规范，接口自己无法实现方法，约束和实现分离。接口的本质是契约，接口实现的关键字是interface，接口中所有定义都是public abstract的。接口必须由类来实现并重写接口中的所有方法类中用 implements来实现接口，接口可以多实现。

/**
 * 接口
 *
 * @author
 */
public interface UserService {
    /**
     * 输出语句接口
     * @param name
     */
    void sys(String name);

}

/**
 * 实现接口
 *
 * @author
 */
public class UserServiceImpl implements UserService {
    /**
     * 重写方法
     * @param name
     */
    @Override
    public void sys(String name) {
    }
}

内部类

内部类就是在一个类中的内部在定义一个类，比如，A类中定义了B类，那么B类就是A类的内部类，而A类就是B类的外部类。内部类可以访问外部类私有的属性和方法

成员内部类

/**
 * 外部类
 * @author Administrator
 */
public class Outer {
    private int id;

    public void sys() {
        System.out.println("这是外部类");
    }

    //内部类
    public class Inner {
        public void sys() {
            System.out.println("这是成员内部类");
        }
    }
}
//调用
    public static void main(String[] args) {
        //使用成员内部类要先吧外部类给new出来在使用外部类实例化内部类进行访问
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.sys();
    }

静态内部类

静态内部类无法使用外部类的非静态属性或者方法

/**
 * 外部类
 * @author Administrator
 */
public class Outer {
    private int id;

    public void sys() {
        System.out.println("这是外部类");
    }

    //内部类
    public static class Inner {
        public void sys() {
            System.out.println("这是静态内部类");
        }
    }
}
//调用
    public static void main(String[] args) {
       //静态内部类调用
        Outer.Inner inner = new Outer.Inner();
        inner.sys();
    }

局部内部类

/**
 * 外部类
 *
 * @author Administrator
 */
public class Outer {
    private int id;

    public void sys() {
        System.out.println("这是外部类");
    }

    public void a() {
        class Inner {
            public void sys() {
                System.out.println("这是局部内部类");
            }
        }

    }

}