java——面对对象

软件出现的目的：
*用计算机的语言来描述世界
*用计算机解决现实世界的问题

面向对象的思想 描述 面向对象的世界

面向对象设计和开发程序的好处：
*交流更加流畅
*提高设计和开发效率

构造方法：
构造方法是用来描述对象创建的过程，构造方法在对象创建的过程中被调用

语法：
访问修饰符 构造方法名(){
//初始化代码
}
注意：构造方法名必须和类名相同；没有返回值；

方法重载：
*方法名相同
*参数项不同
*与返回值和访问修饰符无关

this关键字用法：

调用属性：
this.属性名=100；

调用方法：
this.方法名();

调用构造方法：
this();
this(参数);
如何使用：必须是构造方法中的一条语句

 

面向对象的三大特征之一—封装

封装的概念：
封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息
的操作和访问；

封装的好处:
*隐藏类的实现细节
*只能通过规定方法访问数据
*方便加入控制语句
*方便修改实现

封装的步骤：
1.修改属性的可见性
2.创建getter和setter方法
3.在getter\setter方法中加入属性控制语句

 

static修饰符：
static的资源属于类级别的资源，静态资源，对于类的所有实例对象共享
static关键字可以用来修饰属性，方法，代码块和内部类
static修饰符的资源，在类加载期间执行

1、static修饰的属性：
static关键字修饰的属性，属于对类所有实例对象共享的变量
访问静态的属性：类名.属性名

2、static修饰方法：
static关键字修饰的方法，属于静态方法，可以直接类名.方法名()进行调用.一般
的是静态方法作为工具方法
静态方法中不能调用对象的资源（对象的属性和方法）

3、static修饰的代码块
在类加载的时候执行，因为类只加载一次，所以static的代码块也只运行一次，
一般是使用static代码块来加载一些静态资源，比如说配置文件；
{
这里就是代码块，和构造方法一样，在对象创建时候执行
}
static{
这里就是静态代码块
}

 

Static和非Static的区别
1.属性
2.方法
3.调用方法
4.归属
static全部属于类
非static属于实例和对象

 

继承：
一、继承的前提条件：
子类和父类之间，必须要满足子类is a父类的逻辑关系，才能继承

二、继承的优点
1.提高代码之间的重用性，（继承之后子类共用父类的代码）
2.提高了代码后期的可维护性（后期代码中需要添加或删除某些代码，只需修改父类代码即可）

三、继承的步骤：
1.将多个类中共有的属性和方法提取出来，建立一个父类
2.在子类后面使用extends关键字完成继承， 子类 extends 父类
3.在子类中可以调用父类的代码
注意：在java中属于单继承，在extends关键字后面只能有一个父类

 

子类访问父类成员：

访问父类构造方法：
super();
super(参数)；

访问父类属性：
super.属性名；

访问父类方法：
super.方法名();

注意：this和super都必须出现在第一行，他们之间是互斥的

 

子类不能继承父类的那些资源：
1.private成员
2.子类与父类不在同包，使用默认访问权限的成员
3.构造方法

访问修饰符：
1.private 私有的
2.默认的（friendly） 默认
3.protected 受保护的
4.public 公共的

 

多重继承关系的初始化顺序是怎样的：
1.父类属性
2.父类构造方法
3.子类属性
4.子类构造方法

对象初始化过程：
第一步：在创建类之前，检查类是否已加载（检查硬盘上的.class的文件是否加载到内存中）
如果没有加载就先加载父类的文件，再加载本类的文件
java使用的策略称为：懒惰式加载（按需加载）用到的时候加载，只加载一次。
第二部：分配对象空间，递归分配所有父类的属性空间，
属性会自动的初始化为"0"值；
第三步：属性赋值
第四步：调用父类的构造方法（默认调用父类的无参构造方法）
第五步：调用本类的构造方法

方法重写：
*方法名相同
*参数列表相同
*返回类型相同或是其子类
*子类访问权限大于或等于父类

 

super关键字访问父类的成员：
super只能出现在子类的方法和构造方法中
super调用构造方法时，只能是第一句
super不能访问父类的private成员

 

abstract关键字:
abstract是抽象的意思，可以修饰类和方法，修饰类我们称之为抽象类，修饰方法我们称之为抽象方法
1.abstract 修饰类，抽象类
public abstract class 类名(){}
抽象类用来表示一些抽象的概念

抽象类特点：
*抽象类不能被实例化
*抽象类可以有属性、方法、构造方法，都是用来给子类继承
*抽象类中不一定都是抽象方法。

