面向对象编程（OOP）

属性+方法=类
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象来分析整个系统。但是，具体到微观操作，让然需要面向过程的思路去处理。
面向对象本质就是：以类的方式组织代码，以对象的组织（封装）数据。
从认识论角度考虑是先有对象后有类
三大特性：封装，继承，多态。抽象。

回顾方法的定义以及调用

//main方法
public static void main(String[] args){}
/*
修饰符 返回值类型 方法名(...){
	//方法体
	return 返回值;
}
*/
public String sayHello(){
    return "hello world";
}
public void print(){
    return;
}
public int max(int a,int b){
    return a>b ?a:b;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

静态方法：

public static void say(){
    system.out.print("1111");
}//可直接通过方法名调用，和类一起加载。
非静态方法
public void say(){
    System.out.print("1111");
}


//调用
Student student = new Student();//实例化这个类new，对象类型 对象名=对象值;
student.say();
1
2
3
4
5
6
7
8
9
10
11
12

形参

public static int add(int a,int b){//int a,int b,形参
	return a+b;    
}
1
2
3

实参

public static void main(String[] args){
    int add = Demo03.add(1,3);//1,3:实参
    System.out.println(add);
}
1
2
3
4

值传递

//值传递
public class Demo04{
   public static void main(String[] args){
       int a=1;
       System.out.println(a);
       
       Demo04.change(a);
       System.out.println(a);
   }
    
1
2
3
4
5
6
7
8
9
10

//返回值为空
1

    public static void change(int a){
        a=10;
    }
}
1
2
3
4

a=10，返回值为空，a的值还为1。

引用传递
//引用传递：对象，本质还是值传递

public class Demo05{
    public static void main(String[] args){
        Person person = new Person();
        
        System.out.println(person.name);//null
        
        Demo05.change(person);
        
        System.out.println(person,name);//test
    }
    public static void change(Person person){
        //person是一个对象：指向的--->Person person=new Person();这是一个具体的人，可以改变属性
        person.name = "test";
    };
}

```java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

基本类型作为参数传递时，是传递值的拷贝，无论你怎么改变这个拷贝，原值是不会改变的
对象作为参数传递时，是对象在内存中的地址拷贝一份给了参数
break：跳出switch循环，结束循环。continue：结束依次循环。return：方法结束，返回类型和返回值相同。

方法名：见名知意，驼峰命名法。参数列表：（参数类型，参数名），…可变参数，数组运用可变参数。

内存分析

构造器（类似于c++构造函数）

第一个必须和类的名字相同，第二个必须没有返回类型，不能写外不能写void，有默认构造器。

• 必须和类的名字相同
• 必须没有返回类型

作用

1. 实例化对象。
2. 使用ｎｅｗ关键字，本质调用构造器。
3. 用来初始化值。
4. //alt+insert自动生成无参。

注意

定义有参构造函数之后，如果想使用无参构造，要显示的定义一个无参的构造。
快捷键alt+insert

封装

（目的）让用户更好操作电视机

只需要了解遥控器。不需要了解内部构造。

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

方法（细节）

1. 只可以直接调用共有的属性。私有属性要用get/set方法（函数）。

2.实例

 public String getName() {//获取值,输出值
        return name;
    }

    public void setName(String name) {//set-》设值，赋值
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
     //   return sex;
        System.out.println("性别为"+sex);
          return sex;

    }

    public void setSex(char sex) {//性别
        if(sex!='x'&&sex!='o')//
        {
            System.out.println("请重新输入");
        }else
        this.sex = sex;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

get/set意义

创建get/set快捷键alt+insert

继承

目的

相当于套用父类模板的套用。方便

实例

方法
public class 子类 extend（继承关键字） 父类
细节：
1.ctrl +h 快捷键可以查看调用关系。
2.任何类都会继承Object类。
3.java只有单继承，不可以有多继承。（一个儿子只有一个爸爸，一个爸爸可以有很多儿子。）
4.但可以间接继承，爸爸的爸爸。

Super

目的

：调用父类的东西，与子类区分开来。

实例

调用有参函方法
调用无参方法

关于super构造器

注意点：

1.super调用父类的构造方法，必须在构造方法的第一个
2,super必须只能出现在子类的方法或者构造方法中！
3.super和this不能同时调用构造方法！

Vs this: 代表的对象不同：
this:本身调用者这个对象
super: 代表父类对象的应用 前提 this:继承也可以使用
super:只能在继承条件才可以使用 构造方法 this();
本类的构造 译 super()：
父类的构造！

方法重写

重写跟非静态无关

即b是A new出来的对象，因此调用了A的方法。
因为静态方法是类的方法，而非静态是对象的方法。
有static时，b调用了B类的方法，因为b是用b类定义的。
没有static时，b调用的是对象的方法，而b是用A类new的。

总结

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

1. 方法名必须相同
2. 参数列表列表必须相同否则就重载了
3. 修饰符：范围可以扩大但不能缩小public>Protected>Default>private
4. 抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException->Exception(大)
5. 重写，子类的方法和父类必要一致：方法体不同！

意义：父类的功能，子类不一定需要。
alt+insert +override

多态

即同一方法可以根据发送对象的不同而采用不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用可以有很多
多态存在条件,有继承关系
子类重写父类的方法.父类引用指向子类对象

注意点

多态是方法的多态，没有属性的多态

父类和子类，有联系 类型转换溢出：ClassCastException

存在条件：继承关系，方法需要重写，父类引用指向了子类对象

instanceof和类型转换

instanceof引用类型比较，判断一个对象是什么类型
、类型转换
父类引用指向子类的对象
把子类转换为父类，向上转型，会丢失自己原来的一些方法
把父类转换为子类，向下转型，强制转换，才调用子类方法
方便方法的调用（转型），减少重复的代码，简洁
static
静态变量可以直接用类名访问，也称类变量
静态变量（或方法）对于类，所有对象（实例）共享
静态变量可以直接调用，但是非静态变量不可以直接调用

private static int age;
private double score;
public void run(){	}
public static void go(){	}

public static void main(String[] args){
    Student s1 = new Student();
    System.out.println(Student.age);
    System.out.println(Student.score);
    System.out.println(s1.ahe);
    System.out.println(s1.score);
    go();
    run();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

静态区代码加载类时一起被初始化，最早执行且只执行一次（第一次new）

public class Person{
    {
        System.out.println("匿名代码块");
    }
    static {
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("构造方法");
    }
    public static void main(String[] args){
        Person person = new Person();
        System.out.println("=====================")
        Person person2 = new Person();
        System.out.println("=====================")
        Person person3 = new Person();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

抽象类（父亲给儿子的人生规划，不是模板）abstract

不常用
（本质是类，只能单继承）
格式
public +abstract+void +类名
加了abstract在父类中可以不实现。等待子类实现，
目的是提供一个约束，而在子类中必须实现。

类’son’必须被声明为抽象的，或者实现抽象方法’dosomething()'in 'action
图标

关系

抽象类不能new，只能靠子类去实现，就像父亲（父类抽象类）给儿子的人生规划（抽象类）），靠子类去实现。而父亲又有许多可以复制的模板（正常的方法），但抽象方法只能在抽象类中。在抽象类中没有实现。

接口（为了提供多继承）只有规则 interface implements

重点
//接口中的所有定义是是抽象的，只有定义，没有方法。

例子

第一步
类改为接口
class改为interface、

package 面向对象编程.接口;
//  class改为interface、
public interface   mian {
   //接口里面的方法都是默认抽象的
   public void run(int n);

    // public abstract
}
1
2
3
4
5
6
7
8

接口里面不可以写具体方法。（相当于只写函数名 ）

图标

在后缀为impl文件名中写具体实现类。
第二步
兴建class文件
在类名后加implements +继承的接口

package 面向对象编程.接口;
//实现了接口的类，就需要重写接口中的方法
//java是单继承的，可以利用接口实现多继承，但接口只有定义
public class mainrunImpl implements mian ,timeService {//标准命名方法
                                  //可以继承多个类（抽象的）
    @Override
    public void run(int n) {
    }

    //count +i(实现接口中的类)
    @Override
    public void timer() {
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

其他
public static final
//在里面可以定义的属性是常量（一般不会有人在接口里面定义常量）
//public static int age=99;

总结

加强版抽象类
可以继承多个抽象类的东西叫接口，里面只写方法名（函数名），重写方法在另外一个类（implements）
是一个约束
定义一些方法，让别人实现
public abstract方法
常量 public static final
接口不是类，没有构造方法，不能被实例化。

异常 try catch finally throw throws

概览

Error异常致命，不可避免，exception可以避免。

逮bag

1. 通常这样会报错。

```java
public class exception {
    public static void main(String[] args) {
        int a = 0;
        int b = 4;
        System.out.println(b / a);
1
2
3
4
5
6
7

会报错

已知错误型（精准捕获）

然后在预计出错语句前后套上。
try{在预计出错语句}chatch{} 次过程为必要过程。
假设想要加入善后语句。
try{在预计出错语句}chatch{} finally{}

当然catch后面亦可以用其他捕获类型，只要存在包括关系。

层层递进型

捕获异常要从小到大的

   try{//try catch 是必要的结构
            System.out.println(b / a);
        }catch (ArithmeticException e) {//捕获异常要从小到大的
            System.out.println("分母不冷为0");
        }catch(Throwable  t){
            System.out.println("finally");
        }
1
2
3
4
5
6
7

快捷方式

** System.out.println(b / a);//选中 ctrl+alt+t**

try
{
            System.out.println(b / a);//选中 ctrl+alt+t
    }catch(Exception e)
{
    e.printStackTrace();//打印错误站信息
}finally {

}
1
2
3
4
5
6
7
8
9

主动抛出异常

一般在方法中使用

throw

       if (a == 0)
        {
            throw new ArithmeticException();// 主动抛出异常

    }

1
2
3
4
5
6

throws

try
    {
        new plan().plan(0,4);
    }catch(ArithmeticException r)
    {
        r.printStackTrace();
    }
}
public void plan(int a,int b)throws ArithmeticException{
    if (a == 0)
    {
        throw new ArithmeticException();// 主动抛出异常

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15