Java面向对象编程

面向对象编程

1、初见面向对象

• 面向对象编程(Object-Oriented Programming,OOP)
• 面向对象编程的本质是:以类的方法组织代码,以对象的组织(封装)数据.
• 抽象（抽出共同的相同的）
• 三大特征:
  • 封装
  • 继承
  • 多态
• 认识论:先有对象后有类.
• 代码角度:先有类后又对象.

2、方法回顾和加深

方法名：注意规范就好（见名知意）

静态方法和非静态方法:

static在方法中的作用:

package com.Demo;

public class Demo01 {
	//静态方法
    public static void SayHello(){
        System.out.println("HelloWorld!");
    }
}

package com.Demo;

public class Demo02 {
    public static void main(String[] args) {
        //直接调用方法
        Demo01.SayHello();
    }
}

package com.Demo;

public class Demo01 {
	//非静态方法
    public void SayHello(){
        System.out.println("HelloWorld!");
    }
}

package com.Demo;

public class Demo02 {
    public static void main(String[] args) {
		//实例化这个类
        //对象类型 对象名 = 对象值;
        new Demo01().SayHello();
        //或者下面也行
        Dome01 demo = new Dome01();
        demo.SayHello();
    }
}

package com.Demo4;
public  class Action {
    public static void main(String[] args) {
    }
    //静态方法
    public static void a(){
        b();//报错
    }
    //非静态方法
    public void b(){
        a();//正确
    }
}

总结:

1. 非静态方法需要一个对象来调用。
2. 静态可以直接调用。
3. static是和类一起加载的。
4. 非静态方法可以调用静态方法。

形参和实参

package com.Demo;

public class Demo {
    public static void main(String[] args) {
        //实参
        int sum = Demo03.Multiplication(1, 2);
        System.out.println(sum);
    }
	//形参
    public  static int Multiplication(int a,int b){
        return a*b;
    }
}

值传递和引用传递

public class Demo {

    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);//a=1

        Demo04.change(a);

        System.out.println(a);//a=1
    }

    public static void change(int a) {
        a = 2;
    }
}

package com.Demo;
//引用传递:对象,本质还是值传递
public class Demo {
    public static void main(String[] args) {

        Person p = new Person();

        System.out.println(p.name);//null

        Demo05.change(p);

        System.out.println(p.name);//Tom

    }
    public static void change(Person p){
        //p是一个对象:指向的---> Person p = new Person();这是一个具体的人,可以改变属性
        p.name= "Tom";
    }

}

class Person{
    String name;
    int age;
}

3、对象的创建分析

• 类是抽象的，要实例化，实例化后返回一个自己的对象！
• 使用new关键字创建对象
• 构造器：
  • 和类相同的类名
  • 没有返回值
• 类中的构造也称为构造方法
  • 有参构造
  • 无参构造
• 构造器必须要掌握
  • 一旦定义了有参构造,无参构造就必须显示定义,不然就会报错
• 实例化初始值
  • 使用new关键字,本质是调用构造器
  • 用来初始化值
• this关键字
  • this.(构造器的)name = (参数的)name;
• 总结:
  • 类是一个模板,对象是一个具体的实例
  • 方法(定义,调用)

4、面向对象三大特征

(1)、封装

1. 高内聚,低耦合
2. 属性私有,get/set

(2)、重载

• 有相同的函数名称，但是参数类型（个数、类型、参数排列顺序）不同

(3)、多态

• 包括编译阶段和运行阶段
• （重点）编译阶段：看左边；（记住）|| 运行阶段：看右边
• 为什么说java是面对对象？对象是什么，就调用什么
• 作用：降低程序的耦合度，提升程序的扩展性；

扩展：继承（extends）

• java只有单继承，没有多继承
• 子类和父类的关系，从某些意义上讲是“ is a ”的关系
• 继承是类和类的之间的关系
• object类
• super（注意和this区别）

