JAVASE基础--面向对象大纲

JAVA的核心思想是OOP（面向对象）

面向对象&面向过程

属性➕方法就是一个类

面向过程思想

步骤清晰简单，第一步做什么，第二步做什么。。（线性思维）

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

面向对象思想

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

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

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

什么是面向对象

面向对象编程（OOP）

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

抽象：抽取像的东西

三大特性：

封装

把数据封装，包装起来，对外提供一个小口用于访问

封装是面向对象的特征之一，是对象和类概念的主要特性。封装是把过程和数据包围起来，对数据的访
问只能通过指定的方式。

 在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性
用于表示内部状态。

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

 信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。

 封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部，
因而可以将应用程序修改带来的影响减少到最低限度。

继承

每一个儿子有父亲，我们可以有子类，父类，假设A类继承B类，A就包含了B的所有东西。

继承是一种联结类的层次模型，并且允许和支持类的重用，它提供了一种明确表述共性的方法。 新类继承了原始类后,新类就继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新

类的基类(父类)。 派生类(子类)可以从它的基类(父类)那里继承方法和实例变量，并且派生类(子类)中可以修改或增

加新的方法使之更适合特殊的需要继承性很好的解决了软件的可重用性问题。比如说，所有的Windows应 用程序都有一个窗口，它们可以看作都是从一个窗口类派生出来的。但是有的应用程序用于文字处理，有 的应用程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。

多态

同一个事物会有多种形态，比如两个学习能力不同的人同时执行学习这一方法，得到的结果不同。

多态性是指允许不同类的对象对同一消息作出响应。
多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

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

首先我们的对象是人，对他们抽象，比如这群人都是老师，老师就是类。先有人才有对象。

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

先去设计，对东西分好类，再去实现。首先我们有个人的类，再去变成各种各样的人，对象可以new出来。new是对象的关键字。

方法回顾

格式: 修饰符 返回类型 方法名(参数列表)异常抛出类型{...}

修饰符

public、static、abstract、final等等都是修饰符，一个方法可以有多个修饰符。例如程序入口 main方法，就使用了public static这个俩个修饰符 注:如果一个方法或者属性有多个修饰符,这多个修饰符是没有先后顺序的。

返回类型

方法执行完如果有要返回的数据,那么就要声明返回数据的类型,如果没有返回的数据,那么返回类型就必须写void。

只有构造方法(构造器)不写任何返回类型也不写void

package demo01;

public class Demo01 {//Demo01类
    public static void main(String[] args) {//main方法
        /*修饰符 返回值类型 方法名（...）{
           方法体
           return 返回值
        }



         */
    }
    public String sayHello(){
        return "hello,World";
    }
    public int max(int a,int b){//a,b是形式参数，并不参与实际运算只是传进来别人可以调用.
        return a>b ? a : b;//三元运算符
    }
}

break：跳出switch循环，结束循环

return：结束循环，在return之后再写东西会报错，当返回值类型为空时，return后可以什么也不写。

return 语句的作用
(1) return 从当前的方法中退出,返回到该调用的方法的语句处,继续执行。
(2) return 返回一个值给调用该方法的语句，返回值的数据类型必须与方法的声明中的返回值的类型一 致。
(3) return后面也可以不带参数，不带参数就是返回空，其实主要目的就是用于想中断函数执行，返回 调用函数处。

break语句的作用

(1)break在循环体内，强行结束循环的执行，也就是结束整个循环过程，不在判断执行循环的条件是否 成立，直接转向循环语句下面的语句。

(2)当break出现在循环体中的switch语句体内时，其作用只是跳出该switch语句体

方法名：注意规范

参数列表：（参数类型，参数名）...可以有一个或者多个参数

异常抛出：疑问

如果方法中的代码在执行过程中,可能会出现一些异常情况,那么就可以在方法上把这些异常声明并抛出, 也可以同时声明抛出多个异常,使用逗号隔开即可。

方法的调用：递归

静态方法：用static的

使用static修饰符修饰的方法,就是静态方法. 调用这种方法的时候,"可以"使用对象调用,也"可以"使用类来调用,但是推荐使用类进行调用,因为静态 方法是属于类的。(静态属性也是一样的)

非静态方法：需要new的方法

没有使用static修饰符修饰的方法,就是非静态方法.
调用这种方法的时候,是"一定"要使用对象的。因为非静态方法是属于对象的。(非静态属性也是一样的)

类中方法的调用

假设一个类中有ab两个方法，都是静态方法可以互相调用

public void a(){
    b();
}
public void b(){
}

假设一个类中有ab两个方法，都是非静态方法可以互相调用

public static void a(){
    b();
}
public static void b(){
}

假设一个类中有ab两个方法，静态方法不能直接调用非静态方法，因为

public static void a(){ 
//b();报错
}
public void b(){
a(); }

