、面向对象基础
- 类与对象
- 封装
- 构造方法
- 方法
- 重载
- 对象数组
- this关键字
- static关键字
1.1类与对象
类：类是抽象的，概念上的，共性的，是对象的模板
对象：个体，具体的，可以看见的，对象是个性的，是该类事物的每个个体，也称为类的实例。
类的组成：
- 方法
- 属性
对象的创建
- 类名 对象名= new 类名（）
对象的引用传递问题
- 注意引用的是对象堆内存的空间
1.2封装
面向对象的特性：封装，继承，多态
封装的概念：使用private实现类的封装，用private关键字修饰属性，修饰方法，private的含义是私有的，使用private修饰的方法和属性不能被外部直接访问。
封装的特性：通过使用封装的属性，要通过get,set方法来获得和设值。
1.3构造方法的问题
构造方法的作用：构造方法的作用主要是用来构造对象并且为对象的属性赋值。构造方法的定义规则：
- 无需任何的放回值类型
- 方法名称必须和类重名
1.4方法
方法的定义
public|private|protected|默认 + static|默认|synchroized|native|abstract+返回值类型|void|空+方法名称（参数）+ throws Exception{ 方法体 }
方法的调用：
- 如果是普通方法，通过对象去调用
- 如果是构造方法，通过实例化去调用
- 如果是静态方法，可以通过类名直接访问
2.4对象数组
以类作为数组的类型，以对象作为数组的元素
Person p[] = new Person[10];//一类作为数组的类型,元素就是对象 for (int j = 0; j < p.length; j++) { Person px = new Person("张三",20+j); p[j] = px; } for (int j = 0; j < p.length; j++) { Person per = p[j]; System.out.println(per.getName()+"===="+per.getAge()); }
2.5方法的重载
在同一个类中，方法的名称相同，返回值的类型相同，但是参数的个数，类型，顺序不同就叫做重载，重载是面向对象多态性的一个体现。
//吃饭 public void eat(){ System.out.println(name + "在吃饭"); } public void eat(int x){ System.out.println(name + "在吃饭，吃了"+ x +"碗。"); }
2.6this的关键字的用法
this关键字可以表示当前对象
this关键字可以表示当前类的属性
this关键字可以表示调用当前类的方法
this关键字调用当前类的构造方法
2.7static关键字
- static变量的声明和使用
- static方法的声明及使用
- static方法块的声明及使用
static变量：使用static修饰的变量就叫做静态变量
static方法：使用static修饰的方法就叫做静态方法
public class OopDemo01 { static int score = 70;//静态变量 double salary = 5000.00;//普通变量 public static void add(){//静态方法 //eat();静态方法中不能调用非静态方法 System.out.println(score); //System.out.println(salary);静态方法不能调用非静态变量 } public void eat(){//普通方法 add();//非静态方法可以调用静态方法 System.out.println(score);//普通方法可以调用静态变量 System.out.println(salary); } public static void main(String[] args) { }
对于静态方法调用的问题
- 静态方法中不能调用非静态方法，静态方法不能调用非静态变量
- 非静态方法可以调用静态方法，普通方法可以调用静态变量
栈：保存属性（变量）名称
堆：保存属性（变量）值
全局数据区： static修饰的变量
全局代码区：static修饰的方法
- 代码块：使用一对{}围起来的就是代码块：
- 普通代码块：写在方法中的语句
- 构造块（实例块）：直接写在类中的语句，优于构造方法先执行，在实例化多个对象的时候，构造块执行多次
- 静态块：直接写在类中，使用static修饰，是优于构造块先执行，在实例化多个对象的时候，静态块只执行一次
面向对象高级部分
- 继承
- 抽象类
- 接口
- 多态
2.1继承
继承的作用：
- 通过继承可以简化子类的定义
- 扩展子类的功能
子类通过extends关键字继承父类
继承的特点：子类可以继承父类一切非私有的属性和方法
继承的规定：
- java只支持单继承，一个类不能同时有多个父类（一个人只有一个父亲一样）
- java支持多层继承，一个类继承自父类，父类也可以自爷爷类
子类的实例化过程：实例化子类对象的时候会先调用父类的构造方法，说明父类也进行了实例化对象操作，实际上调用父类的构造方法构造父类对象就是为子类对象开辟空间，而且可以为父类的属性初始值。
super关键字的使用：父类也称为超类（）
- super关键字可以调用父类的属性（非私有）
- super可以调用父类的方法（非私有）
- super关键字可以调用父类的构造方法（必须放在首行）
方法的复写（）
方法的重写的定义：方法的返回值的类型，方法名称，方法里的参数的个数，顺序，类型一致，就是方法的复写，子类复写父类的方法，调用子类的方法，扩展父类的属性，复写分类的方法子类的访问权限必须要大于等于父类的方法，父类的方法不能为private。
复写和重载的区别：
|
序号 |
重载 |
覆写 |
|
1概念 |
名称相同，参数的个数类型顺序不同 |
方法名称相同，访问权限不小于父类被覆写方法，参数相同，返回值类型相同 |
|
2范围 |
在同一类中 |
在继承关系中，子类覆写父类方法 |
访问修饰符
|
位置 |
private |
默认 |
protected |
public |
|
同类 |
V |
V |
V |
V |
|
同包的类 |
X |
V |
V |
V |
|
不同包的字类 |
X |
X |
V |
V |
|
不同包且不是字类 |
X |
X |
X |
V |
public|private|protected|默认 + static|默认|synchroized|native|abstract+返回值类型|void|空+方法名称（参数）+ throws Exception{ 方法体 }
2.3抽象类
final :在java中final可以修饰变量方法，类
- 使用final修饰的变量就是常量，只能赋值一次，而且常量一般使用大写字母来表示常量名称。
- 使用final修饰的方法不能被子类复写
- 使用final修饰的就是太监类，不能拥有子类
- 抽象类：使用abstract修饰的类就是抽象类
- 抽象方法：使用abstract修饰的方法就是抽象方法
package com.wanczy.oopHightLevelDemo; public abstract class OopDemo003 {//定义就是抽象类 public abstract void eat();//声明抽象方法 }
抽象方法只需要声明不需要实现，有一个抽象方法必须定义为抽象类
抽象类和普通类相比区别：抽象类比普通类多了抽象方法，普通类中的所有定义都可以在抽象类中使用
抽象类的使用规则：
- 抽象类本身不能实例化
- 抽象类中的抽象方法只需要声明，不需要实现
- 含有抽象方法的类必须声明为抽象类
- 抽象类必须要有子类，不然抽象类没有任何意义，抽象类的子类必须要复写抽象类中的全部抽象方法。
- 抽象类中可以有抽象方法
- 抽象类中不可以用final声明
范例：现在有两类员工，一类是技术类，一类是销售类，两种员工的提升工资的方式不一样，技术员工类按照岗位等级提升，销售员工按照上一年度销售业绩来提升工资
package com.wanczy.abstractDemo; public abstract class Employee { private String name; private double salary;//工资 public Employee() { super(); // TODO Auto-generated constructor stub } public Employee(String name, double salary) { super(); this.name = name; this.salary = salary; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } public abstract void updSalary();//提升工资的抽象方法 }
package com.wanczy.abstractDemo; public class TechEmployee extends Employee{ private String post;//岗位等级 @Override public void updSalary() { // TODO Auto-generated method stub double salary = super.getSalary(); if(this.post .equals("高级工程师")){ super.setSalary(salary*1.05); }else if(this.post.equals("中级工程师")){ super.setSalary(salary*1.1); }else if(this.post.equals("初级工程师")){ super.setSalary(salary*1.15); } } public String getPost() { return post; } public void setPost(String post) { this.post = post; } public TechEmployee(String post) { super(); this.post = post; } public TechEmployee() { super(); // TODO Auto-generated constructor stub } public TechEmployee(String name, double salary,String post) { super(name, salary); this.post = post; // TODO Auto-generated constructor stub } }
package com.wanczy.abstractDemo; public class OopDemo01 { public static void main(String[] args) { Employee e = new SaleEmployee("长桑",3000,100); e.updSalary(); System.out.println(e.getSalary()); } }
通过以上程序，我们可以发现，如果以后出现其他的员工类型，提升工资的方式不同，可以编写抽象类的字类完成，不需要更改顶层设计。也就是说抽象类的作用就是在于可以方便程序的扩展。
2.4接口
接口的声明使用interface，接口只有常量和抽象方法；
package com.wanczy.oopDemo; public interface InterfaceDemo01 { //常量 //抽象方法 public abstract void eat(); public abstract void run(); }
如果说一个抽象类只有抽象方法和常量的话，我们就可以使用接口来表示。接口中没有子类的概念，实现类，实现类通过implements实现接口，必须覆写接口中所有的抽象方法。
接口的使用规则：
- 接口中访问权限永远都是public，public可以省列，省列后依然时public
- 接口中的方法都是抽象方法，可以省列abstract，省列后依然是abstract方法
- 接口中的常量可以省列final，省列后依然是常量
- 接口在程序中叫实现，接口必须通过实现类实现，也必须要有实现类，不然接口没有意义
- 接口本身不能实例化
- 接口与接口之间可以继承，一个接口可以同时继承多个父接口，子接口中继承了父接口中所有抽象方法和常量
- 实现类也可以实现多个接口，如果实现的多个接口中，有相同的抽象方法，那么实现类只需要复写一次
抽象类与接口的区别
|
|
抽象类 |
接口 |
|
相似 |
不能直接实例化，抽象类通过子类实例化，接口通过实现类实例化 |
|
|
不同 |
包含抽象方法、一般方法、变量、长流昂、构造方法 |
常量和抽象方法 |
|
抽象类可以实现接口 |
接口不继承抽象类 |
|
|
单继承的局限性 |
多继承多实现 |
|
2.7多态
多态的核心就是子类对象作为父类对象来使用，抽象类的子类对象作为抽象类对象使用，实现类对象作为接口的对象来使用。
3总结
理解抽象类和接口的区别
理解重载和覆写的区别
熟记继承的特点以及规定（super关键字的使用）