//person类
package com.Demo;

public class Person {
    protected String name = "Tom111";

}
//Students类
package com.Demo;

public class Students extends Person {

    private String name = "Tom222";

    public  void say(String name){
        System.out.println(name);//Tom333
        System.out.println(super.name);//Tom111
        System.out.println(this.name);//Tom222
    }
}
//测试类
package com.Demo;

public class Test {
    public static void main(String[] args) {
        Students s = new Students();
        s.say("Tom333");

    }
}

• supre
  • super调用父类的构造方法，必须在构造方法的第一个
  • super必须只能在子类的方法或者构造方法中！
  • super和this不能同时调用构造方法！
• this
  • this本身调用者这个对象
  • super代表父类对象的应用
• 前提
  • this：没有继承也可以使用
  • super：只能在继承条件才能使用
• 构造方法
  • this（）；本身的构造
  • super（）；父类的构造

//父类
package com.Demo;
public class Person {
    public Person() {
        System.out.println("父类方法调用了");
    }
}
//子类
package com.Demo;
public class Students extends Person {
    public Students() {
        //默认有个super（）
        super（）;
        System.out.println("子类方法调用了");
    }
}
//主函数
package com.Demo;
public class Test {
    public static void main(String[] args) {
        Students s = new Students();
    }
}
//输出：
父类方法调用了
子类方法调用了

权限：

public

protected

default

private

• 方法重写（需要有继承关系，子类继承父类）
  • 重写都是方法的重写
  • 方法名必须相同
  • 参数列表必须相同
  • 修饰符：范围扩大：private---->public
  • 抛出的异常范围可以被缩小，但是不能扩大
  • 方法名相同，方法体不同
• 无法重写：
  • static 方法
  • final 常量
  • private 方法
• instanceof和类型转换
  • instanceof

public class Test {
    public static void main(String[] args) {
        //Object-->People-->Teacher
        // Object-->People-->Studnets
        Object o = new Students();
        System.out.println(o instanceof Students);//ture
        System.out.println(o instanceof People);//ture
        System.out.println(o instanceof Teacher);//false
        System.out.println(o instanceof Object);//ture
        System.out.println("===============================");
        People p = new Students();
        System.out.println(p instanceof Students);//ture
        System.out.println(p instanceof People);//ture
        System.out.println(p instanceof Teacher);//false
        System.out.println(p instanceof Object);//ture
        System.out.println("===============================");
        Students s = new Students();
        System.out.println(s instanceof Students);//ture
        System.out.println(s instanceof People);//ture
        System.out.println(s instanceof Object);//ture
    }
}

• 类型转换
  • 向上转型：自动转换
  • 向下转型：强制转换
• static关键字详解

//变量
pravatic static int age;
pravatic int money;
Student s = new Student();
//调用：
s.money;
Student.age;
//方法
public static void Hello(){
}
//匿名
{
    //代码块（匿名代码块）
}
//静态（只执行一次）
static{
    //静态代码块
}
//构造
public person(){
    
}
//加载的顺序：静态>匿名>构造

5、抽象类和接口

abstract

1. abstract修饰
2. 继承了抽象的所有方法（包括抽象方法）的子类都必须要实现它的方法。除非子类也是抽象类。
   • 不能被new这个抽象类，只能靠子类去实现它：约束！
   • 抽象类中可以写普通的方法
   • 抽象方法必须在抽象类中
   • 抽象的抽象：约束
3. 思考？
   • 抽象类存在意义？

接口

1. 只有规范
2. 接口本质是契约
3. 声明类的关键字是class，声明接口的关键字是interface
4. 利用接口实现多继承
5. 实现了接口的类，就需要重写接口的方法
6. 接口不能被实例化，接口中没有构造方法

6、内部类

定义：在一个类中，再定义一个类

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

内部类可以获取外部类属性。

原文：https://www.cnblogs.com/starsupreme/p/14724192.html