Java基础（五）-面向对象编程
面向对象编程
Java的核心思想就是OOP（Object-Oriented Programming）
面向过程&面向对象
面向过程思想
- 步骤清晰简单，第一步做什么，第二🙅步做什么……；
- 适合处理一些比较简单的问题。
面向对象思想
- 物以类聚，分类的思维模式；
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
- 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，需要面向对象的思路来分析整个系统。但是具体到微观操作，仍需要面向过程的思路去处理。
什么是面向对象
- 面向对象编程（Object-Oriented Programming，OOP）
- 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
- 抽象
- 三大特性：封装、继承、多态
- 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象；
- 从代码运行角度考虑是先有类后有对象。类是对象的模板。
类与对象的创建
创建与初始化对象
-
使用new关键字创建对象；这个时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
-
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
- 1.必须和类的名字相同；
- 必须没有返回类型，也不能写void
public class Person {
//一个类即使什么都不写，也会存在一个空方法，即无参构造器
String name;
/*
构造器作用：1.使用new关键字，本质是在调用构造器
2.构造器用来初始化对象值；
3.一旦定义了有参构造，如果想使用无参构造，无参就必须显示定义
4.alt+insert 生成构造器的快捷键
5.this.当前类变量=后面传进来的变量值
*/
//无参构造
public Person(){
}
//有参构造
public Person(String name){
this.name=name;
}
/*
Person xh=new Person("yh");
System.out.println(qf.name);
* */
}
类和对象小结
-
类是一个模板，抽象；对象是一个具体的实例
对应的引用：
引用类型：基本类型（8）char,int,long,double,string,boolean,float,byte
对象是通过引用来操作的：栈-->堆
-
属性和方法就构成一个类；
-
属性：字段Filed 成员变量
默认初始化：数字 int 0 ，float 0.0
char: u0000
boolean:false
引用类型：null
赋值格式：修饰符 属性类型 属性名=属性值；
-
方法：
-
-
对象的创建和使用
- 必须使用new 关键字创造对象， 构造器必须有。eg： Person k=new Person()
- 对象的属性，通过.来操作； k.name
- 对象的方法，通过.来操作； k.sleep()
三大特性
1. 封装
-
该露的露，该藏的藏
程序设计追求高内聚，低耦合
-
封装（数据的隐藏）
-
属性私有：get/set
/*封装的意义
* 1.提高程序的安全性，保护数据
* 2.隐藏代码的实现细节
* 3.统一接口
* 4.系统可维护增加了
* 5.Alt+insert 封装函数的快捷键
* */
//类 private:私有
public class Student {
//属性私有
private String name;
private int id;
private char sex;
//提供一些可以去操作这些属性的方法
//提供一些public的get\set方法
public String getName(){
return this.name;
}
public void setName(String name){
this.name=name;
}
}
2. 继承
-
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
-
Java类中只有单继承，没有多继承！
-
子类继承父类，使用关键字extends表示，子类也称为派生类，父类也称为基类。
-
子类继承父类，从意义上讲应具有"is a"的关系；
-
Object类
//子类继承了父类，就会拥有父类的全部方法 //在Java中，所有的类，都默认直接或者间接继承Object类 -
super-this
-
super注意点
- super调用父类的构造方法，必须在构造方法的第一个；
- super必须只能出现在子类的方法或者构造方法中；
- super和this不能同时调用构造方法。
-
与this对比
- 代表对象不同，this：本身调用者这个对象；super：代表父类对象的使用
- 前提不同，this:没有继承也可以使用；super:只能在继承条件才能使用；
- 构造方法：this()：本类的构造；super():父类的构造
-
-
方法重写
方法都是方法的重写（override），与属性无关。静态方法只能被继承，不能被重写。
方法的重写需要有继承关系，子类重写父类的方法
- 方法名必须相同；
- 参数列表必须相同；
- 修饰符：范围可以扩大但是不能缩小：public>protected>default>private
- 抛出的异常范围：可以被缩小，但不能扩大；ClassNotFoundException-->Execption(大)
- 需要重写的原因：父类的功能子类不一定需要，或者不一定满足！
重写，子类的方法和父类必须要一致，但是方法体不同。
//静态方法和非静态方法结果相差很大 public static void main(String[] args) { //方法的调用只和左边定义的数据类型有关 //或者这样理解，对象能执行哪些方法，主要看左边的类型，和右边的关系不大。 A a=new A(); a.test(); //父类的引用指向子类 ，B是父类，A是B的子类 B b=new A(); b.test(); /* 加static时，b输出的是父类B方法的结果；无static时，输出的是子类A的方法结果 * 这样理解，b是A new出来的对象，因此调用了A的方法。 * 因为静态方法是类的方法，而非静态是对象的方法 * 有static时，b调用了B类的方法，因为b是用b类定义的 * 没有static时，b调用的是对象的方法，而b是用A类定义的 * */ }
3.多态
-
同一方法可以根据发送对象的不同而采用多种不同的行为方式；
-
一个对象的实际类型是确定的，但是可以指向对象的引用的类型有很多（父类，有关系的类）
-
多态存在的条件：有继承关系、子类重写父类的方法、父类引用指向子类对象；
-
关键字*** instanceof （类型转换）*** 引用类型，判断一个对象时什么类型
-
多态注意事项；
-
-
多态是方法的多态，属性没有多态性；
-
父类和子类有联系，类型转换异常！ClassCastException!
-
存在条件：继承关系，方法需要重写，父类引用指向子类对象！
Father f1=new Son();
-
有些方法不能重写：①static 方法，属于类，它不属于实例；②final 常量；③private方法，这些类型的方法不能被重写，不存在多态。
-
-
//Student 子类能调用的方法都是自己的或者继承父类的！
Student s1 = new Student();
// Person 父类型，可以指向子类，但是不能调用子类独有的方法！
Person s2 = new Student(); //父类的引用指向子类
Object s3 = new Student();
//对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大；
s2.run(); //子类重写了父类的方法，执行子类的方法
s1.eat();
((Student)s2).eat(); //强制类型转换，将Person类转成Student类
instanceof关键字
//Object>String
//Object>Person>Teacher
//Object>Person>Student
//System.out.println(x instanceof y);//能不能编译通过取决于x和y之间有没有父子关系
Object obj = new Student();
System.out.println(obj instanceof Student);//true
System.out.println(obj instanceof Person);//true
System.out.println(obj instanceof Object);//true
System.out.println(obj instanceof Teacher);//false
System.out.println(obj instanceof String); //false
System.out.println("----------");
Person per = new Student();
System.out.println(per instanceof Student);//true
System.out.println(per instanceof Person);//true
System.out.println(per instanceof Object);//true
System.out.println(per instanceof Teacher);//false
//System.out.println(per instanceof String); //编译报错
类型转换
基本类型之间的转换：高转低需要强转，低转高是自动转换。
//类型之间的转化：父 子
//高 低
Person st = new Student();
//st现在是Person类，将这个对象转换为Student类，就可以使用Student类型的方法了！
((Student)st).go();
}
/*
* 1.父类引用指向子类的对象
*2.把子类对象转换为父类，向上转型
* 3.父类转换为子类，向下转型；强制转换，这个时候会造成方法丢失；
* 4.转换目的是方便方法的调用，减少重复代码
* */
static关键字
- 关于静态变量和静态方法的说明
//static
public class Student {
private static int age; //静态变量 多线程会使用！
private double score;
//非静态方法
public void run(){
go();
}
//静态方法
public static void go(){
}
//静态方法可以调用静态方法，但是不能调用非静态方法，非静态方法可以调用静态方法
//原因是 静态方法或者是变量是跟着类一块被加载的，此时还没加载非静态方法。
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(Student.age); //类变量，可以直接通过类名调用
System.out.println(s1.score);//这个是通过对象来调用
System.out.println(s1.age);
}
}
- 关于静态代码块
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 person = new Person();
}
}
- 静态导入包
抽象类
- abstract修饰符可以用来修饰方法也可以用来修饰类，如果用来修饰方法，那么该方法就是抽象方法，如果用来修饰类，那么该类就是抽象类。
// abstract 抽象类 类 extends： 单继承 （接口可以实现多继承）
//抽象类的所有方法，继承了它的子类，都必须实现它的方法，除非该子类也是抽象类
public abstract class Action {
//约束~有人帮我们实现~
//abstract方法，只有方法名字，没有方法的实现！
public abstract void doSomething();
//注意：1.抽象类不能new对象，只能靠子类去实现它;约束！
//2.抽象方法必须在抽线类，抽象类中可以写抽象的方法
//3.抽象类也一样存在默认构造器，目的是为了解决代码繁琐。
}
接口
- 普通类：只有具体实现
- 抽象类：具体实现和规范（抽象方法）都有！
- 接口：只有规范！自己无法写方法专业的约束！约束和实现分离：面向接口编程
接口就是规范，定义的是一组规则；接口的本质是契约，就像我们的法律一样，我们必须去遵守。
-
是面向对象OO的精髓，是对对象的抽象，最能体现这一点的是接口。
-
声明类的关键字是class，声明接口的关键字是interface！
-
接口的作用
- 约束；
- 定义一些方法，让不同的人实现~；
- 接口中默认的方法都是public abstract；
- 常量是public static final；
- 接口不能被实例化，接口中没有构造方法；
- implements可以实现多个接口
- 必须要重写接口中的方法~
//接口1
public interface UserService {
//接口中的所有定义其实都是抽象的 public abstract
//接口都需要有实现类
void add(String name);
void delete(String name);
}
//接口2
public interface TimeService {
void timer();
}
//以下是可以实现接口的类 implements 接口
//实现了接口的类，就需要重写接口中的方法
//多继承~ 利用接口来实现多继承
public class UserServiceImpl implements UserService,TimeService {
//生成重写方法的快捷键 Ctrl+i
@Override
public void add(String name) {
}
@Override
public void timer() {
}
@Override
public void delete(String name) {
}
}
内部类
内部类就是在一个类的内部定义了一个类，比如，A类中定义了一个B类，那么B类相对于A类来说就称为内部类，而A类相对于B类来说就是外部类了。
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类：就是没有名字初始化类，不用讲实例保存到变量中，比如new Apple().eat();
public class Outer {
private int id=90;
public void out() {
System.out.println("外部");
}
//成员内部类============
public class Inner{
public void in(){
System.out.println("内部");
}
//内部类可以获得外部类的私有属性和方法
public void getID(){
System.out.println(id);
}
}
//========
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
//一个java类中可以有多个class类，但是只能有一个public class
class A{
}
异常机制
程序在运行过程中，可能会存在各种异常问题，因此面对这些异常需要写合适的处理程序，让程序不至于崩溃。
三种类型的异常：
- 检查性异常：用户错误或者问题引起的异常，这是程序员无法预见的。
- 运行时异常
- 错误Error,错误不是异常，而是脱离程序员控制的问题。
异常体系结构
- Java把异常当作对象来处理，比定义了一个基类java.lang.Throwable作为所有异常的超类
- 在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception
异常处理机制
-
抛出异常；一般是用于方法中，关键字：throw、throws
-
捕获异常；一般用于语句中，关键字：try、catch、finally
int a=1; int b=0; //Ctrl+Alt+t 快捷键，选中该语句后使用该快捷键生成包含该语句的异常处理语句； try { System.out.println(a/b); } catch (Exception e) { e.printStackTrace(); } finally { }
自定义异常
-
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
-
在程序中使用自定义异常类，大体可以分为几个步骤：
- 创建自定义异常；
- 在方法中通过throw关键字抛出异常对象；
- 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续下一步操作；
- 在出现异常方法的调用者中捕获并处理异常。
-
实际应用中的经验总结
-
处理运行异常时，采用逻辑合理去规避同时辅助try-catch处理；
-
在多重catch块后面，可以加一个catch(Exception)来处理可能会遗漏的异常；
-
对于不确定的代码 ，也可以加上try-catch处理潜在的异常；
-
尽量去处理异常，切忌只是简单调用printStackTrace()去打印输出；
-
具体如何处理异常，要根据不同的业务需求和异常类型去决定；
-
尽量添加finally语句块去释放占用的资源。
-
浙公网安备 33010602011771号