面向对象

1、面向对象三个阶段：

【1】面向对象分析OOA – Object Oriented Analysis
对象：张三，李四
抽取出一个类----》人类

类里面有什么：
动词–》动态特性–》方法
名词–》静态特性–》属性

【2】面向对象设计OOD – Object Oriented Design
先有类，再有对象：
类：人类： Person
对象：zhangsan ，lisi，zhuliu
【3】面向对象编程OOP – Object Oriented Programming

2、属性（field 成员变量）

定义该类或对象所具有的特征，作用范围–整个类
格式：

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

3、方法：

用来完成特定功能的代码片段

方法声明格式：

修饰符 返回值类型 方法名(形参列表){
	方法体;
	return 方法返回值;
}

方法返回值类型 :基本数据类型和引用数据类型

方法名：首字母小写，其余遵循驼峰命名

形参列表 :int a等等

实际参数：方法调用的时候传入的具体的值：3

返回值：

方法如果有返回值的话： return+方法返回值，将返回值返回到方法的调用处
方法没有返回值的话：return可以省略不写了，并且方法的返回值类型为：void

对象创建

 第一次加载类的时候，会初始化创建对象，对象的属性没有给赋值，有默认的初始化的值。
 再次创建类对象时，就不会进行类加载了

调用方式：

对象名.方法名(实参列表)

4、变量

变量：在程序运行过程中值可以改变的量。

定义格式

变量类型 变量名 = 变量值;
int x = 1;

5、构造器

构造器可以提供许多特殊的方法，构造器本质是一种方法，负责类中成员变量的初始化。没有参数的是无参构造，带参数的是有参构造。构造器没有返回值类型，没有return语句。

造器格式

无参构造：
[修饰符] 构造器的名字即类名(){
        }
有参构造
[修饰符] 构造器的名字即类名(参数列表){
  this.属性名 = 参数名;
}

构造器的作用：不是为了创建对象，因为在调用构造器之前，这个对象就已经创建好了，并且属性有默认的初始化的值。调用构造器的目的是给属性进行赋值操作的。一般保证空构造器存在，不进行赋值，通常是在重载构造器中赋值。使用带参构造器后，如果空构造器没写，系统不会默认分配空构造器。当形参名字和属性名字重名的时，会出现就近原则：直接使用变量名是离的近的那个形参或者局部变量。在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象

6、关键字

特点：JAVA中所有关键字都为小写

this关键字用法：

1)修饰属性：带参构造器

 public Person(int age,String name,double height){
        this.age = age;
        this.name = name;
        this.height = height;
    }

2）修饰方法：在同一类中，方法可以互掉，this可以省略

public void eat(){
	System.out.println("吃饭")
}
public void play(){
        /*this.*/eat();
        System.out.println("上网");
        System.out.println("洗澡");
    }

3）修饰构造器：同一个类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行

//有参构造器
    public Person(int age,String name,double height){
        this(age,name);
        this.height = height;
    }
    public Person(int age,String name){
        this(age);
        this.name = name;
    }
    public Person(int age){
        this.age = age;
    }

super关键字：

在子类的方法中，可以通过 super.属性 super.方法 的方式，显示的去调用父类提供的属性，方法。在通常情况下，super.可以省略不写。但在特殊情况下，当子类和父类的属性或方法重名时，你要想使用父类的属性或方法，只能通过super.属性或方法来调用。

在修饰空参构造器时，构造器里的super()方法通常都是不写的，默认给你分配，如果你写了，那么它的第一行就没有默认分配的super()方法了。在构造器中，super调用父类构造器和this调用子类构造器只能存在一个，两者不能共存，因为super和this修饰的构造器都要放在第一行。

final关键字

1）修饰变量：变量的值不可改变，这时变量也称为字符常量，名字都大写

final int APPLE =10;

2. 修饰引用数据类型：地址值不可改变

 final Dog d = new Dog();
        //d = new Dog(); 地址值不可改变
        //属性可以改变：
        d.age = 10;

3）修饰方法：被修饰的方法不可被重写

4）修饰类：该类不能被继承，一旦一个类被final修饰，那么里面的方法也是final的，final可以省略不写。不能被创建对象，所有的属性，方法都被static修饰

5）发现Math类中的所有的属性，方法都被static修饰，只能通过类名.属性或方法调用。

static关键字用法：

1）static可以修饰属性

package com.demo;
public class Demo {
    int id;
    static int sid;
    public static void main(String[] args) {
        Demo d1 = new Demo();
        d1.id = 10;
        d1.sid = 10;
        Demo d2 = new Demo();
        d2.id = 20;
        d2.sid = 20;
        Demo d3 = new Demo();
        d3.id = 30;
        d3.sid = 30;
        System.out.println(d1.id);
        System.out.println(d2.id);
        System.out.println(d3.id);
        System.out.println("----");
        System.out.println(d1.sid);
        System.out.println(d2.sid);
        System.out.println(d3.sid);
    }
}
结果：
10
20
30
----
30
30
30

