面向过程和面向对象都是对软件分析、设计和开发的一种思想,它指导着人们以不同的方式去分析、设计和开发软件。(相辅相成)
- 都是解决问题的思维方式,都是代码组织的方式
- 解决简单问题可以使用面向过程
- 解决复杂问题:宏观上使用面向对象把握,微观处理上仍然是面向过程
面向过程:适合简单任务,不需要过多协作的事务(一步一步完成)
面向对象:适合复杂问题,需要大量合作
对象的发展过程:数据无管理时代——数组管理(企业部门制)——对象(企业项目制)
类:属性(成员变量field)+方法
面向对象的三大特征:继承、封装、多态
继承使用要点;
1、接口可以多继承,类只能单继承(只有一个父类)
2、可以得到父亲的全部属性和方法(除了父亲的构造方法),但不见得可以直接访问(比如,父亲私有的属性和方法)
3、如果定义一个类时,没有调用extends,则它的父类是:java.lang.Object(可以右击点击Diagrams查看类的继承层次结构或者Ctrl+h)
package cn.sxt.oo;
public class TestExtends {
public static void main(String[] args){
Student stu = new Student("高小七","挖掘机");
stu.rest();
stu.study();
Student stu2 = new Student("高小八","计算机");
stu2.study();
System.out.println(stu2 instanceof Person);
}
}
class Person extends Object{
String name;
int height;
public void rest(){
System.out.println("休息一会!");
}
}
class Student extends Person {
String major;
public void study() {
System.out.println("学习Java");
}
public Student(String name, String major) {
this.name = name;
this.major = major;
this.height = height;
}
}
instanceof 用于判断左边的对象是不是从属于右边的类
封装:
- private表示私有,只有自己类能访问
- default表示没有修饰符,只有同一个包的类能访问
- protected表示可以被同一个包的类以及其他包的子类访问
- public表示可以被该项目的所有包中的所有类访问
package cn.sun.oo;
/**
* 测试封装
*
*/
public class TestEncapsulation {
public static void main(String[] args){
Human h = new Human();
h.sayAge();
//h.age = 18;
h.name = "高淇";
h.height = 180;
}
}
class Boy extends Human{
void sayHello(){
System.out.println(name);
}
}
package cn.sun.oo;
public class Human{
private int age;
String name;//可以被本包下面的类访问
protected int height;
public void sayAge(){
System.out.println(age);
}
}
package cn.sxt.oo;
import cn.sun.oo.Human;
public class TestEncapsulation2 {
public static void main(String[] args){
Human h = new Human();
//h.age = 13;
//h.name = "高淇"; //name 为default属性,不能被不同包访问
h.sayAge();
}
}
class Girl extends Human{
void sayGood(){
System.out.println(height);
}
}
封装的使用细节
- 一般使用private访问权限
- 提供相应的get/set方法来访问相关属性,这些方法通常是public修饰的,以提供对属性的赋值与读取操作(注意:boolean变量的get方法是is开头!!!)
- 一些只用于本类的辅助性方法可以用private修饰,希望其他类调用的方法用public修饰
JavaBean的封装(没有复杂关系的简单的类)
属性私有private,属性的方法(提供get/set方法)公开public,没有其他复杂的方法。
package cn.sun.oo;
/**
* 仍然测试封装
*/
public class Person4 {
private int id;
private String name;
private int age;
private boolean man;
public void setName(String name){
this.name = name;
}
public void setAge(int age){
if(age>=1&&age<=130) {
this.age = age;
}else{
System.out.println("请输入正确年龄!!");
}
}
}
package cn.sun.oo;
/**
* 测试封装
*
*/
public class TestEncapsulation {
public static void main(String[] args){
Human h = new Human();
//h.sayAge();
//h.age = 18;
h.name = "高淇";
h.height = 180;
Person4 p4 = new Person4();
//p4.age = 14;
p4.setAge(-10);
}
}
多态的要点
- 多态是方法的多态,不是属性的多态(多态与属性无关)
- 多态存在要有三个必要条件:继承,方法重写,父类引用指向子类对象
- 父类引用指向子类对象后,用该父类引用调用子类重写的方法,此时多态就出现了
package cn.sun.oo;
/*
测试多态
*/
public class TestPolym {
public static void main(String[] args) {
Animal a = new Animal();
animalCry(a);
Dog b = new Dog();
animalCry(b);
Cat c = new Cat();
animalCry(c);
}
static void animalCry(Animal a) {
a.shout();
}
}
class Animal{
public void shout(){
System.out.println("叫了一声");
}
}
class Dog extends Animal{
public void shout(){
System.out.println("汪汪汪");
}
}
class Cat extends Animal{
public void shout(){
System.out.println("喵喵喵");
}
}
对象的转型:
向上转型:子类可以自动转为父类(自动类型转型)
向下转型:父类转为子类(手动强制转型)
package cn.sun.oo;
/*
测试多态
*/
public class TestPolym {
public static void main(String[] args) {
/*Animal a = new Animal();
animalCry(a);
Dog b = new Dog();
animalCry(b);
Cat c = new Cat();
animalCry(c);
*/
Animal d = new Dog();
Animal c = new Cat();
Dog d2 = (Dog)d;
d2.seeDoor();
/* Dog d3 = (Dog)c;
d3.seeDoor();
//猫不能强制转为狗,编译会通过,但运行时会报错
*/
}
static void animalCry(Animal a) {
a.shout();
}
}
class Animal{
public void shout(){
System.out.println("叫了一声");
}
}
class Dog extends Animal{
public void shout(){
System.out.println("汪汪汪");
}
public void seeDoor(){
System.out.println("看门");
}
}
class Cat extends Animal{
public void shout(){
System.out.println("喵喵喵");
}
}