面向对象编程(oop)
1、什么是面向对象(00)
- 面向过程：线性思维
- 面向对象：分类思维
本质：以类的方式组织代码，以对象的形式阻止（封装）数据
- 三大特性：封装，继承，多态
2、回顾方法的定义
方法的定义
- 修饰符
- 返回值类型
/*
* 修饰符 返回值类型 方法名（...）{
* 方法体
* return 返回值;
* }
* 返回值类型和返回值一一对应
* */
public String haibai(){
return "hello，海摆";
}
- break:跳出Switch，结束循环
方法的调用
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传递
- this关键字
3、 回顾方法的调用
- 递归
创建静态方法时，直接调用即可
当创建非静态方法时，需要先将这个类进行实例化
- 静态方法和非静态方法
如果是先存着去调用不存在的东西会报错，反之
//是和类一起加载的 先存在
public static void a(){
}
//类实例化之后才存在的 后存在
public void b(){
a();
}
- 实参
//这里实际参数要和形式参数类型要一一对应
4、类与对象
右边通过定义属性，左边对haibai进行实例化后，有输出结果，而没有实例则输出默认值
无参构造
有参构造
有参无参快速创建alt+ins
5、封装
属性私有，get/set
1.提高程序安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加了
6、继承
父类Person 子类Student
调用say方法
super
super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法
和this不同点：
this：本身调用这个对象、没有继承也可以使用、本类的构造
super：代表父类对象的引用、只能在继承的条件下才能使用、父类的构造
7、方法重写
- 有static时 静态方法调用类
public class B {
public static void test(){
System.out.println("B=>test");
}
}
public class A extends B{
public static void test() {
System.out.println("A=>test");
}
}
public static void main(String[] args) {
A a = new A(); //Alt+enter
a.test();
B b= new A();
b.test();
}
//结果为
A=>test
B=>test
- 没有静态方法时，调用对象
- 也就是没有static时只跟左边有关
public class B {
public void test(){
System.out.println("B=>test");
}
}
public class A extends B{
public void test() {
System.out.println("A=>test");
}
}
public static void main(String[] args) {
A a = new A(); //Alt+enter
a.test();
B b= new A();//子类重写了父类的方法
b.test();
}
//结果为
A=>test
A=>test
重写：需要有继承关系，子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大但不能缩小 public>protected>default>private
4.抛出的异常：范围 可以被缩小，但不能扩大 ClassnotfoundException--> Exception（大）
重写，子类的方法和父类必要一致，方法体不同！
为什么需要重写：
父类的功能，子类不一定需要，或者不一定满足
alt+insert ; override
8、多态
public class Person {
}
public class Student extends Person{
}
public static void main(String[] args) {
//Student 能调用的方法都是自己或者继承父类的
Student s1 = new Student();
//父类型可以指向子类，但不能调用子类的方法
Person s2= new Student();
Object s3 = new Student();
}
-
注意事项：
-
1.多态是方法的多态，属性没有多态
-
2.父类和子类：有联系，类型转换异常！ClasscastException
-
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1= new son();
- (1) static 方法，属于类，它不属于实例
- (2)final 常量;
- (3)private 方法;
-
9、Static关键字详解
-
静态属性属于类，为所有对象所共享
-
非静态方法可以调用静态方法，静态方法不可调用静态方法
-
输出
- 静态代码块
- 匿名代码块
- 构造方法
-
被final修饰的类无法被继承
-
静态导入包
import static java.lang.Math.PI; // 静态导入包
public class Person {
{
// 代码块 创建对象时自动创建，在构造器之前,赋初始值
System.out.println(“匿名代码块”);
}
static {
// 静态代码块，用于初始化，在类加载时执行
System.out.println(“静态代码块”);
}
public Person()
{
System.out.println(“构造方法”);
}
}
// ================
Person p1 = new Person();
System.out.println(“--------------”);
Person p2 = new Person();
10、抽象类
//抽象类
public abstract class Action {
//abstract,抽象方法，只有名字，没有方法的实现
public abstract void dosomething();
//抽象类里可以有普通方法
public void run(){
}
}
- 抽象类所有的方法，继承了它的子类，都必须要重写它的方法
public class H extends Action{
@Override
public void dosomething() {
}
- 或者
public abstract class H extends Action{
}
- abastract修饰方法，则该方法为抽象方法
- abstract修饰类，则该类为抽象类
- 抽象类不能用new关键字来创建对象，它用子类来继承
- 抽象方法只有方法的声明，没有方法的实现，它用子类实现
- 抽象类可以没有抽象方法，但有抽象方法的类需要声明为抽象类
- 抽象类可以写普通方法
- 子类继承抽象类，必须实现抽象类没有实现的抽象方法，否则子类也要声明抽象类
- 抽象类存在构造函数
- 抽象类就是用来封装，多态地增强代码的可扩展性
11、接口的定义与实现
//class 替换为interface
public interface Userservice {
//接口中的所有定义的方法都是抽象的
void add(String name);
void update(String name);
void delete(String name);
void query(String name);
}
public interface Timeservice {
void timed();
}
//实现接口的类，就需要重写接口的方法
public class Userservicelmpl implements Userservice,Timeservice{
@Override
public void add(String name) {
}
@Override
public void update(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timed() {
}
}
1.关键字interface
2.比较
- 普通类：只有具体实现
- 抽象类：具体实现和规范（抽象方法）都可以
- 接口：只有规范，自己无方法可写，约束和实现分离
3.接口
- 所有定义方法默认都是抽象的public absteact
- 可以多继承
- 就是规范，定义的一组规则
- 不能被实例化，没有构造方法
- 必须重写接口中的方法
12、内部类
1.成员内部类
public class Outer {
//定义一个私有属性
private int id=10;
//定义外部类的方法
public void out(){
System.out.println("这是外部类的方法");
}
//定义内部类方法
public class inner{
public void in(){
System.out.println("这是内部类方法");
}
//获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
}
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
outer.out();
Outer.inner inner = outer.new inner();
inner.in();
inner.getID();
}
}
2.静态内部类
//在上方的基础上 class前面添加static 则为内部类
//定义内部类方法
public static class inner{
public void in(){
System.out.println("这是内部类方法");
}
}
3.局部内部类
public class Outer {
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
4.匿名内部类
public static void main(String[] args) {
//没有名字初始化类，不用讲实例保存到变量中
new apple().eat();
}
static class apple{
public void eat(){
System.out.println("eat");
}
}
13、捕获和抛出异常
-
ctrl+alt+t 代码块
-
最高异常:Throwable
-
其次：error和Exception
-
异常处理的五个关键字 try、catch、finally、throw、throws
- try：监控区域
- catch：捕获异常
- finally：都将会执行的语句
- throw和throws：抛出异常
public class Test {
public static void main(String[] args) {
int a=1;
int b=0;
try {
System.out.println(a/b);
} catch (Error e) {
System.out.println("程序出错");
} catch (Exception e) {
System.out.println("Exception");
} catch (Throwable e) {
System.out.println("Throwable");
} finally {
System.out.println("finally");
//finally可以不要，
}
}
public void a(){
b();
}
public void b(){
a();
}
}
public class Test2 {
public static void main(String[] args) {
try {
new Test2().tt(1,0);
} catch (Exception e) {
System.out.println("发现异常");
}
}
//方法中，处理不了这个异常，方法上抛出异常
public void tt(int a,int b) throws ArithmeticException{
if (b==0){
throw new ArithmeticException();//主动抛出异常
}
}
}