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

avatar
avatar
云惠网小编
2846
文章
1
评论
2021年4月8日11:19:20 评论 16 次浏览 7775字阅读25分55秒
摘要

提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档文章目录前言一、面向对象1、面向对象思想2、三大特性3、类与对象4、对象创建时内存二、使用步骤1.前言提示:以下是本篇文章正文内容,下面案例可供参考一、面向对象1、面向对象思想1. 面向过程到面向对象的思想层面的转变2. 面向过程关注的是执行过程3. 面向对象关注的是 具备功能的对象4. 面向过程到面向对象,从程序员思想上是 从执行者到指挥者的转变2、三大特性1.封装性:所有的内容外界不可见2.继承性:将其他的功能

8、Object类

在这里插入图片描述

向上转型:将子类实例变成父类实例
格式: 父类  父类名称=new 子类对象
向下转型:将父类实例变成子类实例
格式: 子类  子类名称=(子类)new 父类对象
//创建对象的格式
类名  对象名=new 类名(有参数/无参数);
//要使用对象中的属性和方法
//我们可以把 . 看做成 的 ,也就是 对象名的属性/对象名的方法
对象名.属性
对象名.方法

10.3 自动装箱和自动拆箱

9.2 成员内部类

import 包名.类名
import java.util.Scanner;
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方法");
}
}
package com.study.demo; //指的是当前包路径
public class Demo1 {
}

1. 面向过程到面向对象的思想层面的转变
2. 面向过程关注的是执行过程
3. 面向对象关注的是 具备功能的对象
4. 面向过程到面向对象,从程序员思想上是 从执行者到指挥者的转变

格式:
new 接口名(){
//实现接口的方法
}
  1. 降低程序的偶尔度
  2. 易于程序的扩展
  3. 有利于程序的维护
例:
public class Student{
}
======
public class Student extends Object{
}

二、面向对象进阶

在这里插入图片描述

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() {
}
}
  1. 包的定义:通常由多个单词组成,所有单词字母小写,单词与单词之间用 " . "分割 ,一般命名为:com.公司名.项目名.模块名 …

匿名:没有名字,没有 引用变量来接收堆内存中对象的地址,用一次就再也找不到了。
若一个对象要使用两次及以上,那么我们一定要创建 对象名。

7.1多态格式

4、对象创建时内存

4、导包(import)

  1. 对象的使用
  1. 对象的创建

在这里插入图片描述

1. 提示:当我们的一个对象有一个属性是所有人相同时,那么我们就可以把该属性设置为static属性,static属性属于当前类,不管创建多少个对象,这个static修饰的属性不会改变
带有static关键字的属性存储在方法区中,我们的类设置了static关键字属性,那么我们的这个类就持有static的内存地址,不管创建多少个对象,static的属性都是一致的。
重点:无论这个类创建了多少个对象,这个static静态属性在内存中只有一份!!!

在这里插入图片描述
2. 静态方法(直接通过类.静态方法名来执行,不需要new对象)
提示:静态修饰的方法,被调用时,可能对象还没有被创建
非静态方法可以调用静态方法,而静态方法不能调用非静态方法

interface 接口名称{
全局常量(public static final修饰的属性):
抽象方法:
}

10.1 概述

6、interface(接口)

private String name;
private int age;
public Person3(String name, int age) {
this.name = name;
this.age = age;
}

语法:

三、面向对象高级

public int test(int... nums){
int n=0;
for (int i = 0; i <nums.length ; i++) {
n+=nums[i];
}
return n;
}

9、内部类(了解即可)

public class Demo1 {
//构造代码块
{
System.out.println("我执行在构造方法之前");
}
//静态代码块:类加载的时候(第一次使用),静态代码块执行,因为类只加载一次,所以静态代码块只执行一次
static{
}
//构造方法
public Demo1(){
System.out.println("我执行在构造代码块之后");
}
}
abstract class Test{//抽象类
//抽象方法
public abstract void d1();
}
class Test1 extends Test {
//实现(重写)抽象类中的抽象方法
@Override
public void d1() {
}
}
	权限修饰符 返回值类型 方法名称(数据类型... 形参名称){
//参数在方法内部,以数组的形式接收
}

