当前位置：主页 > 查看内容

Java基础篇之面向对象篇(2021)

发布时间：2021-05-11 00:00| 有位朋友查看

简介：文章目录前言一、面向对象基础 1、面向对象思想 2、三大特性 3、类与对象 4、对象创建时内存 5、构造方法构造器 6、方法的重载 7、匿名对象二、面向对象进阶 1、封装private 2、this关键字this指的是当前对象 3、静态static 4、包可以理解为文件夹 4、导……

文章目录

前言
一、面向对象基础
二、面向对象进阶
三、面向对象高级
总结

前言

一、面向对象基础

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语句块中的内容
            System.out.println(i);
        }
    }

总结

提示：面向对象篇已经更新完毕，喜欢的留下jio印，后面的内容会陆陆续续更新！！！

；原文链接：https://blog.csdn.net/m0_50677223/article/details/115405029
本站部分内容转载于网络，版权归原作者所有，转载之目的在于传播更多优秀技术内容，如有侵权请联系QQ/微信：153890879删除，谢谢！

上一篇：JVM结构--类加载 下一篇：没有了

随机推荐

ASP上传漏洞之利用CHR(0)绕过扩展名检测

今天Demon 提到了这个问题，正好想到之前看到的一篇文章《Automatic file uploa...
Firefox 火狐浏览器 86.0.1 发布：修复 L

3月13日消息Mozilla 已经发布了 Firefox 火狐浏览器的 86.0.1 更新，此次更新...
如何轻松的在Linux中运行Windows的.exe文

Wine 6.0稳定版已于几天前发布，作为在Linux、Mac OS和BSD上运行Windows应用程序...
勇立潮头推动国产数据库产业崛起

随着国际环境日趋复杂，数据安全与信息技术发展成为发展首要任务。目前，随着信...
让 FCKeditor 支持多用户Web环境(以PHP为

只能在/userfiles/文件夹下。对于多用户会员系统的网站系统，这显然是不合适的，...
配置Chrome支持本地（file协议）的AJAX请

什么问题 WEB开发过程中，很多时候我们都是写一些简单的Demo，并不是开发一个完...
Yii redis集合的基本使用教程

前言 redis 的集合是无序的，集合成员是唯一的，不能重复。用户可以快速地对集合...
Bundle类及应用Intent传递数据（Android

一、Bundle类 Bundl类是为字符串与某组件对象建立映射关系的组件它与Intent配合...
Ajax的简单实用实例代码

我将实现一个简单的Ajax页面无刷新进行用户验证案例：效果如下图：实现主要过...
Windows 10 太阳谷更新界面猜想：圆角弹

微软计划于今年发布 Windows 10 21H1 更新，但下一代 21H2太阳谷将会带来更多的 ...

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处理流程

总结

推荐图文

随机推荐

关于我们

7、多态