面向对象:
是相对于面向过程而言的一种编程思想。是基于面向过程的。
面向过程：以过程为主。
面向对象：以结果为主，找对象做事情。
面向对象的思想特点：
A:是一种更符合人们思考习惯的思想。
B:把复杂的给简单化。
C:让我们的角色发生了改变。
举例：
吃饭：
面向过程：自己先去买菜买米，回家洗菜洗米，还得做...，最后吃。
面向对象：去饭店。找个对象(女朋友)。
2:怎么样才算面向对象?
请按照我下面的几个步骤：
A:分析有哪些类。
B:分析类应该有什么。
C:分析类与类之间的关系。
举例：
把大象装进冰箱。
面向过程：
A:开冰箱门
B:把大象装进去
C:关冰箱门
代码体现：
class Test {
public static void main(String[] args){
/*
System.out.println("开冰箱门");
System.out.println("把大象装进去");
System.out.println("把大象装进去");
System.out.println("把大象装进去");
System.out.println("关冰箱门");
*/
//在面向过程中，有些动作要重复执行，定义方法
open();
in();
in();
in();
close();
}
public static void open() {
System.out.println("开冰箱门");
}
public static void in() {
System.out.println("把大象装进去");
}
public static void close(){
System.out.println("关冰箱门");
}
}
面向对象：(UML 统一建模语言+设计模式 设计师)
A:分析有哪些类。
大象类
冰箱类
测试类
B:分析类应该有什么。
大象类
把大象装进去
冰箱类
开冰箱门
关冰箱门
测试类
main方法
C:分析类与类之间的关系。
在测试类中，创建大象和冰箱对象，并调用其功能。
代码体现：
class 大象 {
public void in() {
System.out.println("把大象装进去");
}
}
class 冰箱 {
public void open() {
System.out.println("开冰箱门");
}
public void close(){
System.out.println("关冰箱门");
}
}
class Test {
public static void main(String[] args) {
冰箱 b = new 冰箱();
大象 d = new 大象();
b.open();
d.in();
b.close();
}
}
3:类与对象
Java语言是为了描述现实世界事物的。
现实世界事物又是怎么体现的:
属性：外在特征
行为：具备的功能
把现实世界的事物通过Java语言来体现，而Java语言中最基本的单位是：类。
所以，每一个显示世界的具体事物其实对应的是一个类。
现实世界事物 类
属性 成员变量
行为 成员方法
类：类是很多对象的抽象表现形式。
对象：对象是类的具体表现形式。
学生：类
张三：对象
班长：对象
4:类的组成：
A:成员变量
成员变量和局部变量的区别?
a:类中位置区别
成员变量：类中，方法外。
局部变量：类中，方法声明上，或者方法体中。
b:内存位置区别
成员变量：堆内存。
局部变量：栈内存。
c:生命周期区别
成员变量：随着对象的创建而存在，随着对象的消失而消失。
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。
d:初始化值区别
成员变量：都有默认初始化值。
局部变量：没有默认初始化值。先定义，再赋值，最后使用。
B:构造方法
a:构造方法特点
方法名和类名相同。
没有返回值类型。
没有返回值。
b:构造方法注意实现
如果没给，系统给一个无参构造方法。
如果给了，系统将不给。这个时候要么不用无参构造方法，要么自己给一个无参构造方法。
推荐：无参给出。
特殊事项：
构造方法中可不可以出现return语句?
可以。return;
C:成员方法
和前面的函数一样，只不过一般不建议加static。
5:private关键字和this关键字:
private关键字:权限修饰符。表示私有的意思。可以修饰成员变量和成员方法。
this:表示当前类的引用对象。
应用场景：解决局部变量隐藏成员变量问题。
this的三种用法：
this.成员变量
this(...)
this.成员方法()
对应的：把super也说一下：
super.成员变量
super(...)
super.成员方法()
6:一个标准的学生类
class Student {
//姓名
private String name;
//年龄
private int age;
public Student(){}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name; //return this.name;
}
public void setAge(int age){
this.age = age;
}
public int getAge() {
return age;
}
}
7:如何使用一个标准的学生类呢?
给成员变量赋值的方式：
A:通过构造方法赋值
B:通过setXxx()方法赋值
class StudentTest {
public static void main(String[] args) {
//通过构造方法赋值
Student s1 = new Student("张三",18);
System.out.println(s1.getName()+"---"+s1.getAge());
//通过setXxx()方法赋值
Student s2 = new Student s2.setName("张三");
s2.setAge(20);
System.out.println(s2.getName()+"---"+s2.getAge());
}
}
8:继承
我们在定义一个类的时候，不需要从头开始。可以在某些类的基础上，扩充自己的功能即可。
让我们的类和那个已经存在的类产生一个关系，我就能够具备别人的成员。这个关系：继承。
继承的好处：
A:提高代码的复用性。
B:让类与类之间产生了一个关系，是多态的前提。
继承的弊端：
破坏了耦合性。类之间的关系过强，会导致一个类的改动直接影响其他的类。
继承的特点：
A:Java中类只支持单继承。
B:可以多层继承。
什么时候考虑使用继承?
假设法：is a的关系。
方法重写：
一般是指在子类中出现了和父类一模一样的方法声明，方法体不一样。
注意：
A:父类的私有方法不能被重写。
B:子类重写后的方法的访问权限要大于等于父类方法的访问权限。
C:子类重写后的方法的返回值类型：
基本类型：一致。
引用类型：是父类本身或者父类的子类。
开发中，基本上不会出现注意里面的问题，因为开发中方法声明都是一模一样的。
9:多态
同一个对象，在不同时刻表现出现的不同状态。
举例：水(水，冰，水蒸气)
狗(动物,狗)
从代码的角度来看：编译期状态和运行期状态不一致的现象。
Fu fu = new Fu();
Zi zi = new Zi();
Fu fu = new Zi();
前提：
A:有继承或者实现关系。
B:有方法的重写。
C:父类或者父接口的引用指向子类对象。
class Fu {
public int num = 10;
public void show() {
System.out.println("Fu"+num);
}
}
class Zi extends Fu {
public int num = 10;
public int num2 = 20;
public void show() {
System.out.println("Zi"+num);
System.out.println("Zi"+num2);
}
public void method() {
System.out.println("method");
}
}
测试类：
class Test {
public static void main(String[] args) {
/*
Fu f = new Fu();
System.out.println(f.num);
f.show();
Zi zi = new Zi();
System.out.println(zi.num);
zi.show();
*/
//多态
Fu f = new Zi();
System.out.println(f.num);
//System.out.println(f.num2);
f.show();
//f.method();
}
}
多态中成员的特点：
成员变量：编译和运行都看左边。
成员方法：编译看左边，运行看右边。
为什么?
因为方法有重写，而变量没有。
|
收藏
淘帖
踩
