面向对象编程(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+entera.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+entera.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{@Overridepublic 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{@Overridepublic void add(String name) {}@Overridepublic void update(String name) {}@Overridepublic void delete(String name) {}@Overridepublic void query(String name) {}@Overridepublic 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();//主动抛出异常}}
}
