Java笔记_基础_对象和类

最新推荐文章于 2022-01-25 20:29:28 发布
最新推荐文章于 2022-01-25 20:29:28 发布
阅读量68 收藏
点赞数
分类专栏： java笔记 文章标签： java 类 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YWXKSJHX/article/details/115557156
版权

文章目录

类/方法

class

class Demo { //定义一个叫 Demo 的类 如果被 public 修饰则要求该文件的文件名必须与该类名相同

	int i = 10; //成员变量 类中方法外 这个类公用的变量
	
	public Demo() { //构造方法 与类同名 不用加返回值 是在其他类创建这个类时调用 可以无参或有参
	}
	
	public static int a(int a) { //public static:权限修饰符 int:返回值类型(void:无返回值) a:方法名称 (int a):输入的参数((int... a):可变参数可以添加多组数据,底层为数组)
		return 15; //返回值为15 返回值为我们调用这个方法所得到的结果
	}
}

一个类就相当于一个Java文件
Java方法是Java代码块在一起执行一个功能
一般类名采用大驼峰命名法,而方法采用小驼峰命名法
大驼峰命名法: 首字母大写 之后每个单词首字母大写
小驼峰命名法: 首字母小写 之后每个单词首字母大写

修饰符

default //默认   在同一包内可用(可以不用写)
private //私有   只在本类中可用
public //公开   所有类都可用
protected //保护   只在本类和继承本类的子类中可用
static //静态   代码块:与类一起加载只执行一次  变量:无论声明多少对象变量都为同一个  方法:类名.方法名可以直接调用(静态方法不能使用非静态变量) 被 static 所修饰的内容都为单例,即只有一个对象
final //最终   变量:不可改变  成员变量:直接赋值或在构造方法中赋值  方法:可以被继承,但不能被重写  类:不能被继承
abstract //抽象   方法:无内容,必须由子类重写  类:有抽象方法必须为抽象类

枚举:

enum

public enum Season {
	SPRING("春"){ //枚举是静态的,可以直接"枚举类.枚举项"调用
		@Override //每个枚举项都是该枚举类的对象,故若枚举类中有抽象方法则枚举项中必须重写
		public void show() {
			System.out.println(this.name);
		}
	},
	SUMMER("夏"){
		@Override
		public void show() {
			System.out.println(this.name);
		}
	},
	AUTUMN("秋"){
		@Override
		public void show() {
			System.out.println(this.name);
		}
	},
	WINTER("冬"){
		@Override
		public void show() {
			System.out.println(this.name);
		}
	};

	public String name; //枚举项的定义必须在枚举类开头,变量需定义在枚举项之下

	private Season(String name){ //构造方法
		this.name = name;
	}

	public abstract void show(); //抽象方法
}

枚举类.枚举项名.name();获取枚举项名
枚举类.枚举项名.ordinal();返回该枚举索引值
枚举类.枚举项名.compareTo(枚举对象);比较两个枚举项 返回索引的差值
枚举类.value();获取所有枚举项 返回枚举类[]
Enum.valueOf(class, 枚举项名);获取枚举类中的枚举项 Enum:所有枚举类的父类

泛型

<?>泛型通配符,可以匹配所有类型 <? extends 类名>匹配该类和其所有父类泛型 <? super 类名>匹配该类和其所有子类泛型

public class Demo {
    public static void main(String[] args) {
        String s = "ABC";
        B b = new B();
        A<String> a = new A<>(s); //这里指定 E 为String字符串类型 所以构造方法输入的参数 s 为String字符串类型
        A<B> ab = new A<>(b); //这里指定 E 为B这个类 所以构造方法输入的参数 b 为B这个类的对象

        System.out.println(a.e); //ABC 这里的 e 是String字符串类型 内容为"ABC"
        System.out.println(ab.e); //BCD 这里的 e 表示的是B这个类的对象 内容为B这个类的toString方法输出的"BCD"
        System.out.println(ab.b(s)); //ABC 这里指定 T 为String字符串类型 此处打印的是 A这个类 的b方法的返回值
    }
}

class A<E> { //指定E为泛型,一般用单个大写字母表示 表示通配任意类型
    public E e;

    public A(E e) { //此处E与创建类时所指定的E的类型一样
        this.e = e;
    }

    public <T> T b(T t) { //指定T为泛型,与E无关
        return t;
    }
}

class B {
    @Override
    public String toString() {
        return "BCD";
    }
}

泛型表示可以通配任意类型对象

注解

//元注解: 标注注解的注解
@Target({ElementType.FIELD, ElementType.TYPE, ElementType.METHOD}) //指定注解使用的位置(成员变量, 类, 方法)
@Retention(RetentionPolicy.RUNTIME) //指定该注解的存在时间
@Inherited //指定该注解可以被继承
pulic @interface 注解名{ //声明这是一个注解
	属性类型 属性名() default 默认值;
	属性类型 属性名(); //若没有赋默认值,则需定义时赋值
	String value(); //特殊: 若只有value需要赋值，则value可以省略，直接写定义值
}

