一、面向对象三大特征
1、封装
- 将同一类事物的特征和功能包装在一起,只对外暴露需要调用的接口而已。想让你看到的你就看得到,不想让你看到的就见不到。对于封装也称为信息的隐藏,体现的最淋漓尽致的地方就是来定义接口了,在接口中我们没有任何功能的实现,只是定义了一系列抽象的方法声明。在Java中接口是体现封装最常用的方法
- 优点:便于使用,便于修改,增强代码的可维护性。
2、继承
- 所谓继承是Java中面向对象最显著的一个特征,继承是从已有的类中派生出新的类,新的类可以吸收已有的属性、行为,并扩展新的能力。在Java中不支持多继承,单继承使Java的继承关系很简单,一个类只能有一个父类,这样易于我们的管理,同时父类也是子类的抽象化,而子类反过来就是父类的具体化
3、多态
- 多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口,使用不同的实例而执行不同操作。多态性是对象多种表现形式的体现。
- 多态存在的三个必要条件:继承、重写、父类引用指向子类对象。
二、重写与重载
1.重写
- 重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变,核心重写!
class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
System.out.println("狗可以跑和走");
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal(); // Animal 对象
Animal b = new Dog(); // Dog 对象
a.move();// 执行 Animal 类的方法
b.move();//执行 Dog 类的方法
}
}
输出结果:动物可以移动
狗可以跑和走
class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
System.out.println("狗可以跑和走");
}
public void bark(){
System.out.println("狗可以吠叫");
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal(); // Animal 对象
Animal b = new Dog(); // Dog 对象
a.move();// 执行 Animal 类的方法
b.move();//执行 Dog 类的方法
b.bark();
}
}
输出结果:
TestDog.java:30: cannot find symbol
symbol : method bark()
location: class Animal
b.bark();
^
- 该程序将抛出一个编译错误,因为b的引用类型Animal没有bark方法。可以定义Dog b = new Dog();,这样就可以b.bark();方法了,即
重写规则
- 1、如果不能继承一个类,则不能重写该类的方法。
- 2、父类的成员方法只能被它的子类重写。
- 3、访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类的一个方法被声明为 public,那么在子类中重写该方法就不能声明为 protected。
- 4、子类和父类在同一个包中,那么子类可以重写父类所有方法,除了声明为 private 和 final 的方法。
- 5、子类和父类不在同一个包中,那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
- 6、重写的方法能够抛出任何非强制异常,无论被重写的方法是否抛出异常。但是,重写的方法不能抛出新的强制性异常,或者比被重写方法声明的更广泛的强制性异常,反之则可以
- 7、声明为 final 的方法不能被重写。
- 8、声明为 static 的方法不能被重写,但是能够被再次声明。
class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
super.move(); // 应用super类的方法
System.out.println("狗可以跑和走");
}
}
public class TestDog{
public static void main(String args[]){
Animal b = new Dog(); // Dog 对象
b.move(); //执行 Dog类的方法
}
}
- 上述方法使用了super关键字。当需要在子类中调用父类的被重写方法时,要使用 super 关键字。使用super()关键字的好处就是,在TestDog类中,不用写
Animal a = new Animal(); // Animal 对象 a.move();// 执行 Animal 类的方法
就可以直接输出animal类中的move方法。
2.重载
- 重载(overloading) 是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。
class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(int num){
super.move(); // 应用super类的方法
System.out.println("狗可以跑和走" + num + "步");
}
}
public class TestDog{
public static void main(String args[]){
Dog b = new Dog(); // Dog 对象
b.move(9); //执行 Dog类的方法
}
}
运行结果:动物可以移动
狗可以跑和走9步
三、关键字
1、abstract 声明抽象
- abstract关键字可以修改类或方法。abstract类可以扩展(增加子类),但不能直接实例化。abstract方法不在声明它的类中实现,但必须在某个子类中重写。采用 abstract方法的类本来就是抽象类,并且必须声明为abstract。
2、final 最终、不可改变
- final 关键字可以应用于类,以指示不能扩展该类(不能有子类)。final 关键字可以应用于方法,以指示在子类中不能重写此方法。一个类不能同时是 abstract 又是 final。abstract 意味着必须扩展类,final 意味着不能扩展类。一个方法不能同时是 abstract 又是 final。abstract 意味着必须重写方法,final 意味着不能重写方法。
3、interface 接口
- interface 关键字用来声明新的 Java 接口,接口是方法的集合。接口是 Java 语言的一项强大功能。任何类都可声明它实现一个或多个接口,这意味着它实现了在这些接口中所定义的所有方法。实现了接口的任何类都必须提供在该接口中的所有方法的实现。一个类可以实现多个接口。
4、static
- 一旦使用了static关键字 , 那么这样的内容不再属于对象自己 , 而是属于类 , 所以凡是本类的对象 , 都共享同一份。只能初始化一次,构造一次,之后就不能被外部调用。
- 修饰普通变量时,那也就是在静态区域存储了
- 修饰普通函数,其实就是表明了函数的作用范围,这个函数只能在定义的文件内使用。比如两个人,一个人实现了A文件,一个人实现了B文件,两个文件可能都会实现一些函数,这些函数可能会重名,如果担心别人声明的函数与你声明的函数名一样,又不想让别人使用,就可以使用static修饰。
- 修饰成员变量,所有的对象只保存一个变量,不需要生成对象就可以访问该成员。比如生成A,B,C,D实例,那么其实只保存一个A实例,。
- 修饰成员函数,不需要生成对象就可以访问该函数,不是跟着实例走,而是跟着类去走,不能访问非静态成员。
5、default(即默认,什么也不写):
- 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
6、private :
- 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
7、public :
- 对所有类可见。使用对象:类、接口、变量、方法
8、protected :
- 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)。
四、变量类型
1、局部变量:类的方法中的变量。
public class Variable{
static int allClicks=0; // 类变量
String str="hello world"; // 实例变量
public void method(){
int i =0; // 局部变量
}
}
- (1)在以下实例中age是一个局部变量。定义在pupAge()方法中,它的作用域就限制在这个方法中
package com.runoob.test;
public class Test{
public void pupAge(){
int age = 0;//这里要进行初始化,否则会报错
age = age + 7;
System.out.println("小狗的年龄是: " + age);
}
public static void main(String[] args){
Test test = new Test();
test.pupAge();
}
}
运行结果:小狗的年龄是: 7
- (2)局部变量声明在方法、构造方法或者语句块中;
- (3)局部变量在方法、构造方法、或者语句块被执行的时候创建,当它们执行完成后,变量将会被销毁;
- (4)局部变量是在栈上分配的。
- (5)局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用。
2、实例变量:独立于方法之外的变量,不过没有 static 修饰。。
import java.io.*;
public class Employee{
// 这个实例变量对子类可见
public String name;
// 私有变量,仅在该类可见
private double salary;
//在构造器中对name赋值
public Employee (String empName){
name = empName;
}
//设定salary的值
public void setSalary(double empSal){
salary = empSal;
}
// 打印信息
public void printEmp(){
System.out.println("名字 : " + name );
System.out.println("薪水 : " + salary);
}
public static void main(String[] args){
Employee empOne = new Employee("RUNOOB");
empOne.setSalary(1000.0);
empOne.printEmp();
}
}
运行结果:$ javac Employee.java
$ java Employee
名字 : RUNOOB
薪水 : 1000.0
- (1)实例变量声明在一个类中,但在方法、构造方法和语句块之外;
- (2)当一个对象被实例化之后,每个实例变量的值就跟着确定;
- (3)实例变量在对象创建的时候创建,在对象被销毁的时候销毁;
- (4)实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用类型变量的默认值是null。变量的值可以在声明时指定,也可以在构造方法中指定;
3、类变量:独立于方法之外的变量,用 static 修饰。
import java.io.*;
public class Employee {
//salary是静态的私有变量
private static double salary;
// DEPARTMENT是一个常量
public static final String DEPARTMENT = "开发人员";
public static void main(String[] args){
salary = 10000;
System.out.println(DEPARTMENT+"平均工资:"+salary);
}
}
运行结果:开发人员平均工资:10000.0
总结
本片内容都是由面向对象三大特征引出的一系列问题。