一,需要掌握:
1,会创建类和对象
2.面向对象的三大特征:封装,继承,多态.
3.掌握抽象类和接口的使用
4.掌握程序中的异常处理
5.会使用面向对象思想进行编程
二.开发方法
1.结构化开发(基于c语言)
面向功能划分软件结构
自顶而下
最小的子系统是方法
制约了软件的可维护性和可扩展性
2.面向对象开发
把软件系统看成各种对象的集合
系统结构较稳定
子系统相对独立
软件可重用性,可维护性和可扩展性强
三.类与对象
对象:用来描述客观事物的一个实体,由一组属性和方法构成
类:具有相同属性和方法的一组对象的集合
类是对象的抽象,对象是类的具体
public class person {
//属性(特征):成员变量
public String name;
public int age;
public char sex;
//方法(行为):成员方法
public String showInfo() {
String info = "我叫:"+name+";"+age+"岁;性别"+sex;
return info;
}
}
public class TestPerson {
public static void main(String[] args) {
//创建对象: 类名 对象名 = new 类名();
person p1 = new person();
//使用对象的属性和方法:对象名.属性 对象名.方法()
p1.name = "jack";
p1.age = 18;
p1.sex = '男';
String s1 = p1.showInfo();
System.out.println(s1);
person p2 = new person();
p2.name = "rose";
p2.age = 16;
p2.sex = '女';
String s2 = p2.showInfo();
System.out.println(s2);
}
}
注意
方法定义处,参数叫做形式参数,也叫形参(主要约束参数的类型的)
形参名字可以随便取,但要符合驼峰命名规则,同时要有意义
方法调用处,参数叫做实际参数,也叫实参
实参名字可以随便取,但要符合驼峰命名规则,同时要有意义
实参和形参的类型必须一致,名字可以一致,也可以不一致
方法有没有返回值和方法有没有参数,没有任何关系
方法参数可以有一个,也可以有多个,多个参数之间用逗号隔开
形参和实参数量一定要一致,数据类型一定要一致
四.构造方法与方法重载
当参数传递为基本数据类型时,参数变化不保留,基本数据类型参数传值
当参数传递为引用数据类型时,参数变化保留,引用数据类型参数传址
方法重载:
同一个类中
方法名相同
参数个数或类型不同
与返回值,访问修饰符无关
构造方法:
(1)该方法缺少返回值
(2)该方法名字必须和类名一样
每个类都有一个默认无参构造方法
但是,一旦手工添加了带参构造方法,那么系统默认的无参构造方法就会被覆盖掉,如果想使用,就必须显示的写出来
public class Student {
String name;
int score;
//一个类中允许出现多个同名但不同参数的方法,这种方法叫做重载
//构造方法
//(1)该方法缺少返回值 (2)该方法名字必须和类名一样
//每个类都有一个默认无参构造方法
//但是,一旦手工添加了带参构造方法,那么系统默认的无参构造方法就会被覆盖掉,如果想使用,就必须显示的写出来
//方法重载
public Student() {
}
public Student(String name,int score) {
this.name = name;
this.score = score;
}
public void showInfo() {
System.out.println(name+"的成绩是"+score);
}
}
public class ModifyScore {
public void modifyScore(Student[] stus) {
for(int i=0; i五.封装
1.成员变量与局部变量的区别:
作用域不同:
局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的
初始值不同:
Java会给成员变量一个初始值
Java不会给局部变量赋予初始值
注意:
在同一个方法中,不允许有同名局部变量
在不同方法中,可以有同名局部变量
在同一个类中,成员变量和局部变量同名时,局部变量具有更高的优先级
面向对象三大特征之一 ------封装
2.封装的概念:
将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问
封装的两个大致原则:
把尽可能多的东西藏起来,对外提供便捷的接口
把所有的属性藏起来
3.封装:
1.先将属性私有化
2.为private的属性创建共有的setter/getter方法
3.在getter/setter方法中加入属性控制语句
4.封装的好处:
1.便于使用者正确使用系统,防止错误修改属性
2.有助于系统之间的松耦合,提高系统的独立性
3.提高软件的可重用性
4.降低了构建大型系统的风险
六.继承
1.类的访问修饰
public修饰符:共有访问级别
默认修饰符:包级私有访问级别
image.png
2.static变量
1.类的成员变量包括
类变量(静态变量):
被static修饰的变量
在内存中只有一个拷贝
类内部,可在任何方法内直接访问静态变量
其他类中,可以直接通过类名访问
实例变量:
没有被static修饰的变量
每创建一个实例,就会为实例变量分配一次内存,实例变量可以在内存中有多个拷贝,互不影响
2.static变量的作用:
(1)能被类的所有实例共享,可作为实例之间进行交流的共享数据
(2)如果类的所有实例都包含一个相同的常量属性,可把这个属性定义为静态常量类型,从而节省内存空间
3.static方法:
静态方法:可直接通过类名访问
静态方法中不能使用this和super
不能直接访问所属类的实例变量和实例方法
可直接访问类的静态变量和静态方法
实例方法:通过实例访问
可直接访问所属类的静态变量,静态方法,实例变量和实例方法
静态方法必须被实现 main()就是最常用的静态方法
//模拟实现选民投票过程:一群选民进行投票,每个选民只允许投一次, 并且当投票总数达到100时,停止投票
public class Voter {
//投票总数,所有选民都会改变的同一个数据 static
public static int count;
//100,最大投票数,适用于全部的所有选民,static final
public static final int MAX_COUNT = 100;
private String name;
//带参构造方法
public Voter(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public void voteFor() {
if(count == MAX_COUNT) {
System.out.println("投票结束");
return;
}else {
count++;
}
System.out.println(this.name+",感谢您的投票!");
}
public static void printResult() {
System.out.println("选民总数是:"+count);
}
}
public class TestVoter {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Voter lisa = new Voter("lisa");
lisa.voteFor();
Voter.printResult();
for(int i = 1;i <=99;i++) {
Voter v = new Voter("v"+i);
v.voteFor();
}
Voter.printResult();
Voter rose = new Voter("rose");
rose.voteFor();
Voter.printResult();
}
}
方法重写
1.子类继承父类的什么?
继承public和protected 修饰的属性和方法,不管子类和父类是否在同一个包中
继承默认权限修饰符修饰的属性和方法,子类和父类必须在同一个包中
2.不能被继承的父类成员
private成员
子类与父类不在同包,使用默认访问权限的成员
构造方法
3.子类访问父类成员
访问父类构造方法
super();
super(name);
访问父类属性
super.name;
访问父类方法
super.print();
注意:
(1)使用super关键字,super代表父类对象
(2)super只能出现在子类的方法和构造方法中
(3)super调用构造方法时,只能是第一句
(4)super不能访问父类的private成员
4.继承条件下的构造方法
继承条件下构造方法的调用规则
子类构造方法没有通过super显示调用父类的有参构造方法,系统默认调用父类的无参构造方法
子类构造方法通过super显示调用父类的有参构造方法,执行相应构造方法,而不执行父类无参构造方法
5.方法重写规则:
方法名相同
参数列表相同
返回值类型相同或者是其子类
访问权限不能严于父类
父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法也不能被子类覆盖为静态方法
子类可以定义与父类同名的静态方法,以便在子类中隐藏父类的静态方法(注:静态方法中无法使用super,通过类名调用)
父类的私有方法不能被子类覆盖
不能抛出比父类方法更多的异常
6.方法重写vs方法重载
Object类
Object类是所有类的直接或间接父类
equals()方法
Object类的equals()方法
-比较两个对象是否是同一个对象,是则返回true
--操作符==
简单数据类型,直接比较值.如1==2
引用类型,比较两者是否为同一对象
1.单根继承
Java只支持单根继承
一个类只能有一个直接父类
一个类可以有多个间接父类
super和this
七.多态
1.instanceof用于判断一个引用类型所引用的对象是否是一个类的实例
有抽象方法的类一定是抽象类
抽象类就一定有抽象方法吗?不一定
抽象类不能实例化 Pet pet = new Pet();
抽象类的子类可以是普通类,该普通类要实现抽象类中的抽象方法
抽象类的子类也可以是抽象类,此时,父类中的抽象方法可以在子类中不被实现
2.向上转型
- 向上转型:父类的引用指向子类对象.自动进行类型转换
- Pet pet = new Dog();
- <父类型> <引用变量名> = new <子类型> ();
- 此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法,不是父类的方法.
- 此时通过父类引用变量无法调用子类特有的方法
3.向下转型
如果需要调用子类特有的方法?
向下转型: 将一个指向子类对象的父类引用赋给一个子类的引用,即:父类类型转换为子类类型.需强制类型转换
Dog dog = (Dog) pet; // 将pet转换为Dog类型 - <子类型> <引用变量名> = (<子类型>) <父类型的引用变量>;
- 在向下转型的过程中,如果煤油转换为真实子类类型,会出现类型转换异常
类型转换异常:
image.png
4.instanceof
如何减少在向下转型的过程中,没有转换为真实子类类型的转换异常? - Java中提供了instanceof运算符来进行类型的判断
注意 - 使用instanceof时,对象的类型必须和instanceof后面的参数所指定的类在继承上有上下级关系
Pet dog= new Dog();
if (dog instanceof Dog) {
Dog d = (Dog) dog;
d.catchFly();
}else if (dog instanceof Penguin){
Penguin p = (Penguin) dog;
p.swim();
}
八.抽象类与接口
1.抽象类与抽象方法
public abstract class Pet { // 抽象类
public abstract void toHospital(); // 抽象方法
}
- 抽象类VS普通类
抽象类不能被实例化
但可以创建一个引用变量,其类型是一个抽象类,指向非抽象的子类实例
普通类可以被实例化
- 抽象方法VS普通方法
有无方法体
- 抽象类与抽象方法的使用抽象类中可以没有抽象方法,但包含了抽象方法的类必须被定义为抽象类
如果子类没有实现父类的所有抽象方法,子类必须被定义为抽象类
没有抽象构造方法,也没有抽象静态方法
抽象类中可以有非抽象的构造方法,创建子类的实例时可能调用
2.接口
接口特性:
- 接口中的成员变量
默认都是public static final(静态常量 )的,必须显示初始化 - 接口中的方法
默认都是public abstract的
除了成员遍量和方法,不能包含其他
实现类必须实现接口的所有方法 - 接口中没有狗造方法,不能被实例化
- 一格接口不能实现另一个接口,但可以实现类可以实现多个接口 (Java中的多继承)
- implements, 多个接口使用逗号隔开
示例:防盗门功能
阅读代码 找出错误:
1.不能有构造方法
3.不能有普通方法'
4.应是public, 不能private私有化;
3.抽象类vs接口
- 相同点:
代表系统的抽象层
都不能被实例化
都能包含抽象方法(用于描述系统提供的服务,不必提供具体实现) - 不同点:
在抽象类中可以为部分方法提供默认实现,而接口中只能包含抽象方法
一个类只能继承一个直接的父类,但可以实现多个接口
已存在的继承树,可以方便的抽取接口,但是抽取抽象类不容易 - 使用原则:
接口做系统与外界交互的窗口(接口提供服务)
接口本身一旦制定,就不允许随意修改
抽象类可完成部分功能实现,还有部分功能可作为系统的扩展点