2.abstract 修饰方法，抽象方法
访问修饰符 abstract 返回值类型 方法名(参数列表)；
抽象方法不需要自己实现，由子类来实现

抽象方法特点：
*抽象方法没有方法体
*抽象方法必须出现在抽象类中
*一个类继承抽象类之后必须要实现父类所有的抽象方法

3.抽象类可以继承抽象类

 

final关键字，表示最终的
1.final可以用来修饰类、方法和属性。
2.final修饰的类的不能再被继承。比如：String String是final修饰的类，不能被继承

3.final修饰的方法，不能再被子类重写

4.final修饰的变量初始化以后不能再发生改变
常量规范定义：public static final int ace=12;
final修饰的引用数据类型，引用地址不能发生改变，但是只限定第一层，引用类型的属性值是可以改变的

 

多态：
生活中：
同一种事物，由于条件不同，产生的结果不同。

程序中：
同一种引用类型，使用不同的实例而执行不同的操

实现多态的两个要素：
1.子类重写父类方法
2.使用父类的类型

子类到父类的转换（向上转型）：
Pet pet=new Dog();

实现多态的两种形式：
*使用父类作为方法形参实现多态
*使用父类作为方法返回值实现多态

父类到子类的转换（向下转型）
强制类型转换
前提是：已经向上转型
称为：还原行为
语法：
子类名 子类自命名=（子类名） 父类名；
Dog dog = (Dog) pet;

instanceof运算符：
判断对象是否是属于类和接口，返回boolean类型
对象 instanceof 类或接口软件出现的目的：

*用计算机的语言来描述世界

*用计算机解决现实世界的问题

 

面向对象的思想   描述  面向对象的世界

 

面向对象设计和开发程序的好处：

*交流更加流畅

*提高射击和开发效率

 

构造方法：

构造方法是用来描述对象创建的过程，构造方法在对象创建的过程中被调用

 

语法：

    访问修饰符 构造方法名(){

      //初始化代码

}

注意：构造方法名必须和类名相同；没有返回值；

 

  

方法重载：

*方法名相同

*参数项不同

*与返回值和访问修饰符无关

 

 

this关键字用法：

 

调用属性：

this.属性名=100；

 

调用方法：

 this.方法名();

 

调用构造方法：

this();

this(参数);

如何使用：必须是构造方法中的一条语句

 

 

 

面向对象的三大特征之一—封装

 

   封装的概念：

   封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息

的操作和访问；

 

  封装的好处:

  *隐藏类的实现细节

  *只能通过规定方法访问数据

  *方便加入控制语句

  *方便修改实现

 

  封装的步骤：

    1.修改属性的可见性

    2.创建getter和setter方法

    3.在getter\setter方法中加入属性控制语句

 

 

 

static修饰符：

static的资源属于类级别的资源，静态资源，对于类的所有实例对象共享

static关键字可以用来修饰属性，方法，代码块和内部类

static修饰符的资源，在类加载期间执行

 

1、static修饰的属性： 

static关键字修饰的属性，属于对类所有实例对象共享的变量

访问静态的属性：类名.属性名 

 

2、static修饰方法：

static关键字修饰的方法，属于静态方法，可以直接类名.方法名()进行调用.一般

的是静态方法作为工具方法

静态方法中不能调用对象的资源（对象的属性和方法）

 

3、static修饰的代码块

在类加载的时候执行，因为类只加载一次，所以static的代码块也只运行一次，

一般是使用static代码块来加载一些静态资源，比如说配置文件；

{

这里就是代码块，和构造方法一样，在对象创建时候执行

} 

static{

这里就是静态代码块

}

 

 

 

Static和非Static的区别

1.属性

2.方法

3.调用方法

4.归属

static全部属于类

非static属于实例和对象

 

 

 

继承：

一、继承的前提条件：

子类和父类之间，必须要满足子类is a父类的逻辑关系，才能继承

 

二、继承的优点

1.提高代码之间的重用性，（继承之后子类共用父类的代码）

 2.提高了代码后期的可维护性（后期代码中需要添加或删除某些代码，只需修改父类代码即可）

 

三、继承的步骤：

1.将多个类中共有的属性和方法提取出来，建立一个父类

2.在子类后面使用extends关键字完成继承，   子类 extends  父类

3.在子类中可以调用父类的代码

注意：在java中属于单继承，在extends关键字后面只能有一个父类

 

 

 

子类访问父类成员：

 

访问父类构造方法：

super();

super(参数)；

 

访问父类属性：

super.属性名；

 

访问父类方法：

super.方法名();

 

注意：this和super都必须出现在第一行，他们之间是互斥的

 

 

 

