JavaSE基础总结复习之面向对象の知识总结

Java语言的基础特点

面向对象

类和对象

类

类的构造

一，发现类

二，发现类的共有属性（成员变量）

三，定义类的成员方法（行为，动词）

四，使用类创建对象

对象

什么是对象

如何创建对象

类和对象的关系

构造方法

特点

作用

对象与引用

值传递：

引用传递：

关键字

this关键字

static关键字

static--静态

static修饰属性

static修饰内容

static修饰成员的方法

代码块

实例块:

静态块:

类什么时候会被加载?

包

问题:

包的功能:

注意:

包的命名规范:

访问权限

public

protected

(default)

private

补充变量的分类：

按照位置分类：

成员变量

局部变量

面向对象语言的三大特征

封装

一般意义上的封装：

面向对象语言中的封装：

封装案例1：将属性设置为私有权限

编辑

封装案例2：将类中的方法私有化

java设计模式：

单例模式：

继承

优点

继承的语法

方法的重写

方法重写的规则

super关键字

@Override

继承中的构造方法

抽象类

抽象方法

什么时候需要定义抽象的方法：

抽象类的特点

多态

向下转型：

instanceof关键字

final关键字

接口

接口的定义

implements关键字

注意

Java语言的基础特点

简单易学（语法简单，上手容易）；
面向对象（封装，继承，多态）；
平台无关性（ Java 虚拟机实现平台无关性）；
支持多线程（ C++ 语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而 Java 语言却提供了多线程支持）；
可靠性（具备异常处理和自动内存管理机制）；
安全性（Java 语言本身的设计就提供了多重安全防护机制如访问权限修饰符、限制程序直接访问操作系统资源）；
高效性（通过 Just In Time 编译器等技术的优化，Java 语言的运行效率还是非常不错的）；
支持网络编程并且很方便；
编译与解释并存;

面向对象

关注的焦点是类：在计算机程序设计过程中，参照现实中的事物，将事物的属性特征，行为特征抽象出来，用类来表示。

代码结构：以类为组织单位。每种事物都具备自己的属性和行为/功能。

面向对象程序设计时，从宏观上分析程序有哪些功能。

然后对功能进行分类，把不同的功能封装在不同的类中（造汽车，发动机·······）。

是一种宏观设计，适合解决复杂的问题，代码扩展性强，可维护性高。

类和对象

类

具有相同特征（同一类）事务的抽象描述，例如：人类，树类，公务员类，语言类，是抽象的概念

现根据客观的事务进行抽象（设计为程序），然后由抽象创造出具体，最终使用的是具体

类的构造

一，发现类

总结的过程就是抽象化的过程。

例如：古希腊哲学家柏拉图把人定义为：没有羽毛的两脚直立的动物，其中：”没有羽毛“，”两脚独立“都是特征，都能归类为人类，当然在现在看来这样的定义是片面的。

类的声明格式为：

[访问权限修饰符][修饰符]class Cat{

}

//例如：public class Cat{}

访问修饰符有两种public，无（默认）

修饰符：final，abstract

关键字class用来定义一个类

Java类名的命名规范

类名首字母大写，见名知意。

二，发现类的共有属性（成员变量）

三，定义类的成员方法（行为，动词）

四，使用类创建对象

对象

实际存在的该类事物的每个个体，是具体的，因而也称为实例，例如：小明，苹果，魅族20

什么是对象

对象是类的实例，是以类为模板，在内存中创建出的是个实际存在（对象）

如何创建对象

使用new关键字，例如：Cat（）-----类的构造方法

Cat miao = new Cat（）；

new Cat（）使用new创建对象，然后调用Car类的构造方法初始化对象=，将右边创建的对象的地址赋值给左边miao变量

这个miao就相当于创建出的变量，可以表示这个对象，可以使用这个miao进行属性操作

例如：miao.name = "咪咪";

类和对象的关系