@Override重写方法
@Deprecated方法过时
@SuppressWarnings(value = "all")压制警告

内部类

类中的类

成员内部类

类名.内部类名 对象名 = 外部类对象.new 内部类名();

public class Demo {
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        Demo1.Demo2 demo2 = new Demo1().new Demo2(); //创建 Demo1的内部类Demo2 的对象
        System.out.println(demo1.a); //10
        System.out.println(demo2.a); //15
    }
}

class Demo1 {
    int a = 10;
    class Demo2 {
        int a = 15;
    }
}

静态成员内部类

类名.内部类名 对象名 = new 外部类名.内部类名();

public class Demo {
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        Demo1.Demo2 demo2 = new Demo1.Demo2(); //创建 Demo1的静态内部类Demo2 的对象
        System.out.println(demo1.a); //10
        System.out.println(demo2.a); //15
    }
}

class Demo1 {
    int a = 10;
    static class Demo2 {
        int a = 15;
    }
}

匿名内部类 / lambda表达式

匿名内部类: 没有类名的内部类 一般由创建对象时创建内部类来重写其方法

public class Demo {
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1() { //使用匿名内部类的方式重写 Demo1 中的抽象方法并创建对象
            @Override
            public int a(int a) {
                return a + 1;
            }

            @Override
            public int b(int a) {
                return a - 1;
            }
        };
        System.out.println(demo1.a(10)); //11
        System.out.println(demo1.a(10)); //9
    }
}

class Demo1 {
    int a(int a) {
        return 1;
    }

    int b(int a) {
        return 2;
    }
}

lambda表达式: 匿名内部类的简化书写方式 要求外部类只能为接口,并且有且只有一个抽象方法

public class Demo {
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1() { //匿名内部类
            @Override
            public int a(int a) {
                return a + 1;
            }
        };

        Demo1 demo11 = (a) -> { //lambda表达式 意义与上方匿名内部类完全相同 可省略大部分重复代码 (变量名) -> {代码块}
            return a + 1;
        };

        System.out.println(demo1.a(10)); //11
        System.out.println(demo11.a(10)); //11
    }
}

interface Demo1 {
    int a(int a);
}

面向对象

封装

new

import java.util.Random; //导包 说明我们用到的类的位置(全类名)

public class Demo {
    public static void a() {
        Random r = new Random(); //类名 对象名 = new 类名(); 创建一个类的对象 即将此类封装成一个叫 r 的对象
		int a = r.nextInt(100); //对象名.方法名 调用这个对象的这个方法 可以用一个变量承接返回值
    }
}

静态方法可直接类名.方法名;调用

继承

extends

public class Demo1 extends Demo { //class 类名 extends 父类:继承父类的非私有的方法和变量(不能多继承,但可以多重继承)
    
    int i = 10;
    
    public void b() {
		int a1 = this.i; //10 this:声明为本类中的变量
		int a2 = super.i; //100 super:声明为父类中的变量
    }

    @Override //重写父类方法 以本类调用此方法时将不再调用父类方法
    public int a() { //需与父类 方法名,参数 都相同
        return 1;
    }
}

class Demo { //父类

	int i = 100;

	public int a(){
		return 12;
	}
}

父类的方法和自己独有的方法都可以调用

抽象

abstract

 class Demo1 extends Demo { //若继承的类有抽象方法则此类必须重写抽象方法

    @Override
    public int b() {
        return 1;
    }
}

abstract class Demo { //有抽象方法的类也必须被abstract修饰
    public int a() {
        return 1;
    }

    abstract int b(); //abstract:定义一个抽象方法
}

抽象方法即没有方法体的方法,由继承此类的类重写

接口

interface
implements

public class Demo1 implements Demo { //implements实现一个接口 可以多实现 所有抽象方法必须被重写
    
    @Override
    public int a() {
        return 1;
    }

    @Override
    public int b() {
        return 0;
    }
}

interface Demo { //interface:定义一个接口 即只有抽象方法的类
    int a();
    int b();
}

接口即只有抽象方法的类
变量默认添加修饰词 public static final开放 静态 最终
方法默认添加修饰词 public abstract开放 抽象 不可用static修饰

多态

父类 对象名 = new 子类

class Demo1 extends Demo {
    public int c() {
        return 1;
    }
    
    @Override
    public int b() {
        return 1;
    }


}

abstract class Demo {
    public int a() {
        return 1;
    }

    abstract int b();
}

可以使用父类变量承接子类对象
但不能调用子类独有方法
{
Demo demo = new Demo1();
demo.a(); //可以
demo.b(); //可以
demo.c(); //不可以
}

