java中的面向对象总结（java中的面向对象总结法是什么）

类与对象

对象：真实存在唯一的事物。

类：实际就是对某种类型事物的共性属性与行为的抽取，是对对象的抽象。 抽象的概念.... 车

类有属性和方法

如何找适合的对象：

1. sun已经定义好了很多的类，我们只需要认识这些类，我们就可以通过这些类创建对象使用。

2. 自定义类，通过自定义类来创建对象使用。

自定义类创建对象的三步骤：

1. 自定义类。

格式：

class 类名{

事物的公共属性使用成员变量描述。 事物的公共行为使用函数描述。

}

2. 通过自定义类创建对象。

格式：

类名 变量名 = new 类名();

3. 访问(设置)对象的属性或者调用对象的功能。

1.访问对象属性的格式：

对象.属性名.

2.设置对象的属性：

对象.属性名 = 数据。

3. 调用对象的功能

对象.方法名();//不传参

对象.方法名(传递参数)//传参数

调用方法时，参数要与参数列表传递的一一对应

方法的定义

public 返回值类型 方法名（类型 传递类型）{

操作

}

面向对象中，整个程序的基本单位是类，方法是从属于类的

凡是以new为关键字创建的对象，jvm虚拟机都会创建一个新的空间，创建一个对象 new 类名()

构造器

构造方法

1.Constructor

2.名称与类名必须相同

3.作用:初始化对象的信息的，比如说给成员变量赋值，为new服务的

4.如何使用:通过new

5.空构造:始终保持有至少一个构造器

空构造:没有手动的编写其他的构造器，javac编译的时候，自动加入空的构造器

一旦有了自己的构造器，javac不再加入空构造器

6. 普通的成员方法，不是构造器的重载！

public void Phone(){

System.out.println("Phone方法被调用了");

}

7.构造器的重载:只看形参(个数、顺序、类型)

8.不能使用修饰符 final static abstract

(set)设定器和访问器(get)

get(访问器) set(设定器)

1.时机不同

构造器new对象时候调用

设定器 对象已经存在了再调用

2. 次数不同

构造器new调用一次

设定器 对象可以多次调用

3.相互调用：

构造器中可以调用设定器，反之 设定器不能调用构造器

Static关键字

static变量

1.什么是static

static的特点：(它可以修饰成员变量，还可以修饰成员方法)

A:随着类的加载而加载

回想main方法。

B:优先于对象存在

C:被类的所有对象共享,静态的成员变量 共享的！

举例：咱们班级的学生应该共用同一个班级编号。

其实这个特点也是在告诉我们什么时候使用静态?

如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。

举例：

饮水机(用静态修饰)

水杯(不能用静态修饰)

D:可以通过类名调用

其实它本身也可以通过对象名调用。

推荐使用类名调用。

静态修饰的内容一般我们称其为：与类相关的，类成员

static 静态的，先于对象存在的！

2.了解内存分析图

3.static变量和非static变量的一个区别

a.在内存中份数不同

不管有多少个对象，static变量只有一份，对于每个对象，实例变量都会有单独的一份

static变量是属于类的，类变量

非静态的变量是属于对象的，实例变量

b.在内存中的存放的位置不同

静态变量存放在方法区中

实例变量存放在堆内存中

c.访问的方式不同

实例变量:stu1.age=20; 对象名.变量名

静态变量 :stu1.schoolName="哈哈哈";对象名.变量名

Student2.schoolName="呵呵呵";类名.变量名(推荐使用！)

Static代码块

static块

语法：static{}

执行的顺序:第一次加载类的时候，并且执行一次！不管你有多少对象！

作用:加载类的时候给静态的变量初始化用的！

static{}可以有多个，上下执行顺序，不能写方法中，要写到类中！

代码块

语法：{}

执行过程：从上到下，每创建一个对象就执行一次！在对象之前执行！

代码块可以有多个！

作用:作用不大！但是还是有作用的，可以把多个构造中的共同的代码提取，放入！

3.类中的成员

a 成员变量(静态变量&实例变量)

b 成员方法(静态方法&实例方法)

c 构造方法

d 静态代码块

e 代码块

f 内部类

set set toString

继承

继承:继承:子类继承父类的属性和方法，并且有自己独特的属性和方法

关键字 extends 继承

重写：当父类不能满足子类的需求，子类重写父类的方法 条件 方法名相同，参数列表相同 顺序相同

属性不能被重写！

私有方法、静态方法、final方法 不能被重写！

重写前提需要继承！

关键字 @Override

2.继承的好处

重用代码、避免重复、重写方法、新曾方法、提高了效率！

3.Object类 是所有类的祖先，任何一个类都直接或者是间接的继承了Object！

如果一个类没有显示extends任何类，默认的继承Object类！

super :关键字

1.作用:执行当前对象的父类对象，，每一个对象都有一个super属性，我们在创建对象的时候分配空间！

前提:在子类中

2.使用:

a.修饰父类的成员变量:super.color="";

b.修饰父类的成员方法 :super.introduce();