在Java编程语言中，类和对象是紧密相关的概念。类是对具有相同属性和行为的一组对象进行抽象和封装的模板。类定义了对象的属性和行为，并提供了一种创建对象的方式。

对象是根据类定义的模板创建的实体，它具有类定义的属性和行为。对象是类的实例化，每个对象都是独立的，可以具有不同的属性值。

类在Java中通过关键字class来定义，而对象通过关键字new创建。

构造方法

特点

构造方法的名称必须与类名完全相同。

构造方法没有返回类型，包括void。

构造方法可以重载，即一个类可以有多个构造方法，只要它们的参数列表不同即可。

作用

初始化对象的属性，让对象在创建后就具有合适的初始值。

在对象创建过程中执行一些必要的操作。

对象与引用

Java中进行方法调用中传递参数时，参数传递有两种：

值传递：

(形参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

引用传递：

(形参数类型是引用数据类型参数)：也称为传地址。

方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。

基本类型传递的是该数据值本身。

引用类型传递的是对对象的引用，而不是对象本身。

但是无论是值传递还是引用传递,其本质都是传值,所以也都统称值传递

关键字

this关键字

this在类中用来表示当前正在访问的对象,this.成员变量名--显示的访问当前对象的成员变量

常常用来区分同名的成员变量和局部变量

static关键字

static--静态

可以用来修饰类的成员变量,成员方法

static修饰属性

特点为静态成员变量也称为类变量,在内存中只有一份,所有成员共享

一般情况下,将类中所有对象都相同的属性设置为静态的

static修饰内容

随着类的加载而加载,类只要被加载了就可以直接通过类名访问

static修饰成员的方法

被称为静态方法,类方法,可以直接使用类名调用

静态的方法中,只能使用静态的成员变量,因为他们都是随着类的加载而加载的

非静态的方法可以使用静态的成员变量

静态的方法中不能使用this关键字,也不能用super关键字

代码块

类似于一个没有名称的方法体(代码块)

分为实例块和静态块

实例块:

每次创建对象时自动执行

{

实例代码块内容

}

静态块:

在类被加载时自动执行

static{

静态代码块内容

}

类什么时候会被加载?

1,在运行类中的main方法

2,访问类中的静态成员变量和静态成员方法

3,创建类的对象时先加载类

包

问题:

项目越写越大,用到的类越来越多,会出现同名类,如何按照不同的功能管理类

java中使用包机制来管理类,

包的功能:

1,按照不同的功能来管理类

2.避免类重名

3,控制访问权限

注意:

当在一个类中,使用了另一个包中的类,使用前必须使用import关键字导入,使用本包中的类,以及java.lang包中的类不需要导入

java中每一个类都会属于一个包,所以使用时是通过类的全地址使用的--称为全类名

包的命名规范:

在包名中，可以使用.号来区分包的级别；包名一般情况下是小写,至少有三级第一级指该项目的类型，如com,org,gov等，第二级指项目所开发或者运行的公司名称，如：oracle,sun,huawei等第三级指项目的名称，如：bcms,oa,erp,cms等第四级指项目模块的名称，如：bean,action,exception等

访问权限

public

公共权限,可以修饰(类,成员变量,成员方法),公共权限修饰的成员可以在任何地方访问

protected

受保护权限,( 可以修饰成员变量,成员方法),在本类中,同包的其他类中可以访问到,可以在不同包的子类中访问

(default)

默认权限,可以修饰(类,成员变量,成员方法),同包的其他类中可以访问到

private

私有权限,可以修饰(可以修饰成员变量,成员方法),在本类中可以访问到

补充变量的分类：

数据类型：基本类型变量：byte short·······等基本数据类型

引用类型变量：类，数组，持有的是对象的引用地址

按照位置分类：

成员变量

定义在类中，可以使用权限修饰衬衫修饰

            在构造方法中进行自动的初始化赋值

            生命周期：

                    静态：随着类的加载二加载，随着类的销毁而销毁

                    非静态：随着对象的创建而创建，随着对象的销毁而销毁

                    储存的位置：

                    非静态：堆

                    静态：方法区

局部变量

定义在方法中，不仅使用修饰符修饰

            必须我们自己初始化

            生命周期：方法调用创建，方法结束销毁

            储存的位置：栈

面向对象语言的三大特征

封装

一般意义上的封装：

例如将重复出现的代码抽取了一个函数，称为代码的封装（包装）

面向对象语言中的封装：

将类的某些信息使用不同的访问权限修饰符==隐藏==在类内部，不允许外部直接访问操作，而是通过该类提供的方法来实现对隐藏信息的操作和访问，方便加入控制语句，控制权就在自己的手上

封装案例1：将属性设置为私有权限

在其他类中不能任意的访问,只能通过类中提供的特殊的方法进行访问

private String name;
private int age;

向外提供一个公共的方法访问，可以在此方法中加入控制语句

//设置名字的方法
public void setName(String name){
  if(name.length()>2&&name.length()<6){
    this.name = name;
  }
}
//获取名字的方法
public String getName(){
  return this.name;
}

在IDEA中可以通过右键方法变量，选择Generate，点击setter或者getter，直接创建一个外部可用的方法

封装案例2：将类中的方法私有化

java设计模式：

解决某种问题的固定方式（算法）

单例模式：

让一个类，在一个程序中只能创建一个对象，将类的构造方法私有化，外界不能随意调用

//将构造方法私有化，在外界不能随意调用
private Window(){
  
}
//向外界提供获得此对象的方法
//创建一个静态的window对象，类在第一次加载后在内存中生成唯一一份window对象
//每次加载时拿到的都是唯一的对象
static Window window = new Window();
public static Window getWindow(){
  return window;
}

public class TestWindow {
    public static void main(String[] args) {
        Window win = Window.setWindow();
        System.out.println(win);
    }
}

可以看到，此例中创建的每个window都的哈希值都相同于Window类中第一次创建的window，可以有效的避免创建多个对象，以达到在一个程序中只创建一个对象的作用

继承

就是将同一事物中共性的属性和行为进行抽取，定义在一个类中（基类）

其他类可以继承基类，就可以拥有基类中的功能，但不能使用基类中私有的内容

继承可以实现代码的复用性，以及可以在子类中扩展子类自己特有的功能，而不影响其他类

只要符合is-a关系（什么是什么关系，比如苹果是水果），就可以使用继承，一个类只能直接继承一个类，而间接的可以继承多个类，称为继承的传递性，例如b继承a，然后c继承b，则c也继承了a

一个类不显示的继承任何类的时候默认继承object类

Object类是java类体系中最大的类，object之上再也没有别的类

优点

提高了代码的复用性

减少了代码的冗余

增强了程序的扩展（在子类中扩展自己的内容）

继承的语法

extends关键字，在创建类的时候在类名后使用extends关键字继承别的类

public class Dog extends Animal{
  //Dog继承Animal的成员变量和成员方法，但是不能直接访问父类私有的内容
}

方法的重写

当父类的方法功能实现不能满足子类需求时，可以对方法进行重写

子类可以对从父类中继承类的方法就进行改造，在程序执行时，子类的方法将覆盖父类的方法，称为方法的重写

方法重写的规则

子类重写的方法必须和父类被重写的方法名称,参数列表相同。
子类重写的方法的返回值类型与父类保存一致。
子类重写的方法使用的访问权限不能小于父类被重写方法的访问权限。注意：① 父类私有方法不能重写 ② 跨包的父类默认权限的方法也不能重写
子类方法抛出的异常不能大于父类被重写方法的异常

super关键字

在Java类中使用super来调用父类中的指定操作：

1，super可用于访问父类中定义的属性

2，super可用于调用父类中定义的成员方法

3，super可用于在子类构造器中调用父类的构造器

注意：

尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员 super的追溯不仅限于直接父类还可以是父类的父类 super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

super调用的是父类的成员，而不是表示一个父类对象

@Override

是java中的一个注解标签，定义在重写的方法上面，表示此方法是从父类重写而来，也可以不用添加，只要重写的方法结构与父类一直，也算正确的重写

建议保留：

1，编译器可以进行语法验证

2，阅读代码时可以明确的知道此方法是重写的

在IDEA中可以通过在子类括号内部的空白中右键空白处选择Generate，点击Override Mathod

这样就可以创建一个Override的重写方法，进行修改即可

继承中的构造方法

1.子类继承父类时，不会继承父类的构造方法。

只能通过“super(形参列表)” 的方式调用父类指定的构造方法。

2.规定super(形参列表)，必须声明在构造器的首行。

3.如果在子类构造器的首行没有显示调用super(形参列表)，则子类此构造器默认调用super()，即调用父类中空参的构造器。

4.这么做是为了保证先对父类成员进行初始化。

抽象类

抽象方法

抽象方法是一种特殊的方法：它只有方法声明，而没有具体的实现

什么时候需要定义抽象的方法：

在一些体系结构的顶端类只需要定义功能而没有必要实现，因为不同子类中的实现都不同，这个时候就可以将这个方法声明为抽象方法

抽象方法必须用abstract关键字进行修饰，有抽象方法的类就叫抽象类，而抽象类也需要用abstract来修饰，抽象类中可能包含抽象方法，所以类也是抽象的

/*
一个类中如果包含抽象方法，那么这个类一定是抽象类
使用abstract修饰的类就是抽象类
*/
public abstract class Animal(){
  //抽象方法，没有方法体，使用abstract修饰
  public abstract void eat();
}

抽象类的特点

抽象类不能被创建对象，其他功能与正常的类都相同，可以有成员变量，成员方法，包括构造方法都可以有。

抽象类的主要作用是在上层定义功能，只能用作基类，在子类中进行继承和重写。

继承抽象类的非抽象类必须实现其中所有的抽象方法，而已实现方法的参数，返回值要和抽象类中的方法一样，否则该类也必须声明为抽象类。

多态

同一种事务在不同的时刻表现不同的状态

父类的引用指向子类对象

前提是必须要有继承关系，此时构成多态

两个不同的时间段：

编译期：写代码时类型是Animal（父类类型）

运行期：运行代码时类型是具体的子类类型

多态也称向上转型

Animal dog = new Dog();
  dog.eat();/*在编译时dog调用为Animal类的方法，但在运行时会调用子类
              dog中重写的方法*/
Animal cat = new Cat();

用父类类型表示任意的子类类型对象，利于程序扩展

成员方法：编译看左边，运行看右边

静态成员方法：编译和运行都看左边

成员变量：编译和运行都看左边

向下转型：

将父类类型向下强制转为子类类型

Animal dog = new Dog();//此时编译调用子类的方法会报错
Dog d = (Dog)dog;//此时d就可以在编译中使用子类Dog中的方法
d.eat();

instanceof关键字

作用是：测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

左边是对象，右边是类，当对象是右边类或子类创建的对象时，返回true，否则false

父类类型与指定类型相同返回true，否则返回false

if（animal instanceof Dog){
  Dog dog = (Dog)animal;
  dog.lookhome();
}

final关键字

用于修饰类，方法，参数，属性（成员变量）

final修饰的类，不能被继承，所以不能修饰抽象类，例如java中String类不可被继承

final修饰的类，子类不能重写

final修饰方法的参数，参数值在方法中不能被改变

情况1：在类定义时，值就确定，直接赋值，赋值后值不改变的，建议使用static修饰

final static int a = 10;

情况2：在类定义时值不明确，必须在创建对象后，在构造方法中对其进行赋值，每个对象中拥有一个常量

public class Demo {
    public void test(final int a){
    }
    final int count;
    public Demo(int count){
        this.count = count;
    }
    public static void main(String[] args) {
        Demo f = new Demo(1);
    }
}

常量一般建议全部使用大写字母定义