异常

弹出异常

throw new 异常名弹出异常

public class Demo {
    public static void main(String[] args) throws Exception { //throws 异常名   跟在在类名之后,表示有可能会遇到该异常,若遇到则抛出给调用者 (Exception 最上级异常,所有异常的父类)
        throw new Exception("异常: Exception"); //弹出异常
    }
}

运行结果：
弹出异常

自定义异常

继承RuntimeException并创建构造方法

public class Demo {
    public static void main(String[] args) throws Exception { //抛出异常
        throw new A("异常: A"); //弹出异常
    }
}

class A extends RuntimeException { //自定义异常 A
    public A(String s) {
	    super(s);
        System.out.println(s);
    }
}

运行结果：
抛出异常

异常处理:

{
try{ //有可能出现异常的代码
}catch(异常名 e){ //捕捉异常之后封装为异常对象并继续运行此处代码
}finally{ //表示不管有没有异常,此处代码一定会执行,除非JVM退出
}
}

public class Demo {
    public static void main(String[] args) {
        try {
            a(); //a方法添加了 throws Exception 若遇到异常将抛出到此处
            System.out.println("未遇到异常A"); //此打印语句在异常之下,若异常未起作用将打印
        } catch (Exception e) {
            System.out.println("遇到异常A");
            e.printStackTrace(); //默认异常处理机制 即打印异常
        } finally {
            System.out.println("异常A 已处理完");
        }
        System.out.println("其他代码");
    }

    public static void a() throws Exception { //抛出异常给调用者
        throw new A("异常: A"); //弹出异常
    }
}

class A extends RuntimeException {

    public A(String s) {
        System.out.println(s);
    }
}

运行结果：
异常处理