c.修饰父类的构造方法:super(color,age); //必须是第一条语句！

3.注意:

this和super不能同时出现在子类的构造方法中

如果都存在，谁是第二条语句就报错！

Equals

==&equals

==比较栈内存中的值

对于基本类型，比较的是咱们栈内存中的值

对于引用类型，比较的是咱们栈内存中的值(值的真正的含义是：地址)

instanceof 关键字

instanceof关键字的作用：判断一个对象是否属于指定的类别。

instanceof关键字的使用前提：判断的对象与指定的类别必须要存在继承或者实现的关系。

instanceof关键字的使用格式：

对象 instanceof 类别

instanceof关键字的作用： 目前没用。但是后天我们学习 到了多态之后就非常有用。

一般我们做强制类型转换之前都会使用该关键字先判断一把，然后在进行转换的。

equals() 比较对象在堆内存中成员变量的内容

Object的equals()比较的是地址，作用和==相同！

需要重写equals()

为什么要重写？因为你Object的比较已经面目全非了，不在是我们的需求了！变成我们的自己的比较方式！

@Override

public boolean equals(Object obj) {

//类型转换

if(obj==null){

return false;

}

//防御性编程

if(!(obj instanceof Animal)){//判断是否为同一类

return false;

}

Animal other =(Animal)obj;

if(this.color==other.color && this.age==other.age){

return true;

}else{

return false;

封装

封装

1.什么是封装？

开汽车(直接开，不用研究发动机是什么原理！)

a.提高了安全性

b.降低了我们使用的难度

2.权限修饰符

private(私有的) 当前类

default(默认的) 当前包

protected(受保护的)当前包+其他包的子类

public(公共的) 当前项目 、当前包、其他包、所有包

3.权限修饰符来修饰的成员

a .对属性的封装

属性 private int age;

提供:getter(访问器) setter(设定器)

b.对方法的封装

private void introduce(){

System.out.println(name+" "+age+"-----------");

}

可以简介的访问，同一个类可以访问私有的方法，来访问公共的方法来获取私有的方法里的功能！

public void test(){

System.out.println("hahaha");

this.introduce();

}

c.权限对类的修饰

类的修饰只有2种，

public修饰，此时要求类名和文件名必须相同！

默认的，仅限与当前包中使用！

private&protected 不能修饰类！

d.修饰构造器

private Person()：对象不能直接new了 ，不能继续了！

有什么用啊？单例模式！

多态

1.什么是多态

多种形态表现形式

Person p1 =new Chinese();//把子类对象赋给父类的引用变量！然后通过父类引用变量调用子类重写的方法！这时多态出现了！

p1.eat();

2.多态的条件

a.继承

b.方法的重写

c.将子类对象赋给父类的引用变量！

3.多态的好处

a.代码减少了

b.利用代码扩展

4.使用最多的场合就是用父类做方法形参

5.父类是父类

子类是子类

子类是父类

父类不是子类

子类不是其他子类

6.转型

向上转型 Person p1 =new Chinese(); 把子类对象赋给父类的引用变量

向下转型 将父类引用比变量赋给子类引用变量

向上转型:

Person p1 =new Chinese();将子类对象赋给父类的引用变量！

p1.sleep();调用子类继承父类的方法

p1.eat();调用的是子类重写的方法，而不是父类的方法！

p1.SquareDance();不能调用子类特有的方法！

向下转型:

1.必须是强制类型转换

2.不是做手术 必须是一个真实的类型！否者出现(类型转换异常)

Exception in thread "main" java.lang.ClassCastException

3.避免转换异常可以在转换之前进行判断 instanceof

p5 instanceof Chinese

对象 instanceof 类名|接口名 判断是否为同一类

4.instanceof 判断

System.out.println(p5 instanceof Chinese);

System.out.println(p5 instanceof UK);

System.out.println(p5 instanceof Italian);

System.out.println(p5 instanceof Person);

System.out.println(p5 instanceof Object);

Final关键字

final

1.含义:最终的，断子绝孙类，不变的

2.final 使用

a.修饰变量

public static final double PI =3.1415926;

static:可以通过类名直接访问

final :不可变的

b.修饰方法

方法不能被子类重写了！

c.修饰类

不能继续了！

This关键字

this关键字：方法被哪个对象调用，this就代表那个对象

this关键字代表了所属函数的调用者对象。

this:是当前类的对象引用。简单的记，它就代表当前类的一个对象。

注意：谁调用这个方法，在该方法内部的this就代表谁。

this关键字作用：

1. 如果存在同名成员变量与局部变量时，在方法内部默认是访问局部变量的数据，可以通过this关键字指定访问成员变量的数据。

2. 在一个构造函数中可以调用另外一个构造函数初始化对象。

this关键字调用其他的构造函数要注意的事项：

1. this关键字调用其他的构造函数时，this关键字必须要位于构造函数中 的第一个语句。

2. this关键字在构造函数中不能出现相互调用 的情况，因为是一个死循环。

this关键字要注意事项：

1. 存在同名的成员变量与局部变量时，在方法的内部访问的是局部变量(java 采取的是“就近原则”的机制访问的。)

2. 如果在一个方法中访问了一个变量，该变量只存在成员变量的情况下，那么java编译器会在该变量的 前面添加this关键字。

抽象类与接口

abstract使用

语法: 抽象类和抽象方法都是用abstract修饰的！

抽象不能new(实例化)，只能被继承！

抽象类必须有构造器，创建子类的时候需要

抽象类可以有0个|1个|多个抽象方法，

如果类中有抽象的方法，这个必须是抽象类！

抽象方法只能声明，没有实现！

子类必须重写这个抽象的方法！

2.含义

抽象类为所有的子类提供了一个模板，子类必须完成这个抽象类的所有的抽象方法，而且可以进行扩展！

抽象类，可以避免子类设计的随意性

抽象类就是用来当父类的！用来被继承的！

3. abstract的反义词

(final不能有子类，abstract必须有子类)

final 可以修饰变量 、方法、类；不能修饰构造方法

abstract 可以修饰方法和类，不能修饰变量和 构造方法

interface 接口

1.interface

接口中所有的方法都是抽象的！方法都默认采用了public abstract 修饰，可以省略不写

接口中只有常量和抽象的方法，没有变量！

接口中不能有构造方法

接口还不能new(不能实例化)

2.用接口做方法的形参，实参可以是实现了该接口所有的类，可以达到多态的效果

面向接口的开发

把容易发生变量的内容，在设计之初，先设计成接口，再给初不同的实现！

3.抽象类和接口的区别

共同点:

都是抽象的方法

都不能new

都是让子类来继承(extends)或实现 (implements)

区别：

1.成员变量 接口中有的是常量 没有变量

2.成员方法呢: 接口中的方法全部是抽象的方法！抽象类可以有0个|多个抽象方法，抽象方法存在，那这个一定是抽象类，但是抽象类不一定有抽象方法

3.构造器:抽象类是有构造器，接口没有

4.一个类只能继承一个抽象类！但是我们可以实现多个接口！

匿名内部类

匿名内部类(了解)

匿名内部类使用的条件：如果某些类只想使用一次，就没有必须专门写一个类！此时我们使用匿名内部类

2.使用:

show(new Product(){

@Override

public double getPrice() {

return 7888;

}

@Override

public String getName() {

return "iphone8 ";

}

});

3.但是你要看的懂！

4. 匿名内部类访问外部的变量

final double dis =0.2;

JDK 1.8版本之后不在用写final了！

5.作为了解的 java中用的少！

内部类(了解)

1.类的成员

成员变量

成员方法

构造器

静态代码块

代码块

内部类

2.

a.内部类是类的成员，可以受用4个权限修饰符

b.内部乐意的方法直接范文外部类的成员变量和方法

c.外部类不可以直接访问内部的方法，需要实例化

d.可以实现多重继承！但是我们很少使用，而且java中很少使用内部类，一般接口去实现！

异常

什么是异常(exception)

就是在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序

2.try -catch 进行异常的处理执行过程

情况1：try块中代码没有出现异常

不执行catch块代码，执行catch块后边的代码

情况2：try块中代码出现异常，catch中异常类型匹配（相同或者父类）

try块中后续的语句不执行了，执行catch块代码，执行catch块后边的代码

情况3：try块中代码出现异常， catch中异常类型不匹配

try块中后续的语句不执行了， 不执行catch块代码，不执行catch块后边的代码，程序会中断运行

3.catch块中如何处理异常的

//1用户自定义信息

//System.err.println("被除数和除数必须是数字，除数不能是0")

//2使用java提供的异常信息

//System.out.println(e.toString());

//System.out.println(e.getMessage());

//e.printStackTrace();

//3.继续向上抛出这个异常(catch块后面的代码不执行),抛给调用者，调用这需要处理这个异常

throw e;

问:当什么情况下，最后的谢谢你不会执行

System.out.println("感谢使用本程序");

System.out.println("程序结束了");

情况1:catch块中有throw语句

情况2:没有匹配到catch块中的语句

情况3:遇到return的时候(条件)

2.即使以上三种情况都出现了，我希望仍然之后谢谢语句

解决:finally语句 最终的

使用:

关闭数据库链接 conn.close();

关闭IO流 fis.close();

关闭socket链接 socket.close()

是不是所有的情况下finally都会执行呢？

不是，唯一的例外

1.问题: System.err.println("被除数和除数必须是数字，除数不能是0");

描述的不清楚！

解决: 多重catch语句

1、一次和各个catch块进行比较，如果匹配了，执行该catch块的代码，后续的catch块不会继续比较了

2.各个catch块的执行顺序是先子类后父类

1.throws throw

throws 和throw的区别

1.位置不同:throw位于方法体中，throws位于方法声明中

2.内容不同 :throw后面跟着的是一个异常的对象;throws后面跟着的是一个或者是多个异常类;

3.作用不同:throw此处有异常，我负责抛出异常，这里是异常的源头！

throws:该方法中有异常，但是我没有进行处理try-catch，我们负责告诉你，告诉调用者！