因为静态方法是和类一起存在的，所以可以在非静态方法中调用，但是非静态方法是后来创建的，在静态方法中，非静态方法没有加载好，所以无法调用。

另外:在同一个类中,静态方法内不能直接访问到类中的非静态属性.

总结:类中方法中的调用，两个方法都是静态或者非静态都可以互相调用，当一个方法是静态，一个方法是非静态的时候，非静态方法可以调用静态方法，反之不能。

形式参数和实际参数

// a = x;
public void test(int a//形式参数){
    //..
}
main:
int x = 1;//实际参数
t.test(x);

参数列表中的a是方法test的形参(形式上的参数)

调用方法时的x是方法test的实参(实际上的参数)

注意:形参的名字和实参的名字都只是一个变量的名字,是可以随便写的,我们并不关心这个名字,而是关 心变量的类型以及变量接收的值。

值传递

public class Test{
    public static void changeNum(int a){
         a = 10;
  }
    public static void main(String[] args){
        int a = 1; //没有返回值，因此a就算在上面输出，值还是0
 }  
}
  System.out.println("before: a = "+a);  //1
  changeNum(a);
  System.out.println("after: a = "+a);   //1
 } 
}

引用传递

package demo01;

public class Demo02 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
        Demo02.change(person);
        System.out.println(person.name);
    }

    public static void change(Person person) {
        person.name = "demono2";

    }
}
//定义了一个Person类，有一个属性：name
class Person{
    String name;//null
}

this关键字

类与对象的关系

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

动物，植物，手机，电脑。。。

都是抽象的概念，每一类都有很多种类，相当于共同特征

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

张三就是人的一个具体实例，张三家里的旺财，就是狗的一个具体实例。旺财就是对象，可以new出来。是狗类里的。

能够体现出特点，展现出功能的是具体的实例，

创建与初始化对象

使用new关键字创建对象

除了分配默认的值和空间

一个项目应该只存在一个main方法

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

使用new关键字创建对象

使用new关键字创建的时候，除了分配内存空间以外，还会给创建好的对象进行磨人的初始化。以及对类中构造器的调用。

类中的构造器也叫构造方法，是在进行创建类的时候自动创建的一个方法

1.必须和类名相同

2.必须没有返回值，也不能写void

构造器可以显示的定义

如下：

package Main;

public class person {
    public person() {//构造方法
    }
}

构造器的两个作用

1.使用new关键字，必须要有构造器

本质是在调用构造器

一旦定义有参构造，无参构造必须显示定义

2.构造器用来初始化值

this.xx(代表当前类的) = 传进来的值

创建对象内存分析

package Main;

public class hahaha {
    public static void main(String[] args) {
        person person = new person();//用new实例化一个对象
        student student = new student("sei" ,23);
        student.age = 1;
        System.out.println(student.name);
        System.out.println(student.age);
    }
}

package Main;

public class student {

    String name;
    int age;
    public void study(){
        System.out.println();
    }

    public student() {
    }
    public student(String name, int age) {
        this.name = name;
        this.age = age;
    }


}

 右边整体都是堆，下面有一个特殊区域方法区，main方法在栈中先加载，对象指向堆，给对象赋值，方法堆中有静态方法区，其中的static方法和类一起加载，因此堆中的任意对象都可以调用静态方法区中的方法

栈 stack:

1. 每个线程私有，不能实现线程间的共享!
2. 局部变量放置于栈中。
3. 栈是由系统自动分配，速度快!栈是一个连续的内存空间!

堆 heap:
1. 放置new出来的对象!

2. 堆是一个不连续的内存空间，分配灵活，速度慢!

方法区(也是堆):

1. 被所有线程共享!
2. 用来存放程序中永远是不变或唯一的内容。(类代码信息、静态变量、字符串常量)

引用类型的概念

1. java中，除了基本数据类型之外的其他类型称之为引用类型。
2. java中的对象是通过引用来操作的。(引用:reference)说白了，引用指的就是对象的地址!

属性(field，或者叫成员变量)

1. 属性用于定义该类或该类对象包含的数据或者说静态属性。

2. 属性作用范围是整个类体。
3. 属性的默认初始化:在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。(数值:0,0.0 char:u0000, boolean:false, 所有引用类型:null)

4.属性定义格式:

[修饰符] 属性类型 属性名 = [默认值]

类的方法

 方法是类和对象动态行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单
位，整个程序有一个个函数调用组成;面向对象中，整个程序的基本单位是类，方法是从属于类或对象
的。

方法定义格式:

[修饰符] 方法返回值类型 方法名(形参列表) { 
// n条语句
}

java对象的创建和使用

必须使用 new 关键字创建对象。

Person person= new Person ();
使用对象(引用) . 成员变量来引用对象的成员变量。

person.age

使用对象(引用) . 方法(参数列表)来调用对象的方法。

1. setAge(23)

类中就是://静态的数据 //动态的行为