• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

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

互联网 diligentman 7天前 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处理流程
  • 总结

前言


一、面向对象基础

1、面向对象思想

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

2、三大特性

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

3、类与对象

类必须通过对象才可以使用,对象的所有操作都在类中
类由属性和方法组成:
		属性:相当于人的特征 例如:姓名、年龄、爱好...
		方法:相当于人的行为 例如:吃饭、睡觉、打豆豆...
  1. 类的定义格式
class 类名称{
   成员属性;
   成员方法;
}
  1. 属性与方法
属性定义格式:
   属性类型  属性名;
属性定义及赋值格式;
   属性类型 属性名=属性值;
方法定义格式:
   权限修饰符 返回值 方法名称(形参列表){
   			//方法体
   			return 返回值;
   }
   例如:
   public int number(){
   	int i=10;
   	return i;
   }
  1. 对象的创建
//创建对象的格式
类名  对象名=new 类名(有参数/无参数);
//要使用对象中的属性和方法
//我们可以把 . 看做成 的 ,也就是 对象名的属性/对象名的方法
对象名.属性
对象名.方法
  1. 对象的使用
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、对象创建时内存

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

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静态属性在内存中只有一份!!!

Java基础篇之面向对象篇(2021)
2. 静态方法(直接通过类.静态方法名来执行,不需要new对象)
提示:静态修饰的方法,被调用时,可能对象还没有被创建
非静态方法可以调用静态方法,而静态方法不能调用非静态方法

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

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

  1. 包的定义:通常由多个单词组成,所有单词字母小写,单词与单词之间用 " . "分割 ,一般命名为:com.公司名.项目名.模块名 …
package com.study.demo; //指的是当前包路径

public class Demo1 {
    
}

4、导包(import)

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

5、权限修饰符

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

6、构造代码块

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

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

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{

}

Java基础篇之面向对象篇(2021)
提示:我们可以看到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);//调用父类的有参数构造方法
    }
}

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

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方法");
    }
}

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

4、final关键字

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

5、abstract 抽象类

  1. 抽象类必须使用 abstract class 声明
  2. 一个抽象类中可以没有抽象方法,抽象方法必须写在抽象类中
格式:
	abstract class 类名{//抽象类
		//抽象方法
		public abstract void 方法名();//抽象方法,只声明为实现
	}
	
  1. 一个抽象类不能被实例化(也就是不能被 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 面向接口编程

  1. 降低程序的偶尔度
  2. 易于程序的扩展
  3. 有利于程序的维护

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 概述

Java基础篇之面向对象篇(2021)
概述:当我们的方法需要一个传入一个Object对象时,我们只有一个int,但是我们调用的方法需要传入的参数是Object类型,我们就创建一个包装类,把int基本类型放入到Integer中,就可以调用方法
Java基础篇之面向对象篇(2021)

10.2 装箱和拆箱

概述:装箱就是把基本类型放入到相对应的包装类中,就是装箱。
拆箱就是把包装类中的相对应的基本类型拿出来,就是拆箱
Java基础篇之面向对象篇(2021)

		//装箱
        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语句块中的代码块");
        }
    }

Java基础篇之面向对象篇(2021)
注意:如果try语句块中没有报错并且有个return,finally语句块中的代码还是会执行!!!


### 12.3 finally执行与不执行的解析

  1. 当程序正常执行时(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语句块中的代码块");
       }
   }

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

  1. 当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语句块中的代码块");
        }
    }

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

  1. 手动退出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语句块中的代码块");
       }
   }

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

总结

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


程序员灯塔
转载请注明原文链接:Java基础篇之面向对象篇(2021)
喜欢 (0)