子类不能继承父类的那些资源：

1.private成员

2.子类与父类不在同包，使用默认访问权限的成员

3.构造方法

 

 

访问修饰符：

1.private             私有的

2.默认的（friendly）  默认

3.protected           受保护的

4.public              公共的

 

 

 

多重继承关系的初始化顺序是怎样的：

1.父类属性

2.父类构造方法

3.子类属性

4.子类构造方法

 

 

对象初始化过程：

第一步：在创建类之前，检查类是否已加载（检查硬盘上的.class的文件是否加载到内存中）

如果没有加载就先加载父类的文件，再加载本类的文件

java使用的策略称为：懒惰式加载（按需加载）用到的时候加载，只加载一次。

第二部：分配对象空间，递归分配所有父类的属性空间，

属性会自动的初始化为"0"值；

第三步：属性赋值

第四步：调用父类的构造方法（默认调用父类的无参构造方法）

第五步：调用本类的构造方法

 

 

方法重写：

*方法名相同

*参数列表相同

*返回类型相同或是其子类

*子类访问权限大于或等于父类

 

 

 

super关键字访问父类的成员：

super只能出现在子类的方法和构造方法中

super调用构造方法时，只能是第一句

super不能访问父类的private成员

 

 

 

abstract关键字:

abstract是抽象的意思，可以修饰类和方法，修饰类我们称之为抽象类，修饰方法我们称之为抽象方法

1.abstract 修饰类，抽象类

   public abstract class 类名(){}

 抽象类用来表示一些抽象的概念

 

抽象类特点：

 *抽象类不能被实例化

 *抽象类可以有属性、方法、构造方法，都是用来给子类继承

 *抽象类中不一定都是抽象方法。

 

2.abstract 修饰方法，抽象方法

      访问修饰符 abstract 返回值类型 方法名(参数列表)；

   抽象方法不需要自己实现，由子类来实现

   

  抽象方法特点：

    *抽象方法没有方法体

    *抽象方法必须出现在抽象类中

    *一个类继承抽象类之后必须要实现父类所有的抽象方法

 

 3.抽象类可以继承抽象类

 

 

 

final关键字，表示最终的

1.final可以用来修饰类、方法和属性。

2.final修饰的类的不能再被继承。比如：String  String是final修饰的类，不能被继承

 

3.final修饰的方法，不能再被子类重写

 

4.final修饰的变量初始化以后不能再发生改变

常量规范定义：public static final int ace=12;

final修饰的引用数据类型，引用地址不能发生改变，但是只限定第一层，引用类型的属性值是可以改变的

 

 

 

 

多态：

生活中：

同一种事物，由于条件不同，产生的结果不同。

 

程序中：

同一种引用类型，使用不同的实例而执行不同的操

 

实现多态的两个要素：

1.子类重写父类方法

2.使用父类的类型

 

子类到父类的转换（向上转型）：

Pet pet=new Dog();

 

实现多态的两种形式：

*使用父类作为方法形参实现多态

*使用父类作为方法返回值实现多态

 

 

父类到子类的转换（向下转型）

强制类型转换

前提是：已经向上转型

称为：还原行为

语法：

子类名 子类自命名=（子类名） 父类名；

Dog     dog     =  (Dog)  pet;

 

instanceof运算符：

判断对象是否是属于类和接口，返回boolean类型

对象  instanceof 类或接口