杨望星空世纪航行
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础-类与对象
qq_45531687的博客
09-13 61
Java基础-类与对象第六章 介绍类一、类基础1.类的基础格式2.一个简单类二、声明对象三、给对象引用变量赋值四、方法1.添加方法2.返回值3.加入带自变量的方法五、构造函数1.带自变量的构造函数六、this关键字七、垃圾回收八、finalize()方法九、一个堆栈类 第六章 介绍类 一、类基础 类就是对象的模板（template），而对象就是类的 一个实例（instance） 1.类的基础格式 使用关键字class来创建类 2.一个简单类 一个类定义一个新的数据类型 class Box{ doub
java类与对象 学习笔记
yaologos的博客
07-17 296
类与对象 面向对象（Object Oriented） 一、面向对象 三大特性： 封装性：对象的成员属性和行为看做一个不可分割的整体，一些不想让外界看到的方法也隐藏起来 继承性：java是类的单继承，接口的多继承，是从一个基础的类上派生出反应一些特殊性的类，如几何类下面可以包括圆类，正方体类等 多态性：多态是指程序中允许出现重名现象。 方法重载：根据函数参数的不同，允许同名函数完成不同的工作 对...
java最简单最全入门基础笔记(不简单，不全你打我)
热门推荐
javaboy_yl
11-11 14万+
刚开始学习java的时候，可能是一头雾水，不知道从何学起，这里跟大家分享一下!(仅仅只供初级学者学习，大佬勿喷) 一、初始java 1.生活中的程序： 从起床到教室上课的过程 穿衣打扮》起床》洗漱》出宿舍》》吃早餐》到教室 按照特定的顺序去完成某一件事的过程我们叫做生活中的程序 2.计算机中的程序: 一组有序指令的集合,需要和计算机交流就要使用计算机语言，java就是计算机语言的一种 3.java...
Java学习笔记01：Java概述_基础语法
JasonYangQ的博客
08-09 5376
1. Java概述 1.1 Java语言背景介绍（了解） 语言：人与人交流沟通的表达方式 计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言 Java语言是美国Sun公司（Stanford University Network）在1995年推出的计算机语言 Java之父：詹姆斯·高斯林（James Gosling） 2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可：https://www.oracle.com java语言的三个版本： ​ JavaSE: Java 语言的
尚学堂JAVA基础学习笔记_2/2
李英俊小朋友
11-29 5259
尚学堂JAVA基础学习笔记_2/2 文章目录尚学堂JAVA基础学习笔记_2/2写在前面第10章 IO技术1. IO入门2. IO的API3. 装饰流4. IO实战5. CommonsIO第11章 多线程技术1. 概念2. 线程状态3. 线程的优先级4. 守护线程5. 获取线程基本信息的方法6. 并发控制1. 同步2. 死锁3. 并发协作7. 高级主题第12章 网络编程1. 概念2. UDP编程3....
Java基础笔记_Java基础笔记_Java笔记_worthnwg_
10-02
这份"Java基础笔记"涵盖了初学者需要掌握的关键知识点，旨在帮助快速入门Java编程。以下是对这些笔记内容的详细解读： 1. **Java简介**：Java是由Sun Microsystems（现已被Oracle公司收购）于1995年发布的面向对象...
Java Studty.rar_Java笔记_java基础学习
最新发布
09-24
在这个压缩包中，我们可以期待找到一些关键的学习资源，如代码示例和笔记，这些都是理解并掌握Java基础知识的重要工具。 1. **Java简介**：Java是一种面向对象的、跨平台的编程语言，由Sun Microsystems（现为...
java笔记_Java笔记_
10-03
这份"java笔记"是专为初学者设计的，旨在帮助那些对编程没有基础的人快速掌握Java核心技术。笔记采用Ediplus编辑器编写，这是一款轻量级且功能强大的文本编辑工具，非常适合程序员进行代码编写和学习。 首先，Java...
达内Java_笔记整理.rar_Java 达内笔记_Java笔记_java 笔记_笔记_达内
09-23
达内是一家知名的教育机构，其整理的Java笔记通常会覆盖从基础到进阶的各种主题，以系统化的方式帮助学员掌握这门广泛使用的编程语言。 首先，Java的基础知识是必不可少的，这些笔记可能包括变量、数据类型、运算符...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java笔记_根据MySQL表生成Java实体类
YWXKSJHX的博客
01-25 2580
根据MySQL表生成Java实体类
Java笔记_基础_配置文件
YWXKSJHX的博客
04-24 1802
文章目录XMLdtdschemapropertiesJSON XML XML文件是由很多标签组成的,而标签名是可以自定义的 <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <!-- 必须写在第一行第一列 /version="1.0" 这句话必须写 /encoding="UTF-8" 表示该XML文件应该用此编码打开(可不写) /standalone="yes" 是否依赖其他的xml文件yes/no(可不写) --> &l
idea的一些设置
YWXKSJHX的博客
03-20 308
文章目录字体设置背景设置颜色图片控制台背景设置编码设置忽略大小写更新设置启动设置导包设置Maven配置启动过慢解决办法实用插件 截图时idea版本为2019.3.5 字体设置 Settings > Editor > Font Font: 字体样式 Size: 字体大小 Line spacing: 行间距 背景设置 颜色 Settings > Editor > Color Scheme > General Text > Default text
Java笔记_基础语法
YWXKSJHX的博客
03-21 164
喜闻乐见的"Hello World" public class HelloWorld { //定义一个名叫"HelloWorld"的类 public static void main(String[] args){ //main方法: java程序的入口 System.out.println("Hello World"); //打印至控制台 } } public class 类名{ 访问修饰符 权限修饰符 返回值数据类型 方法名(数据类型 数据){ 方法(值); } } 源文件：源.
Java笔记_基础_常用类
YWXKSJHX的博客
04-12 157
文章目录String String
Java笔记_基础_集合
YWXKSJHX的博客
04-17 128
文章目录集合 集合
Java笔记_配置环境变量
YWXKSJHX的博客
03-22 128
目录JDK JDK JDK是 Java 语言的软件开发工具包，是整个java开发的核心，它包含了JAVA的运行环境（JVM+Java系统类库）和JAVA工具。 JDK有很多版本，但我们一般使用JDK8 JDK8官网下载: https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html 但是Java官网在国外，国内下载慢不说，下载10次能失败9次 然后我发现腾讯软件中心也可以下载,直接搜索 JDK 就可以了 ..
Java笔记_框架_MyBatis
YWXKSJHX的博客
04-24 101
文章目录配置驱动 配置驱动 sql语句: CREATE DATABASE Demo; USE Demo; CREATE TABLE Demo( id int PRIMARY KEY, test1 varchar(10), test2 int ); INSERT INTO Demo(id, test1, test2) VALUES (1, "第一个数据", 123); INSERT INTO Demo(id, test1, test2) VALUES (2, "第二个数据", 234); INSERT I
Java笔记_基础_Web
YWXKSJHX的博客
04-23 101
文章目录httpservletHttpServlet配置文件驱动注解驱动@WebServlet("/访问路径") http 网络超文本数据传输协议 不支持中文,传输中文时将字符分割为十六进制的字节以百分号分割而进行传输 URL编码: URLEncoder.encode(String, "编码"); 以指定编码将字符串转换成URL编码 URL解码: URLDecoder.decode(String, "编码"); 将URL编码以指定编码转换成字符串 浏览器 -> 服务器 : 请求 服务器 -> 浏
Java基础笔记：集合、对象、类和包的基本概念
Java 集合方法和基础知识点总结 集合的方法是 Java 中的一种数据结构，用于存储和管理数据。集合的方法包括： 1. size()：获取集合的大小。 2. add()：添加元素到集合中。 3. remove()：删除集合中的元素。 4. set...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值