面向过程&面向对象
面向过程思想
步骤清晰简单,第一步做什么,第二步做什么
面对过程适合处理一些较为简单的问题
面向对象思想
物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的我呢提,适合处理需要多人协作的问题!
对于描述复杂的事物,为了从宏观上把握,从整体上合理分析,我们需要使用面向对象的思路来分析整个系统,但是,具体到微观操作,仍然需要面向过程的思路去处理
什么是面向对象
面向对象编程(OOP)
面向对象编程的本质就是:以类的方式组织代码,以对象的组织(封装)数据
抽象
三大特征
封装、继承、多态
从认识的角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象
从代码运行的角度是先有类后有对象。类是对象的模板。
方法的定义
静态和非静态方法
A类中定义静态static方法aa(),B类中可以通过调用A.aa()来调用该方法
A类中定义非静态方法bb(),B类中需要通过实例化来调用bb()方法
A a1=new A();
a1.bb()
同一类中,定义两个非静态方法a(),b(),方法a和方法b可以互相调用
public void a(){
b();
}
public void b(){
a();
}
同一类中,定义两个静态方法aa(),bb(),方法aa和方法bb可以互相调用
public static void aa(){
bb();
}
public static void bb(){
aa();
}
同一类中,定义一个静态方法aaa(),一个非静态方法bbb(),方法bbb可以调用aaa,方法aaa不可以调用bbb
//和类一起加载的,故而一个存在的调用一个不存在的东西,所以会报错
public static void aaa(){
bbb();
}
//类实例化之后才存在
public void bbb(){
aaa();
}
值传递
传递中只是将a值传递,打印输出的a仍等于1
//值传递
public class Demo04 {
public static void main(String[] args) {
int a=1;
System.out.println(a); //a=1
Demo04.change(a);
System.out.println(a); //a=1
}
//返回值为空
public static void change(int a){
a=10;
}
}
类和对象的关系
类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物
对象是抽象概念的具体实例
创建与初始化对象
使用new关键字创建对象
使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化以及对类中构造器的调用
类中构造器也称为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点:
1.必须和类的名字相同
2.必须没有返回类型,也不能写void
构造器:
1.和类名相同
2.没有返回值
作用:
1.new的本质调用构造器
2.初始化对象的值
注意点:
1.定义有参构造之后,如果想使用无参构造,显示的定义一个无参的构造
创建对象内存分析
public class Pet {
public String name;
public int age;
public void shout(){
System.out.println(this.name+"叫了一声");
}
}
package com.oop;
import com.oop.demo03.Pet;
public class Application {
public static void main(String[] args) {
Pet dog=new Pet();
dog.name="旺财";
dog.age=3;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
Pet cat =new Pet();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CfTXBKWO-1675501496630)(C:\Users\trick\AppData\Roaming\Typora\typora-user-images\image-20230131202039746.png)]
封装
高内聚,低耦合
属性私有,get/set
/*
1.提高代码的安全性,保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加了
*/
public class Student {
//属性私有
private String name;
private int id;
private char sex;
private int age;
//提供一些可以操作这个属性的方法!
//提高一些oublic的get、set方法
//get 获得这个数据
public String getName(){
return this.name;
}
public void setName(String name){
this.name=name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>120||age<0) {
this.age = 3;
}else {
this.age = age;
}
}
//alt+insert->getter和setter
}
/*
public static void main(String[] args) {
Student s1=new Student();
s1.setName("zzzz");
System.out.println(s1.getName());
s1.setAge(999);//不合法
System.out.println(s1.getAge());
s1.setAge(20);//不合法
System.out.println(s1.getAge());
}
*/
继承
继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模
extands的意思是扩展。子类是父类的继承
java中类只有单继承,没有多继承!
继承是类和类之间的一种关系,除此之外,类和类之间的关系还有依赖、组合、聚合等
继承关系的俩个类,一个为子类(派生类),一个为父类(基类),子类继承父类,使用关键字extends来表示
子类和父类之间,从意义上讲应该具有“is a"的关系
object类
super
//在java中所有的类都默认继承object类
public class Person {
/*
public
protect
default
private
*/
private int money=10000000;
public void say(){
System.out.println("gaggagagag!");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
package com.oop.demo05;
//student is Person
public class Student extends Person{
}
package com.oop.demo05;
//Teacher is Person
public class Teacher extends Person{
}
/*
ctrl+H 快捷键查看继承树
public class Application {
public static void main(String[] args) {
Student student=new Student();
student.say();
student.setMoney(99999999);
System.out.println(student.getMoney());
}
}
*/
super
/*
父类中private属性无法被子类继承
子类的构造方法中隐藏默认继承了父类的构造方法
如果父类的只有有参构造方法,那么子类中只能调用有参构造方法
super注意点:
1.super调用父类的构造方法,必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中!
3.super和this不能同时调用构造方法
Vs this:
代表的对象不同:
this:本身调用者这个对象
super:代表父类对象的应用
前期:
this:没有继承也可以使用
super:只有在有继承情况下可以使用
构造方法:
this():本类的构造
super():父类的构造
*/
package com.oop.demo05_super;
public class Person {
public Person() {
System.out.println("Person无参执行了");
}
protected String name="lzh";
public void print(){
System.out.println("Person");
}
//私有的东西无法被继承
}
public class Student extends Person{
public Student() {
//隐藏代码:调用了父类的无参构造
super();//调用父类的构造器,必须要在子类构造器的第一行
System.out.println("Student无参执行了");
}
public Student(String name){
this.name=name;
}
private String name="zzz";
public void print(){
System.out.println("Student");
}
public void test1(){
print();
this.print();
super.print();
}
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
public class Application {
public static void main(String[] args) {
Student student=new Student();
//student.test("xxxx");
//student.test1();
}
}
重写
/*
静态方法和非静态的方法区别很大
重写的关键字只能用public
子类重写父类的方法
重写:需要有前提,子类重写父类的方法!
1.方法名必须相同
2.参数列表必须相同
3.修饰符:范围可以扩大: public>protected>Default>private
4.抛出的异常:范围可以被缩小,但不能扩大:ClassNotFoundException-->Exception(大)
重写,子类的方法和父类必须要一致,方法体不同!
为什么需要重写:
1.父类的功能,子类不一定需要或者不一定满足!
Alt+insert->override;
*/
public class B {
public void test(){
System.out.println("B=>test()");
}
}
public class A extends B{
//Override重写
@Override//注解:有功能的注释!
public void test() {
System.out.println("A=>test()");
}
}
public class Application {
public static void main(String[] args) {
//方法的调用只和左边,定义的数据类型有关
A a=new A();
a.test();
//父类的引用指向了子类
B b =new A(); // 子类重写了父类的方法
b.test();
}
}
output:
A=>test()
A=>test()
多态
动态编译
即同一种方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多
多态存在的条件
有继承关系
子类重写父类方法
父类引用指向子类对象
注意:多态是方法的多态,属性没有多态性
/*
多态注意事项:
1.多态是方法的多态,属性没有多态
2.父类和子类,有联系,类型转换异常:ClassCastException!
3.存在条件:继承关系,方法需要重写,父类引用指向子类对象! Father f1=new Son():
1.static方法 属于类,它不属于实例
2.final常量
3.private方法
*/
public class Person {
public void run(){
System.out.println("run");
}
}
public class Student extends Person{
@Override
public void run(){
System.out.println("son run");
}
public void eat(){
System.out.println("son eat");
}
}
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person()
//可以指向的引用类型就是不确定的 父类的引用指向子类
//Student能调用的方法都是自己的或者继承父类
Student s1= new Student();
//Person 父类型,可以指向子类,但是不能调用子类独有的方法
Person s2=new Student();//父类的引用指向子类
s1.run();
s2.run();//子类重写父类的方法,执行子类的方法
//能执行哪些方法主要看对象左边的类型,与右边的关系不大!
//不能执行s2.eat();
((Student)s2).eat();//转换类型来调用
}
}
instanceof (类型转换) 引用类型,判断一个对象是什么类型
public class Application {
public static void main(String[] args) {
Object object = new Student();
System.out.println(object instanceof Student);//True
System.out.println(object instanceof Person);//True
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//False
System.out.println(object instanceof String);//False
Person person=new Person();
System.out.println(person instanceof Student);//True
System.out.println(person instanceof Person);//True
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//False
//System.out.println(person instanceof String);编译报错
Student student=new Student();
System.out.println(student instanceof Student);//True
System.out.println(student instanceof Person);//True
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);编译报错
//System.out.println(student instanceof String);编译报错
}
}
public class Application {
public static void main(String[] args) {
//类型之间的转化:父 子
//高 低
Person student=new Student();
//student将这个对象转换为Student类型,我们就可以使用Student类型的方法了!
((Student)student).go();
//子子类转父类可能丢失自己本来的一些方法
}
}
/*
1.父类引用指向子类的对象
2.把子类转为父类,向上转型;
3.把父类转化为子类。需要强制转换
4.方便方法的调用,减少重复的代码!简洁
*/
static修饰符
public class Person {
//2 赋初始值
{
//代码块(匿名代码块)
//程序在执行时并不能主动调用
//创建对象时 自动创建,在构造器之前
System.out.println("匿名代码块");
}
//1
static {
//静态代码块 可以在其中加载初始化数据
//类一加载就直接执行,而且永久只执行一次
System.out.println("静态代码块");
}
//3
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 =new Person();
System.out.println("==============");
Person person2 =new Person();
}
}
//static
public class Student {
private static int age; //静态变量
private double score; //非静态变量
public void run(){
}
public static void go(){
}
public static void main(String[] args) {
Student s1=new Student();
System.out.println(Student.age); //使用类来调用
//System.out.println(Student.score);编译报错
System.out.println(s1.age);
System.out.println(s1.score);
Student.go();
go();
s1.run();
}
}
//静态导入包
import static java.lang.Math.random;
public class Test {
public static void main(String[] args) {
System.out.println(Math.random());
System.out.println(random()); //使用静态导入包之后可以不加Math. 可以直接调用
}
}
//final修饰的类无法被继承
抽象类
abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法,如果修饰类,那么该类就是抽象类
抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类
抽象类,不能使用ne关键字来创建对象,它是用来让子类继承的
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的
子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该类也要声明为抽象类
//abstract 抽象类 :类 extends:单继承~ (接口可以多继承)
public abstract class Action {
// 约束~有人帮我们实现
//abstract ,抽象方法,只有方法名字,没有方法实现
public abstract void doSomething();
/*抽象类的特点:
1.不能new这个抽象类,只能靠子类去实现它:约束!
2.抽象类可以写普通的方法
3.抽象方法必须在抽象类中
//抽象的抽象:约束
//思考:抽象类不能new,存在构造器吗
存在的意义是什么 抽象出来~提高开发效率
*/
}
//抽象类的所有方法,继承了它的子类,都必须要实现它的方法
public class A extends Action{
@Override
public void doSomething() {
}
}
接口
普通类:只有具体实现
抽象类:具体实现和规范(抽象方法)都有
接口:只有规范 约束和实现分离:面向接口编程~
接口就是规范,定义的是一组规则,体现了现实世界中”如果你是…则必须能…“的思想。如果你是天使则必须能飞
接口的本质是契约,就像法律一样,制定好后大家都遵守
OO的精髓,是对对象的抽象,最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言,就是因为设计模式所研究的,实际上就是如何合理的去抽象
声明类的关键字是class,声明接口的关键字是interface
//interface 定义的关键字 接口都需要有实现类
public interface UserService {
//接口中的所有定义都是抽象的 public abstract
void run();
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
//定义的属性都是常量 public static final int AGE=99;
int AGE=99;
}
/*
作用:
1.约束
2.定义一些方法,让不同的人去实现
3.方法都是public abstract
4.变量都是public static final 静态常量 可以直接使用
5.接口不能被实例化
6.implements可以实现多个接口
7.必须要重写接口中的方法
*/
public class UserServiceImpl implements UserService ,TimeService{
@Override
public void run() {
}
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
public interface TimeService {
void timer();
}
内部类
内部类就是在一个类的内部定义一个类,比如,A类中顶一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类
1.成员内部类
2.静态内部类
3.局部内部类
4.匿名内部类
异常机制
异常指程序运行出现的不期而至的各种状况,如:文件找不到,网络连接失败,非法参数等。
异常发生在程序运行期间,他影响了正常的程序执行流程
三种类型的异常
1.检查性异常
最具有代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的
2.运行时异常
运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常是可以在编译时被忽略
3.错误ERROR
错误不是异常,而是脱离程序员控制的问题。
java把异常当作对象来处理,并定义一个基类java.lang.Throwable作为所有异常的超类
在javaAPI中已经定义了许多异常类,这些异常类分为两大类,错误Error和异常Exception
Error
error类对象由java虚拟机生成并抛出,大多数错误与代码编写者所执行的操作无关
java虚拟机运行错误,当JVM不再有继续执行操作所需的内存资源时,将出现OutOfMemoryError,这些异常发生时,java虚拟机一般选择线程终止
Exception和error的区别:
error通常是灾难性的致命错误,是程序无法控制和处理的,当出现这些异常时,jvm一般会选择终止线程,Exception通常情况下时可以被程序处理的,并且在程序中应该尽可能的去处理这些异常
异常处理机制
抛出异常
捕获异常
处理异常的五个关键字:try、catch、finally、throw、throws
public class Tets {
public static void main(String[] args) {
int a=1;
int b=0;
//捕获多个异常,要从小到大
try {//try监控区域
if(b==0){
throw new ArithmeticException(); //主动抛出异常
}
System.out.println(a/b);
}catch (Error e){ //catch(想要捕获的异常类型)捕获异常
System.out.println("程序出现异常,变量b不能为0");
}catch (Exception e){
}catch (Throwable e){
} finally { //处理善后工作
System.out.println("finally");
}
//finally可以不需要
}
}
public class Tets {
public static void main(String[] args) {
try{
new Tets().test(1,0);
}catch (ArithmeticException e){
e.printStackTrace();
}
}
//假设这个方法中,处理不了这个异常,方式上抛出异常
public void test(int a,int b) {
if (b == 0) {
throw new ArithmeticException(); //主动抛出异常,一般在方法中使用
}
}
}
自定义异常
用户自定义异常类,只需继承Exception即可
使用自定义异常类,大体分为一下几个步骤:
1.创建自定义异常类
2.在方法中通过throw关键字抛出异常对象
3.如果在当前抛出异常的方法中处理异常,可以使用try-catch语句捕获并处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常,继续进行下一步操作
4.在出现异常方法的调用者中捕获并处理异常
//继承Exception:自定义的异常类
public class MyException extends Exception{
//传递数字>10
private int detail;
public MyException(int a) {
this.detail = a;
}
// toString:打印异常的信息
@Override
public String toString() {
return "MyException{" +
"detail=" + detail +
'}';
}
}
public class Test {
//可能会存在异常的方法
static void test(int a) throws MyException{
if(a>10){
throw new MyException(a);
}
System.out.println("ok");
}
public static void main(String[] args) {
try{
test(1);
}catch (MyException e){
System.out.println("MyException=>"+e);
}
}
}