6、方法的重载

new 类名().方法名()//匿名对象

程序中异常分两种,受检异常(写代码时预知会出现的异常),和非受检异常(运行时可能会出现的异常,也可能不出现),当出现异常时程序会中断,所以我们需要捕获异常来保证程序不中断。
格式:

		//自动装箱,内部会自动把基本数据类型int 100转换为包装类Integer
Integer integer1=100;
//自动拆箱,内部会自动把包装类中的基本数据类型拿出来,变成int类型
int i1=integer1;

5、构造方法(构造器)

1.封装性:所有的内容外界不可见
2.继承性:将其他的功能继承下来
3.多态性:方法的重载本身就是一个多态性的体现

Object类是所有类型的父类,如果一个类没有明确继承某一个类,那么默认继承Object类

10.2 装箱和拆箱

在这里插入图片描述
提示:我们可以看到Student学生类没有写任何属性和方法,但是继承了Person类后,我们可以使用Person类的属性和方法,只有权限修饰符是 public 和protected 子类才可以继承使用

概述:封装是为了保护或防止代码被恶意修改
保护类的属性,不让类以外的程序直接修改访问

在Java程序中,可以将一个类定义在另一个类或者方法里面,这样成为内部类

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

2、super关键字

class Out{
private String name;
//成员内部类
class In{
public void say(){
System.out.println(name);
}
}
}

6.1 格式

2、this关键字(this指的是当前对象)

  1. 用于修饰属性、变量。使用final修饰变量后,变量成为常量,不能再次赋值。
    1.1 使用final修饰变量后,变量成为常量,不能再次赋值。
    1.2 final修饰的局部变量,只能赋值一次(可以先声明,后赋值)
    1.3 final修饰的成员变量,必须在声明时赋值。
  2. final用于修饰类
    2.1 final修饰的类,不能被继承
  3. final用于修饰方法
    3.1 final修饰的方法:不能被子类重写

3、静态static

public interface Demo3 {
//全局常量
public static final int a=0;
//全局常量简写
int a=0;
//抽象方法
public void demo3();
//抽象方法简写
void demo3();
}

12.2 try catch处理流程

try{
//可能发生异常的代码段
}catch(异常类型) 对象名1{
//异常的处理操作
}catch(异常类型 对象名2){
//异常的处理操作
}finally{
//无论程序是否出错都会执行finally语句块里的代码段
}

2、三大特性

7、匿名对象

6.2 面向接口编程

在这里插入图片描述
概述:当我们的方法需要一个传入一个Object对象时,我们只有一个int,但是我们调用的方法需要传入的参数是Object类型,我们就创建一个包装类,把int基本类型放入到Integer中,就可以调用方法
在这里插入图片描述

5、abstract 抽象类

面试题:构造方法、构造代码块和静态代码块执行顺序
静态代码块 – > 构造代码块 – > 构造方法

3、重写(Override)

6、构造代码块


  1. 类的定义格式

提示:构造代码块:随着对象的每次创建,执行一次,并且执行在构造方法之前!
区别于构造方法的是:无论用户调用哪一个构造方法来创建对象,都会执行构造代码块
静态代码块:类加载的时候(第一次使用),静态代码块执行,因为类只加载一次,所以静态代码块只执行一次

在这里插入图片描述

属性定义格式:
属性类型  属性名;
属性定义及赋值格式;
属性类型 属性名=属性值;
方法定义格式:
权限修饰符 返回值 方法名称(形参列表){
//方法体
return 返回值;
}
例如:
public int number(){
int i=10;
return i;
}

9.3 匿名内部类


4、final关键字

class 父类{
}
class 子类 extends 父类{
}

提示:代码中有就近原则,当我们写的变量名一样时,都会找形参的相同变量名,为了起到见名知意,构造器建议写成这样