软件出现的目的：*用计算机的语言来描述世界*用计算机解决现实世界的问题
面向对象的思想   描述  面向对象的世界
面向对象设计和开发程序的好处：*交流更加流畅*提高射击和开发效率
构造方法：构造方法是用来描述对象创建的过程，构造方法在对象创建的过程中被调用
语法：    访问修饰符 构造方法名(){      //初始化代码}注意：构造方法名必须和类名相同；没有返回值；
  方法重载：*方法名相同*参数项不同*与返回值和访问修饰符无关

this关键字用法：
调用属性：this.属性名=100；
调用方法： this.方法名();
调用构造方法：this();this(参数);如何使用：必须是构造方法中的一条语句


面向对象的三大特征之一—封装    封装的概念：   封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问；
  封装的好处:  *隐藏类的实现细节  *只能通过规定方法访问数据  *方便加入控制语句  *方便修改实现
  封装的步骤：    1.修改属性的可见性    2.创建getter和setter方法    3.在getter\setter方法中加入属性控制语句


static修饰符：static的资源属于类级别的资源，静态资源，对于类的所有实例对象共享static关键字可以用来修饰属性，方法，代码块和内部类static修饰符的资源，在类加载期间执行
1、static修饰的属性： static关键字修饰的属性，属于对类所有实例对象共享的变量访问静态的属性：类名.属性名 
2、static修饰方法：static关键字修饰的方法，属于静态方法，可以直接类名.方法名()进行调用.一般的是静态方法作为工具方法静态方法中不能调用对象的资源（对象的属性和方法）
3、static修饰的代码块在类加载的时候执行，因为类只加载一次，所以static的代码块也只运行一次，一般是使用static代码块来加载一些静态资源，比如说配置文件；{这里就是代码块，和构造方法一样，在对象创建时候执行} static{这里就是静态代码块}


Static和非Static的区别1.属性2.方法3.调用方法4.归属static全部属于类非static属于实例和对象


继承：一、继承的前提条件：子类和父类之间，必须要满足子类is a父类的逻辑关系，才能继承
二、继承的优点1.提高代码之间的重用性，（继承之后子类共用父类的代码） 2.提高了代码后期的可维护性（后期代码中需要添加或删除某些代码，只需修改父类代码即可）
三、继承的步骤：1.将多个类中共有的属性和方法提取出来，建立一个父类2.在子类后面使用extends关键字完成继承，   子类 extends  父类3.在子类中可以调用父类的代码注意：在java中属于单继承，在extends关键字后面只能有一个父类


子类访问父类成员：
访问父类构造方法：super();super(参数)；
访问父类属性：super.属性名；
访问父类方法：super.方法名();
注意：this和super都必须出现在第一行，他们之间是互斥的


子类不能继承父类的那些资源：1.private成员2.子类与父类不在同包，使用默认访问权限的成员3.构造方法

访问修饰符：1.private             私有的2.默认的（friendly）  默认3.protected           受保护的4.public              公共的


多重继承关系的初始化顺序是怎样的：1.父类属性2.父类构造方法3.子类属性4.子类构造方法

对象初始化过程：第一步：在创建类之前，检查类是否已加载（检查硬盘上的.class的文件是否加载到内存中）如果没有加载就先加载父类的文件，再加载本类的文件java使用的策略称为：懒惰式加载（按需加载）用到的时候加载，只加载一次。第二部：分配对象空间，递归分配所有父类的属性空间，属性会自动的初始化为"0"值；第三步：属性赋值第四步：调用父类的构造方法（默认调用父类的无参构造方法）第五步：调用本类的构造方法

方法重写：*方法名相同*参数列表相同*返回类型相同或是其子类*子类访问权限大于或等于父类


super关键字访问父类的成员：super只能出现在子类的方法和构造方法中super调用构造方法时，只能是第一句super不能访问父类的private成员


abstract关键字:abstract是抽象的意思，可以修饰类和方法，修饰类我们称之为抽象类，修饰方法我们称之为抽象方法1.abstract 修饰类，抽象类   public abstract class 类名(){} 抽象类用来表示一些抽象的概念
抽象类特点： *抽象类不能被实例化 *抽象类可以有属性、方法、构造方法，都是用来给子类继承 *抽象类中不一定都是抽象方法。
2.abstract 修饰方法，抽象方法      访问修饰符 abstract 返回值类型 方法名(参数列表)；   抽象方法不需要自己实现，由子类来实现     抽象方法特点：    *抽象方法没有方法体    *抽象方法必须出现在抽象类中    *一个类继承抽象类之后必须要实现父类所有的抽象方法
 3.抽象类可以继承抽象类


final关键字，表示最终的1.final可以用来修饰类、方法和属性。2.final修饰的类的不能再被继承。比如：String  String是final修饰的类，不能被继承
3.final修饰的方法，不能再被子类重写
4.final修饰的变量初始化以后不能再发生改变常量规范定义：public static final int ace=12;final修饰的引用数据类型，引用地址不能发生改变，但是只限定第一层，引用类型的属性值是可以改变的



多态：生活中：同一种事物，由于条件不同，产生的结果不同。
程序中：同一种引用类型，使用不同的实例而执行不同的操
实现多态的两个要素：1.子类重写父类方法2.使用父类的类型
子类到父类的转换（向上转型）：Pet pet=new Dog();
实现多态的两种形式：*使用父类作为方法形参实现多态*使用父类作为方法返回值实现多态

父类到子类的转换（向下转型）强制类型转换前提是：已经向上转型称为：还原行为语法：子类名 子类自命名=（子类名） 父类名；Dog     dog     =  (Dog)  pet;
instanceof运算符：判断对象是否是属于类和接口，返回boolean类型对象  instanceof 类或接口