内存分析：

首先开辟一个main方法的栈帧（栈的一块内存空间），创建对象前，需要加载类，类在加载的时候会先加载字节码信息和静态域，静态内容先于对象存在，static修饰的sid在静态域中，int类型的成员变量默认初始化值0，静态域中的内容被类中对象共享。

开始创建对象，在堆中开辟一块内存空间0x99，创建完对象后，t1进栈，通过0x99指向堆中的id1地址，开始赋值，id1=10,id2=10。

然后再创建一个对象id2，开辟内存空间0x66，创建完对象，t2进栈，通过0x66指向堆中的id2地址，开始赋值，id1=20,id2=20。

然后再创建一个对象id3，开辟内存空间0x22，创建完对象，t3进栈，通过0x22指向堆中的id3地址，开始赋值，id1=30,id2=30。

static修饰属性的应用场景：某些特定的数据想要在内存中共享，这个情况下，就可以用static修饰的属性。

属性：
静态属性 （类变量）
非静态属性（实例变量）

2）修饰方法

 int id;
    static int sid;
    public void a () {
        System.out.println(id);
        System.out.println(sid);
        System.out.println();
    }
    public static void b(){
        //System.out.println(id);静态方法不能访问非静态属性
        //a();静态方法不能访问非静态方法
        //System.out.println(this.id);在静态方法中不能使用this关键字
        System.out.println(sid);//静态方法可以访问静态属性

    }
   // 静态的方法可以用   对象名.方法名去调用  也可以用 类名.方法名,一般都是用后者

3）修饰代码块

代码块分为：普通块，构造块，静态块，同步块

代码块执行顺序：静态块在类加载的时候就先加载了，优先于对象存在；构造块>普通块。

package com.demo;

public class Demo7 {
    int a;
    static int sa;

    public void b(){
        System.out.println("bbbbbbbbbbb");
        System.out.println("我是方法中的普通块");
    }
    public static void c(){
        System.out.println("静态方法cccccccc");
    }

    {
        System.out.println("我是类中构造块");
    }

    static{
        System.out.println("我是类中静态块");
        //在静态块中只能方法：静态属性，静态方法
        System.out.println("静态方法的静态属性"+sa);
        c();
    }

//空构造器
    public Demo7(){
    }
    //带参构造器
    public Demo7(int a){
        this.a = a;
    }

    public static void main(String[] args) {
        Demo7 d = new Demo7();
        d.b();
    }
}
/**
结果：
我是类中静态块
静态方法的静态属性0
静态方法cccccccc
我是类中构造块
bbbbbbbbbbb
我是方法中的普通块
*/

4）内部类

内部类分为成员内部类（静态和非静态，位置在类中）和局部内部类（方法内，块内，构造器内）

成员内部类

public class TestOuter {
    //非静态的成员内部类：
    public class D{
        int age = 20;
        String name;
        public void method(){
            //5.内部类可以访问外部类的内容
            /*System.out.println(age);
            a();*/
            int age = 30;
            //8.内部类和外部类属性重名的时候，如何进行调用：
            System.out.println(age);//30
            System.out.println(this.age);//20
            System.out.println(TestOuter.this.age);//10
        }
    }
    //静态成员内部类：
    static class E{
        public void method(){
            //6.静态内部类中只能访问外部类中被static修饰的内容
            /*System.out.println(age);
            a();*/
        }
    }
    //属性：
    int age = 10;
    //方法：
    public void a(){
        System.out.println("这是a方法");
        {
            System.out.println("这是一个普通块");
            class B{
            }
        }
        class A{
        }
        //7.外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用
        D d = new D();
        System.out.println(d.name);
        d.method();
    }
    static{
        System.out.println("这是静态块");
    }
    {
        System.out.println("这是构造块");
    }
    //构造器：
    public TestOuter(){
        class C{
        }
    }
    public TestOuter(int age) {
        this.age = age;
    }
}
class Demo{
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建外部类的对象：
        TestOuter to = new TestOuter();
        to.a();
        //9.创建内部类的对象：
        //静态的成员内部类创建对象：
        TestOuter.E e = new TestOuter.E();
        //非静态的成员内部类创建对象：
        //错误：TestOuter.D d = new TestOuter.D();
        TestOuter t = new TestOuter();
        TestOuter.D d = t.new D();
    }
}

局部内部类

public class TestOuter {
    //1.在局部内部类中访问到的变量必须是被final修饰的
    public void method(){
        final int num = 10;
        class A{
            public void a(){
                //num = 20;
                System.out.println(num);
            }
        }
    }
    //2.如果类B在整个项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了
    public Comparable method2(){
        class B implements Comparable{
            @Override
            public int compareTo(Object o) {
                return 100;
            }
        }
        return new B();
    }
    public Comparable method3(){
        //3.匿名内部类
        return new Comparable(){
            @Override
            public int compareTo(Object o) {
                return 200;
            }
        };
    }
    public void teat(){
        Comparable com = new Comparable(){
            @Override
            public int compareTo(Object o) {
                return 200;
            }
        };
        System.out.println(com.compareTo("abc"));
    }
}

7、重写和重载

重写：发生在继承的子类中，子类对父类方法不满意，需要自己定义符合自己的方法。方法名和参数列表相同，方法体不同。

方法名相同，参数列表不同。以下情况都是重载

（1）个数不同
add() add(int num1) add(int num1,int num2)
（2）顺序不同
add(int num1,double num2) add(double num1,int num2)
（3）类型不同
add(int num1) add(double num1)

8、面向对象特征

封装、继承、多态、抽象。

封装：对内部某些数据进行私有化，提供相应方法供对象操作数据，提高了代码的安全性。封装性的设计思想是把该隐藏的隐藏起来，该暴露的暴露出来。

程序设计追求高内聚低耦合，高内聚是类的内部细节自己完成，不允许外界干涉；低耦合是对外暴露少量方法供于使用。

继承：子类 extends 父类，子类对父类的一些属性和方法，对父类不满意的方法可以重写成自己想要的方法。

好处：提高了代码的复用性，可以直接使用父类方法。提高了可扩展性。

父类private修饰的内容，子类也继承过来了。一个父类可以有多个子类。一个子类只能有一个直接父类。
但是可以间接的继承自其它类。

多态：多态就是多种状态，同一个行为，不同的子类表现出来不同的形态。多态是调用同一方法，然后由于对象不同会产生不同的行为。

//父类的引用指向子类对象
Animal an = new Dog();
//转型：
 Pig p = new Pig();
 Animal an = p;//向上转型
 //将Animal转为Pig类型：
 Pig pig = (Pig)an ;//向下转型

多态的应用场合：
（1）父类当做方法的形参，传入具体的子类的对象
（2）父类当做方法的返回值，返回的是具体的子类的对象
（3）接口当做方法的形参，传入具体的实现类的对象
（4）接口当做方法的返回值，返回的是具体的实现类的对象

抽象：将具有相同数据结构和行为的对象抽象成类

使用关键字abstract修饰抽象类和抽象方法，一个方法是抽象的，它所在类也是抽象的。抽象类中的方法未必是抽象方法。一个类继承抽象类，那么这个类也是抽象类，一般子类不用abstract修饰，一般都是重写抽象方法，并且要重写所有的抽象方法。子类如果没有重写父类全部的抽象方法，那么子类也可以变成一个抽象类。

9、权限修饰符

*表示可以访问

	同一类	同一包	子类	所有类
private	*
default	*	*
protected	*	*	*
public	*	*	*	*

10、接口

定义格式：

[访问修饰符]  interface 接口名   [extends  父接口1，父接口2…]  {
         常量定义；       
         方法定义；
}

/*
jdk1.8之前的接口内容
常量：固定修饰符：public static final	可以省略
抽象方法：固定修饰符：public abstract	可以省略
 */
public interface TestInterface01 {
    //常量：
    /*public static final*/ int NUM = 10;
    //抽象方法：
    /*public abstract*/ void a();
}

类和接口的关系： 实现关系——类实现接口
一旦实现一个接口，那么实现类要重写接口中的全部的抽象方法。java只有单继承，实现可以一个也可以多个。
当一个类既有继承又有接口，先写继承 再写实现：

extends 父类 implements 接口1，接口2

/**
jdk1.8之后的接口内容
1.新增非抽象方法：
public default修饰的非抽象方法：
*/
注意1：default修饰符必须要加上，否则出错
注意2：实现类中要是想重写接口中的非抽象方法，那么default修饰符必须不能加，否则出错。
public interface TestInterface {
    public static final int NUM= 10;
    public abstract void a();
    //public default修饰的非抽象方法：
    public default void b(){
        System.out.println("-------TestInterface---b()-----");
    }
}
class Test implements TestInterface{
    public void c(){
        //用一下接口中的b方法：
        b();//可以
        //super.b();不可以
        TestInterface.super.b();//可以
    }
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }
    @Override
    public void b() {
    }
}

/*
静态方法：
注意1：static不可以省略不写
注意2：静态方法不能重写
*/
public interface TestInterface2 {
    public static final int NUM = 10;
    public abstract  void a();
    //public default非抽象方法；
    public default void b(){
        System.out.println("-----TestInterface2---b");
    }
    //静态方法：
    public static void c(){
        System.out.println("TestInterface2中的静态方法");
    }
}
class Demo implements TestInterface2{
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }
    public static void c(){
        System.out.println("Demo中的静态方法");
    }
}
class A {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Demo d = new Demo();
        d.c();
        Demo.c();
        TestInterface2.c();
    }
}

为什么要在接口中加入非抽象方法?

接口中只定义抽象方法的话，如果接口的内容修改的话，会导致实现类也随之变化，不利于代码扩展维护，加入非抽象方法，对实现类没有影响，想调用就去调用即可。