Java基础篇之面向对象篇(2021)
文章目录
- 前言
- 一、面向对象基础
-
- 1、面向对象思想
- 2、三大特性
- 3、类与对象
- 4、对象创建时内存
- 5、构造方法（构造器）
- 6、方法的重载
- 7、匿名对象
- 二、面向对象进阶
-
- 1、封装private
- 2、this关键字（this指的是当前对象）
- 3、静态static
- 4、包（可以理解为文件夹）
- 4、导包(import)
- 5、权限修饰符
- 6、构造代码块
- 三、面向对象高级
-
- 1、继承(extends)
- 2、super关键字
- 3、重写(Override)
- 4、final关键字
- 5、abstract 抽象类
- 6、interface(接口)
-
- 6.1 格式
- 6.2 面向接口编程
- 6.3 全局常量和抽象方法
- 6.4 接口的实现
- 7、 多态
-
- 7.1多态格式
- 7.2向上向下转型
- 8、Object类
-
- 8.1 概念
- 9、内部类（了解即可）
-
- 9.1概念
- 9.2 成员内部类
- 9.3 匿名内部类
- 10、包装类
-
- 10.1 概述
- 10.2 装箱和拆箱
- 10.3 自动装箱和自动拆箱
- 11、可变长参数
-
- 11.1 格式
- 12、try catch（捕获异常）
-
- 12.1概述：
- 12.2 try catch处理流程
- 12.4 throws 抛出异常
- 12.5 throw 创建一个异常
- 12.6 自定义异常(了解内容)
- 总结
前言
此文章已经更新完毕，Java核心类库过两天将会更新到新的文章！！！
一、面向对象基础
1、面向对象思想
1. 面向过程到面向对象的思想层面的转变
2. 面向过程关注的是执行过程
3. 面向对象关注的是 具备功能的对象
4. 面向过程到面向对象，从程序员思想上是 从执行者到指挥者的转变
2、三大特性
1.封装性：所有的内容外界不可见
2.继承性：将其他的功能继承下来
3.多态性：方法的重载本身就是一个多态性的体现
3、类与对象
类必须通过对象才可以使用，对象的所有操作都在类中
类由属性和方法组成：
属性：相当于人的特征 例如：姓名、年龄、爱好...
方法：相当于人的行为 例如：吃饭、睡觉、打豆豆...
- 类的定义格式
class 类名称{
成员属性;
成员方法;
}
- 属性与方法
属性定义格式：
属性类型 属性名;
属性定义及赋值格式;
属性类型 属性名=属性值;
方法定义格式：
权限修饰符 返回值 方法名称(形参列表){
//方法体
return 返回值;
}
例如：
public int number(){
int i=10;
return i;
}
- 对象的创建
//创建对象的格式
类名 对象名=new 类名(有参数/无参数);
//要使用对象中的属性和方法
//我们可以把 . 看做成 的 ，也就是 对象名的属性/对象名的方法
对象名.属性
对象名.方法
- 对象的使用
public class Demo2 {
public static void main(String[] args) {
//类名 对象名称=new 类名();
//创建对象
Book book=new Book();
//给对象中的属性赋值
book.BookName="金苹果";
book.money=16.4;
//调用对象中的方法
book.say();
}
}
class Book{
String BookName;
double money;
public void say(){
System.out.println("===>我是"+BookName+"我的价格为===>"+money);
}
}
4、对象创建时内存
5、构造方法（构造器）
执行时机：在创建对象时，自动调用
提示：当我们new对象时，会自动调用该对象的无参数构造方法，若对象中没有创建构造方法会默认创建一个无参数构造方法，如果我们写了有参构造方法或无参构造方法，那么就不会自动创建构造方法（建议自己创建对象时就写入有参无参构造方法）
class Book{
String BookName;
double money;
//无参数构造方法
public Book(){};
//有参数构造方法
public Book(String name,double money){
//this指的是当前对象
//将形参中的name值赋值给this.BookName中
this.BookName=name;
this.money=money;
}
public void say(){
System.out.println("===>我是"+BookName+"我的价格为===>"+money);
}
}
6、方法的重载
//一个类中定义的方法，是允许 方法重载（相同的方法名称）
//注意：
//1.方法名相同
//2.形参类型、长度不同、参数类型顺序不同
//形参x 和 y
public int sum(int x,int y){
int i=x+y;
return i;
}
public double sum(double x,double y){
double i=x+y;
return i;
}
7、匿名对象
匿名：没有名字，没有 引用变量来接收堆内存中对象的地址，用一次就再也找不到了。
若一个对象要使用两次及以上，那么我们一定要创建 对象名。
new 类名().方法名()//匿名对象
二、面向对象进阶
1、封装private
概述：封装是为了保护或防止代码被恶意修改
保护类的属性，不让类以外的程序直接修改访问
class Person3{
//给类的属性添加private修饰符实现对属性的封装，此时外部程序不能直接访问或修改属性
private String name;
private int age;
//此时我们可以开放一个方法来设置和得到类中私有的属性 set属性名 和 get属性名
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
2、this关键字（this指的是当前对象）
提示：代码中有就近原则，当我们写的变量名一样时，都会找形参的相同变量名，为了起到见名知意，构造器建议写成这样
private String name;
private int age;
public Person3(String name, int age) {
this.name = name;
this.age = age;
}
3、静态static
1. 提示：当我们的一个对象有一个属性是所有人相同时，那么我们就可以把该属性设置为static属性，static属性属于当前类，不管创建多少个对象，这个static修饰的属性不会改变
带有static关键字的属性存储在方法区中，我们的类设置了static关键字属性，那么我们的这个类就持有static的内存地址，不管创建多少个对象，static的属性都是一致的。
重点：无论这个类创建了多少个对象，这个static静态属性在内存中只有一份！！！
2. 静态方法（直接通过类.静态方法名来执行，不需要new对象）
提示：静态修饰的方法，被调用时，可能对象还没有被创建
非静态方法可以调用静态方法，而静态方法不能调用非静态方法
public class Demo5 {
public static void main(String[] args) {
Student.say();
}
}
class Student{
public static void say(){
System.out.println("我是静态方法，直接通过 类.静态方法名就可以执行");
}
}
4、包（可以理解为文件夹）
- 包的定义：通常由多个单词组成，所有单词字母小写，单词与单词之间用 " . "分割 ，一般命名为：com.公司名.项目名.模块名 …
package com.study.demo; //指的是当前包路径
public class Demo1 {
}
4、导包(import)
- 导包：当我们需要使用某一个包的对象时，但是我们的两个com.study.test和com.study.test2这两个包中都有Person这个类，我们需要导入这个test2包中的Person类，我们就必须要导入test2这个包的Person类
import 包名.类名
import java.util.Scanner;
5、权限修饰符
6、构造代码块
提示：构造代码块：随着对象的每次创建，执行一次，并且执行在构造方法之前！
区别于构造方法的是：无论用户调用哪一个构造方法来创建对象，都会执行构造代码块
静态代码块:类加载的时候（第一次使用），静态代码块执行，因为类只加载一次，所以静态代码块只执行一次
public class Demo1 {
//构造代码块
{
System.out.println("我执行在构造方法之前");
}
//静态代码块:类加载的时候（第一次使用），静态代码块执行，因为类只加载一次，所以静态代码块只执行一次
static{
}
//构造方法
public Demo1(){
System.out.println("我执行在构造代码块之后");
}
}
面试题：构造方法、构造代码块和静态代码块执行顺序
静态代码块 – > 构造代码块 – > 构造方法
三、面向对象高级
1、继承(extends)
1. 格式：
class 父类{
}
class 子类 extends 父类{
}
2. 概念：什么叫做继承，简单来说，子类继承了父类，那么子类可以用父类的东西
public class Demo1 {
public static void main(String[] args) {
Student student=new Student();
student.setName("张三");
student.setAge(20);
student.say();
}
}
class Person{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void say(){
System.out.println("我叫"+name+"今年"+age+"岁");
}
}
class Student extends Person{
}
提示：我们可以看到Student学生类没有写任何属性和方法，但是继承了Person类后，我们可以使用Person类的属性和方法，只有权限修饰符是 public 和protected 子类才可以继承使用
2、super关键字
class Person{
private String name;
private int age;
public Person(){
System.out.println("无参数Person类");
}
public Person(String name,int age){
System.out.println("有参数Person类");
}
}
class Student extends Person{
public Student(){
//当我们不写super()时，系统会自动给我们加入super()
//super()有参和无参只能存在一个
super();//默认调用父类的无参数构造方法
super("无名称",20);//调用父类的有参数构造方法
}
}
3、重写(Override)
1. 当我们子类继承了父类时，我们不满足于父类的方法，需要重写父类的方法，叫做重写，当我们重写父类的方法后，我们调用子类的say方法就会先找子类中是否有say方法，如果有调用子类的say方法，没有则调用父类的say方法
public class Demo2 {
public static void main(String[] args) {
Student2 student2=new Student2();
student2.say();
}
}
class Person2{
public void say(){
System.out.println("我是父类的say方法");
}
}
class Student2 extends Person2{
@Override
public void say() {
System.out.println("我是重写后的say方法");
}
}
4、final关键字
- 用于修饰属性、变量。使用final修饰变量后，变量成为常量，不能再次赋值。
1.1 使用final修饰变量后，变量成为常量，不能再次赋值。
1.2 final修饰的局部变量，只能赋值一次(可以先声明，后赋值)
1.3 final修饰的成员变量，必须在声明时赋值。 - final用于修饰类
2.1 final修饰的类，不能被继承 - final用于修饰方法
3.1 final修饰的方法：不能被子类重写
5、abstract 抽象类
- 抽象类必须使用 abstract class 声明
- 一个抽象类中可以没有抽象方法，抽象方法必须写在抽象类中
格式：
abstract class 类名{//抽象类
//抽象方法
public abstract void 方法名();//抽象方法，只声明为实现
}
- 一个抽象类不能被实例化(也就是不能被 new 抽象对象类名),当我们子类继承(extends)抽象父类时，必须重写所有父类的抽象方法来加以实现。
abstract class Test{//抽象类
//抽象方法
public abstract void d1();
}
class Test1 extends Test {
//实现(重写)抽象类中的抽象方法
@Override
public void d1() {
}
}
6、interface(接口)
6.1 格式
interface 接口名称{
全局常量(public static final修饰的属性):
抽象方法:
}
6.2 面向接口编程
- 降低程序的偶尔度
- 易于程序的扩展
- 有利于程序的维护
6.3 全局常量和抽象方法
public interface Demo3 {
//全局常量
public static final int a=0;
//全局常量简写
int a=0;
//抽象方法
public void demo3();
//抽象方法简写
void demo3();
}
6.4 接口的实现
提示：1. 格式 public class 类名 implements 接口名1,接口名2…{}
public interface Demo3 {
//全局常量
public static final int a=0;
//全局常量简写
// int a=0;
//抽象方法
// public void demo3();
//抽象方法简写
void demo3();
}
//接口实现 implements 接口名
public class Demo4 implements Demo3{
@Override
public void demo3() {
}
}
7、 多态
提示：父类型引用指向子类型对象
7.1多态格式
public class Demo5 {
public static void main(String[] args) {
//父类型引用 person 指向子类型对象 new Student5();
//把new Student5()的地址给了 person
//Student属于Person
//执行方法时执行的是子类对象的方法，若子类没有该方法就执行父类的该方法
Person5 person=new Student5();
person.say();
}
}
class Person5 {
public void say(){
System.out.println("Person5 say方法执行");
}
}
class Student5 extends Person5{
@Override
public void say() {
System.out.println("Student5 say方法执行");
}
}
7.2向上向下转型
向上转型：将子类实例变成父类实例
格式： 父类 父类名称=new 子类对象
向下转型：将父类实例变成子类实例
格式： 子类 子类名称=(子类)new 父类对象
8、Object类
8.1 概念
Object类是所有类型的父类，如果一个类没有明确继承某一个类，那么默认继承Object类
例：
public class Student{
}
======
public class Student extends Object{
}
9、内部类（了解即可）
9.1概念
在Java程序中，可以将一个类定义在另一个类或者方法里面，这样成为内部类
9.2 成员内部类
特点：成员内部类可以无条件访问外部类的属性和方法，包括private成员和静态成员
class Out{
private String name;
//成员内部类
class In{
public void say(){
System.out.println(name);
}
}
}
9.3 匿名内部类
格式：
new 接口名(){
//实现接口的方法
}
10、包装类
10.1 概述
概述：当我们的方法需要一个传入一个Object对象时，我们只有一个int，但是我们调用的方法需要传入的参数是Object类型，我们就创建一个包装类，把int基本类型放入到Integer中，就可以调用方法
10.2 装箱和拆箱
概述：装箱就是把基本类型放入到相对应的包装类中，就是装箱。
拆箱就是把包装类中的相对应的基本类型拿出来，就是拆箱
//装箱
Integer integer = new Integer(100);
//拆箱
integer.intValue();
10.3 自动装箱和自动拆箱
//自动装箱，内部会自动把基本数据类型int 100转换为包装类Integer
Integer integer1=100;
//自动拆箱，内部会自动把包装类中的基本数据类型拿出来，变成int类型
int i1=integer1;
11、可变长参数
11.1 格式
语法：
权限修饰符 返回值类型 方法名称(数据类型... 形参名称){
//参数在方法内部，以数组的形式接收
}
public int test(int... nums){
int n=0;
for (int i = 0; i <nums.length ; i++) {
n+=nums[i];
}
return n;
}
12、try catch（捕获异常）
12.1概述：
程序中异常分两种，受检异常（写代码时预知会出现的异常），和非受检异常（运行时可能会出现的异常，也可能不出现），当出现异常时程序会中断，所以我们需要捕获异常来保证程序不中断。
格式：
try{
//可能发生异常的代码段
}catch(异常类型) 对象名1{
//异常的处理操作
}catch(异常类型 对象名2){
//异常的处理操作
}finally{
//无论程序是否出错都会执行finally语句块里的代码段
}
12.2 try catch处理流程
1.当异常发生时，系统会自动创建一个异常类的对象
2.如果发生的异常代码在try中，则会执行自动匹配catch捕获的相对应的异常，如果没有在try中，则会抛出异常
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int i=0;
try{
System.out.println("输入一个数字");
i= scanner.nextInt();
}catch (InputMismatchException e){
//补救措施
System.out.println("必须输入数字默认为1");
i=1;
}finally {
//无论程序是否抛出异常，都会执行finally语句块中的内容
//finally语句块必然执行，在这里我们可以
System.out.println(i);
System.out.println("我是finally语句块中的代码块");
}
}
注意：如果try语句块中没有报错并且有个return，finally语句块中的代码还是会执行！！！
### 12.3 finally执行与不执行的解析
- 当程序正常执行时(finally必然执行)
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int i=0;
try{
System.out.println("输入一个数字");
i= scanner.nextInt();
}catch (InputMismatchException e){
//补救措施
System.out.println("必须输入数字默认为1");
i=1;
}finally {
//无论程序是否抛出异常，都会执行finally语句块中的内容
System.out.println(i);
System.out.println("我是finally语句块中的代码块");
}
}
- 当try中出现异常时(finally必然执行)
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int i=0;
try{
System.out.println("输入一个数字");
i= scanner.nextInt();
}catch (InputMismatchException e){
//补救措施
System.out.println("必须输入数字默认为1");
i=1;
}finally {
//无论程序是否抛出异常，都会执行finally语句块中的内容
System.out.println(i);
System.out.println("我是finally语句块中的代码块");
}
}
- 手动退出JVM（finally不语句块不执行）
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
try{
int a=10;
int b=0;
System.out.println(a/b);//报错执行catch
}catch (InputMismatchException e){
//补救措施
//退出JVM 0代表正常退出
System.exit(0);
}finally {
//此时finally不再执行
System.out.println("我是finally语句块中的代码块");
}
}
12.4 throws 抛出异常
- 当我们写代码时代码可能会发生异常是，我们可以将异常抛出去，抛给调用者来处理异常
public static void main(String[] args) {
//当我们不处理异常时会爆红，说该方法可能会发生IO异常，需要我们提前处理
Demo3.shutdown("0");
}
//关机方法 上抛IO异常让调用者来处理
public static void shutdown(String s1) throws IOException {
Runtime.getRuntime().exec(s1);
}
12.5 throw 创建一个异常
格式：
public static void main(String[] args) {
Person3 person3 = new Person3();
person3.setAge(-1);
}
class Person3{
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
if(age<0 || age>100){
//年龄不合理我们创建一个异常
throw new RuntimeException("年龄不合理");
}
this.age = age;
}
}
12.6 自定义异常(了解内容)
- 当程序出错时，可以throw 我们自定义的运行时异常
public class MyException extends RuntimeException{
//自定义非受检异常 RuntimeException
public MyException(String message){
super(message);
}
}
- 受检异常:写代码时会体现预知这个地方会有异常出现
public class MyException extends Exception{
//自定义受检异常 RuntimeException
public MyException(String message){
super(message);
}
}
总结
提示：面向对象篇已经更新完毕，喜欢的留下jio印，后面的内容会陆陆续续更新！！！