类必须通过对象才可以使用,对象的所有操作都在类中
类由属性和方法组成:
属性:相当于人的特征 例如:姓名、年龄、爱好...
方法:相当于人的行为 例如:吃饭、睡觉、打豆豆...

特点:成员内部类可以无条件访问外部类的属性和方法,包括private成员和静态成员

3、类与对象

10、包装类

//一个类中定义的方法,是允许 方法重载(相同的方法名称)
//注意:
//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;
}
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);
}
}

执行时机:在创建对象时,自动调用
提示:当我们new对象时,会自动调用该对象的无参数构造方法,若对象中没有创建构造方法会默认创建一个无参数构造方法,如果我们写了有参构造方法或无参构造方法,那么就不会自动创建构造方法(建议自己创建对象时就写入有参无参构造方法)

6.3 全局常量和抽象方法

  1. 抽象类必须使用 abstract class 声明
  2. 一个抽象类中可以没有抽象方法,抽象方法必须写在抽象类中

1. 当我们子类继承了父类时,我们不满足于父类的方法,需要重写父类的方法,叫做重写,当我们重写父类的方法后,我们调用子类的say方法就会先找子类中是否有say方法,如果有调用子类的say方法,没有则调用父类的say方法

9.1概念

7.2向上向下转型

12、try catch(捕获异常)

6.4 接口的实现

public class Demo5 {
public static void main(String[] args) {
Student.say();
}
}
class Student{
public static void say(){
System.out.println("我是静态方法,直接通过 类.静态方法名就可以执行");
}
}

12.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方法执行");
}
}
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);//调用父类的有参数构造方法
}
}

总结

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);
}
}
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{
}
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;
}
}

1、封装private

提示:1. 格式 public class 类名 implements 接口名1,接口名2…{}

4、包(可以理解为文件夹)

文章目录

  • 前言
  • 一、面向对象基础
    • 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处理流程
  • 总结

2. 概念:什么叫做继承,简单来说,子类继承了父类,那么子类可以用父类的东西

一、面向对象基础

11、可变长参数

  1. 一个抽象类不能被实例化(也就是不能被 new 抽象对象类名),当我们子类继承(extends)抽象父类时,必须重写所有父类的抽象方法来加以实现。

11.1 格式

class 类名称{
成员属性;
成员方法;
}

在这里插入图片描述

  1. 属性与方法

提示:父类型引用指向子类型对象

概述:装箱就是把基本类型放入到相对应的包装类中,就是装箱。
拆箱就是把包装类中的相对应的基本类型拿出来,就是拆箱
在这里插入图片描述

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);
}
}

1、面向对象思想

1.当异常发生时,系统会自动创建一个异常类的对象
2.如果发生的异常代码在try中,则会执行自动匹配catch捕获的相对应的异常,如果没有在try中,则会抛出异常

1. 格式:

格式:
abstract class 类名{//抽象类
//抽象方法
public abstract void 方法名();//抽象方法,只声明为实现
}

7、 多态

		//装箱
Integer integer = new Integer(100);
//拆箱
integer.intValue();

1、继承(extends)

8.1 概念

5、权限修饰符

  1. 导包:当我们需要使用某一个包的对象时,但是我们的两个com.study.test和com.study.test2这两个包中都有Person这个类,我们需要导入这个test2包中的Person类,我们就必须要导入test2这个包的Person类

前言

本文转自 https://blog.csdn.net/m0_50677223/article/details/115405029

腾讯云618
avatar
2w 字长文爆肝 JVM 经典面试题!太顶了! java

2w 字长文爆肝 JVM 经典面试题!太顶了!

如果你是中高级程序员,那我相信你一定被面试官问过JVM。下次再被问到JVM,你直接把老周的这篇文章丢给他吧!话不多说,让我们直接进入主题吧。JVM内存结构,常见异常,调优参数,调优...
腾讯云618
匿名

发表评论

匿名网友 填写信息

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: