Java-类

最新推荐文章于 2022-06-23 08:29:22 发布
最新推荐文章于 2022-06-23 08:29:22 发布
阅读量234 收藏
点赞数
分类专栏： Java 文章标签： java 类 抽象类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangxuelong461/article/details/103824815
版权

类，对象

  • 类中可以包含:
    所有对象所共有的属性/特征--------成员变量
    所有对象所共有的行为-------------方法

  • 一个类可以创建多个对象
    同一类型所创建的对象，结构相同，数据不同

  • 类是对象的模板，对象是类的具体的实例

  • 补充

    1. 同一个文件中可以包含多个类

    2. public修饰的类只能有一个

    3. public修饰的类的名称必须与文件名相同

   

类的构造方法

  1. 给成员变量赋初值

  2. 与类同名，没有返回值类型

  3. 在创建(new)对象时被自动调用

  4. 若自己没有定义构造方法，则默认一个无参构造方法；
    若自己定义了构造方法，则不再默认提供

  5. 构造方法可以重载

    class Student{
	  String name; //成员变量
	  int age;
	  String address;
	
	  Student(){
	    this("无名氏",1,"未知");
	  }
	  Student(String name){
	    this(name,1,"未知");//调用下面的构造方法
	  }
	  Student(String name,int age,String address){
	    this.name = name;
	    this.age = age;
	    this.address = address;
	  }
	
	  void study(){          
	    System.out.println(name+"在学习...");
	  }
	  void sayHi(){                    
	    System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
	  }
}

this

  1. this:
    指代当前对象，哪个对象调用方法它指的就是哪个对象
    只能用在方法中，方法中访问成员变量之前，默认有个this
  2. this的用法：
    1）this.成员变量名-----------访问成员变量
    2）this.方法名()--------------调用方法（不用）
    3）this()--------------调用构造方法

null

null:空，没有指向任何对象
若引用的值为null，则该引用不能再进行任何操作了，
若操作则发生NullPointerException空指针异常

   

继承

  1. 作用：代码复用

  2. 通过extends来实现继承

  3. 超类/父类：派生类所共有的属性和行为
    派生类/子类：派生类所特有的属性和行为

  4. 派生类继承超类后，派生类具有：派生类和超类的所有属性和方法

  5. 一个超类可以有多个派生类，一个派生类只能继承一个超类--------单一继承
    （不支持多继承–class C extends A,B—错误！）

  6. 继承具有传递性(多重继承):
    A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类

  7. java规定：
    在构造派生类之前必须先构造超类；
    在派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法
    在派生类中的构造方法中若调用了超类的构造方法，则不再默认提供
    super()调用超类的构造方法必须位于派生类构造方法的第一行
    示例：

    class A{
	A(){
		
	}
}
class B extends A{
	B(){
		//super();//这句话是默认的
	}
}

super的用法

1）super.成员变量名---------------访问超类的成员变量
2）super.方法名()-------------------调用超类的方法
3）super()----------------调用超类的构造方法

   

向上造型

  1. 超类型的引用指向派生类的对象
  2. 能点出来什么，看引用的类型
  3. 向上造型后能访问到的子类成员只有重写的普通方法

   

package

  1. 作用：避免类名的冲突

  2. 包名可以有层次结构（如:包名是oo.day01），同包中的类不能同名

  3. 类的全称：包名.类名

  4. 建议：包名所有字母都小写
    域名反写 . 项目名称 . 模块名称 . 类名
    cn.xxx . projecta . stumanager .
    cn.xxx . projecta . teachmanager .

import

  1. 同包中的类可以直接访问

  2. 不同包中的类不能直接访问，想访问：

    1. 先import声明类，再访问类
    2. 类的全称-------太繁琐、不建议

   

访问控制修饰符

  1. public：公开的，任何类

  2. private：私有的，本类

  3. protected：受保护的，本类、派生类(子类)、同包类

  4. 默认的：什么也不写，本类、同包类

说明：
1. 类的访问修饰符只能是public或默认的
2. 类中成员的访问修饰符上面4种都可以
3. 派生类(子类)方法的访问权限要大于或等于超类(父类)方法的

一般情况：
1. 数据（成员变量）私有化（private）
2. 行为（方法）公开化（public）

   

final

最终的、不能改变的---------------单独应用几率极低

  1. 修饰变量：变量不能被改变

  2. 修饰方法：方法不能被重写

  3. 修饰类：类不能被继承

示例：

package oo.demo;
//final的演示
public class FinalDemo {
	public static void main(String[] args) {
	
	}
}
//演示final修饰类
final class Joo{}
//class Koo extends Joo{} //编译错误，final的类不能被继承
class Loo{}
final class Moo extends Loo{}

//演示final修饰方法
class Hoo{
	final void show() {}
	void test() {}
}
class Ioo extends Hoo{
	//void show() {} //编译错误，final的方法不能被重写
	void test() {}
}

//演示final修饰变量
/*
 * final修饰成员变量，只有如下两种初始化方式:
 *   1)声明同时初始化
 *   2)在构造方法中初始化
 * final修饰局部变量，只要在用之前初始化即可
 */
class Goo{
	final int num = 5;
	final int count;
	Goo(){
		count = 5;
	}
	void show() {
		final int number;
		//num = 55; //编译错误，final的变量不能被修改
	}
}

   

staic

  1. 静态变量

    1. 由static修饰
    2. 属于类,存储在方法区中，只有一份
    3. 常常通过类名.来访问
    4. 何时用：所有对象所共享的数据（图片、音频、视频等）

  2. 静态方法

    1. 由static修饰
    2. 属于类，存储在方法区中，只有一份
    3. 常常通过类名.来访问
    4. 静态方法中没有隐式this的传递，静态方法中不能直接访问实例成员

  3. 静态块

    1. 由static修饰
    2. 属于类，在类被加载时自动执行，只执行一次
    3. 何时用：加载/初始化静态资源（图片、音频、视频等）

  4. cookie:
    静态变量------------一般在静态块中初始化
    实例变量------------一般在构造方法中初始化

    成员变量:

    1. 实例变量:没有static修饰，属于对象的，存储在堆中，
      有几个对象就有几份
      通过对象点来访问

    2. 静态变量:由static修饰，属于类的，存储在方法区中，
      只有一份
      通过类名点来访问

       java中Math.sqrt是静态方法(只传参数就可以,不需要创建对象)
 double d = Math.sqrt(25);

示例：

package oo.demo05;
	//static的演示
	public class StaticDemo {
		public static void main(String[] args) {
			Aoo o1 = new Aoo();
			o1.show(); //1,1
			Aoo o2 = new Aoo();
			o2.show(); //1,2
			Aoo o3 = new Aoo();
			o3.show(); //1,3
			System.out.println(Aoo.b); //常常通过类名点来访问
	
			//Boo.test(); //常常通过类名点来访问
		   
            下面三句话打印出：静态方法 构造方法 构造方法 构造方法
			Coo o1 = new Coo();
			Coo o2 = new Coo();
			Coo o3 = new Coo();//静态方法是存在方法区中的，只有一份
			
		}
	}
	class Aoo{ //演示静态变量
		int a;
		static int b;
		Aoo(){
			a++;
			b++;
		}
		void show() {
			System.out.println(a+","+b);
		}
	}

	class Boo{ //演示静态方法
		int a;
		static int b;
		void show() { //有隐式this
			System.out.println(a); //this.a
			System.out.println(b);  //Boo.b
		}
		static void test() { //没有隐式this
			//静态方法没有隐式this传递
			//没有this就意味着没有对象
			//而实例变量a必须通过对象来问的
			//所以此处编译错误
			//System.out.println(a);
			System.out.println(Boo.b);
		}
	}

	class Coo{ //演示静态块
		static {
			System.out.println("静态块");
		}
		Coo(){
			System.out.println("构造方法");
		}
	}

   

static final 常量：应用率最高

  1. 必须声明同时初始化
    如：static final int age = 20;

  2. 由类名.来访问，不能被改变

  3. 建议：常量名所有字母都大写，多个单词用_分隔

  4. 编译器在编译时会将常量直接替换为具体的值，效率高
    （注意：如果是静态变量，会将类Eoo.class加载到方法区中，将静态变量一并存储到方法区中;常量则没有存储过程）

  5. 何时用：数据永远不变，并且经常使用

注意：
  1. 执行静态块必须加载类，加载类必须是调用构造器或者访问静态成员
  2. 每次执行构造器前执行实例块
  3. 静态块优先实例块执行
  4. 静态块和静态变量没有先后顺序，谁在前面谁先执行
结论：
  1. 父类静态变量和静态块（先声明的先执行）
  2. 子类静态变量和静态块（先声明的先执行）
  3. 父类的变量和代码块（先声明的先执行）
  4. 父类的构造方法
  5. 子类的变量和代码块（先声明的先执行）
  6. 子类的构造方法

示例：

package oo.day05;
//static final常量的演示
public class StaticFinalDemo {
	public static void main(String[] args) {
		System.out.println(Doo.PI); //通过类名点来访问
		//Doo.PI = 3.1415926; //编译错误，常量不能被改变

		//1)加载Eoo.class到方法区
		//2)静态变量num一并存储到方法区中
		//3)到方法区中获取num的值并输出
		System.out.println(Eoo.num);
	
		//编译器在编译时将常量直接替换为具体的值，效率高
		//相当于System.out.println(5);
		System.out.println(Eoo.COUNT);
	
	}
}

class Eoo{
	public static int num = 5; //静态变量
	public static final int COUNT = 5; //常量
}

class Doo{
	public static final double PI = 3.14159;
	//public static final int NUM; //编译错误，常量必须声明同时初始化
}

   

成员内部类—应用率低

  1. 类中套类，外面的类称为Outer外部类，里面的类称为Inner内部类

  2. 内部类通常只服务于外部类，对外不具备可见性（在外面无法访问内部类）

  3. 内部类对象通常是在外部类中创建的

  4. 内部类中可以直接访问外部类中的成员(包括私有的)
    内部类中有个隐式的引用指向了创建它的外部类对象，语法：外部类名.this

示例：

package oo.demo;
//成员内部类的演示
public class InnerClassDemo {
	public static void main(String[] args) {
		Mama m = new Mama();
		//Baby b = new Baby(); //编译错误，内部类对外不具备可见性
	}
}

class Mama{
	private String name;
	void createBaby() {
		Baby b = new Baby(); //内部类对象需要在外部类中创建
	}
	class Baby{
		void showMamaName() {
			System.out.println(name); //内部类中可以直接访问外部类的成员
			System.out.println(Mama.this.name); //隐式的引用(外部类名.this)
			//System.out.println(this.name); //编译错误，this代表当前对象，当前类中没有name属性
		}
	}
}

   

匿名内部类：应用率高

  1. 若想创建一个类（派生类）的对象，并且对象只被创建一次，此时类不必命名，称为匿名内部类

  2. 在匿名内部类中访问外部的变量，要求该变量必须是final的（jdk1.8以前的版本）

示例：

package oo.demo;
//匿名内部类的演示
public class NstInnerClassDemo {
	public static void main(String[] args) {
		//1)创建了Foo的一个派生类，但是没有名字
		//2)创建了该派生类的一个对象，名为o1
		//3)大括号中的为派生类的类体
		Foo o1 = new Foo() {
			//
		};
	
		int num = 5;
		//1)创建了Foo的一个派生类，但是没有名字
		//2)创建了该派生类的对象，名为o2
		//3)大括号中的为派生类的类体
		Foo o2 = new Foo() {
			void test() {
				System.out.println(num); //jdk1.8以前的版本时，要求num必须是final的
			}
		};
	
	}
}
//抽象类，不允许实例化
abstract class Foo{
	//
}
注意：内部类由独立的.class吗？

有
Mama$Baby.class
NstInnerClassDemo$1.class
NstInnerClassDemo$2.class

   

抽象方法

  1. 由abstract修饰

  2. 只有方法的定义，没有具体的实现（连{}都没有）

  3. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

抽象类

  1. 由abstract修饰

  2. 包含抽象方法的类必须是抽象类；不包含抽象方法的类也可以声明为抽象类-----我乐意

  3. 抽象类不能被实例化

  4. 抽象类是需要被继承的，派生类（子类需要：）

    1. 重写所有的抽象方法
    2. 也可以声明为抽象类------------一般不这么用

  5. 抽象类的意义：

    1. 封装派生类共有的属性和行为---------代码复用
    2. 为所有派生类提供统一的类型--------向上造型
    3. 可以包含抽象方法，为所有派生类提供统一的入口。（派生类的具体实现不同，但入口是一致的）

设计规则

  1. 将派生类共有的属性和行为抽到超类中--------抽共性
  2. 所有派生类的行为都一样，设计为普通方法；所有派生类的行为不一样，设计为抽象方法
  3. 将部分派生类所共有的行为，抽到接口中。符合既是也是原则时，使用接口，接口是对继承的单根性的扩展----实现多继承

类中的变量

  1. 实例变量:
    1.类中，方法外
    2.创建对象时存储在堆中，对象被回收时一并被回收
    3.有默认值

  2. 局部变量:
    1.方法中
    2.方法被调用时存储在栈中，方法调用结束时与栈帧一并被清除
    3.没有默认值

局部内部类不能使用该方法的局部变量

public static void main(String[] args) {
/*
 * java有一个语法要求：
 * 当一个方法的局部内部类当中使用了该方法的其他局部变量时，要求这个变量必须是final的
 * JDK8之后，final关键字可以不写，但是这个语法还在。这意味着局部内部类中是不能修改该变量的值的
 * 如果要修改，只能将该变量定义为属性(或挪到该方法之外的其他地方定义)
 */
// final boolean isFinish = false;
Thread download = new Thread() {
	public void run() {
		System.out.println("down:开始下载图片...");
		for(int i=1;i<=100;i++) {
			System.out.println("down:"+i+"%");
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("down:图片下载完毕");
		isFinish = true;
	}
};
雨醉东风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 常见的OOM类型总结
qq_28834355的博客
06-18 587
文章目录StackOverflowErrorJava heap spaceGC overhead limit exceededMetaspace StackOverflowError 说明：栈空间溢出 举例：递归无限调用，不设置结束点，会导致栈空间爆满 public static void stackOverflowError(){ stackOverflowError(); } Java heap space 说明：堆空间溢出 举例：设置最大堆空间10m，然后创建一个2
Java中的类
weixin_52821030的博客
11-01 546
1.什么是类？ 1.类---类型---数据类型---复合数据类型---自定义复合数据类型 基本数据类型就8中，在开发中远远不够，所以我们就需要一个可以根据自己的需求随时能制作出一个自己需要的数据类型。 2.将性质或特征相同的元素抽象出来的事物，在java中用来描述具有性质或特质相同的元素，抽象出来的自定义复合数据类型 2创建java类 通过class关键字创建java类 格式：【public】class类名{} ...
java 有哪些类_Java语言有哪些类别？
weixin_42676678的博客
02-20 278
当客户程序需要与服务器程序通讯的时候，客户程序在客户机创建一个socket对象，Socket类有几个构造函数。两个常用的构造函数是 Socket(InetAddress addr, int port) 和 Socket(String host, int port)，两个构造函数都创建了一个基于Socket的连接服务器端流套接字的流套接字。对于第一个InetAddress子类对象通过addr参数获得...
Java常用类
weixin_42024952的博客
05-16 1005
System类： System类代表当前Java程序的运行平台，程序不能创建System类的对象， System类 提供了一些类变量和类方法，允许直接通过System类来调用这些类变量和类方法。 获取系统所有环境变量： 用map来接收，遍历它 我们也可以拿出具体的： System.out.println(System.getenv(“JAVA_HOME”)); 获取属性的方法; 也可以指定要拿...
Java OOM 类型
小单的博客专栏
03-05 963
1、java.lang.OutOfMemoryError: PermGen space 说明 PermGen space的全称是Permanent Generation space,是指内存的永久保存区域。用于存放Class和Meta的信息,GC(Garbage Collection)不会在主程序运行期对PermGen space进行清理，所以如果你的APP会LOAD很多CLASS的话,就很可能...
java内部类的相关知识点
风小猪的博客
09-03 216
Java的内部类 1. 内部类的介绍 依据《Java核心技术》中所说，内部类即是一个定义在另一个类中的类，使用内部类的主要原因在于： 内部类的方法可以访问该类定义所在的作用域中的数据，包括私有的数据 内部类可以对同一个包中的其他类进行隐藏起来 如果我们想要定义一个回调函数，而又不想编写大量的代码，那么我们可以使用匿名内部类比较便捷 我们首先来看一个简单的内部类的例子 package com.feng; public class OuterClass { private int age = 10
java基础学习-类
qq_48390851的博客
07-12 101
1.抽象类 具体实现，规范（抽象方法） 有抽象方法的类只能定义成抽象类 抽象类不能实例化，即不能用new来实例化抽象类 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。 抽象类只能用来被继承。 抽象方法必须被子类实现 2.接口 比抽象类更抽象的规范，将规范和实现彻底分离。接口：规范，普通类：具体实现 接口里面只能定义抽象方法和常量，抽象方法默认前面带有**“public abstract void fly()”**修饰，而常量默认前面带有“publ
java-websocket jar包
07-11
总结来说，`java-websocket` jar包为Java和Android开发者提供了实现WebSocket通信的简单途径，`WebSocketUtils.java`工具类进一步简化了这个过程。通过理解和使用这个库，开发者可以轻松构建实时通信的应用，如在线...
mysql-connector-java-5.1.30工具
04-19
2. **添加到项目**：将`.jar`文件添加到Java项目的类路径（ClassPath）中，对于Maven项目，可以在`pom.xml`中添加依赖： ```xml <groupId>mysql <artifactId>mysql-connector-java <version>5.1.30 ``` 3. ...
java-11 windows-x64 安装包
03-05
5. **字符串重复**：新增`String`类的`repeat()`方法，可以轻松创建重复的字符串，提高编码效率。 6. **ZGC（Z Garbage Collector）**：这是一个实验性的低延迟垃圾收集器，适合大内存应用，它的目标是在高负载下...
Java-JDK-11.0.8(Windows &amp; Mac os) 下载
09-19
1. **模块化系统（Project Jigsaw）**：通过将JDK拆分为模块，提高了可维护性和安全性，同时也为优化类路径和启动时间提供了可能。 2. **本地变量类型推断（var关键字）**：在Java 11中，可以使用`var`关键字声明...
java源码包---java 源码 大量 实例
04-18
　Java二进制IO类与文件复制操作实例，好像是一本书的例子，源代码有的是独立运行的，与同目录下的其它代码文件互不联系，这些代码面向初级、中级Java程序员。 Java访问权限控制源代码 1个目标文件 摘要:Java源码,...
学习Java（5）之面向对象
我的博客
05-25 500
1.第一题 Student.java public class Student { String name, sex; int age; //构造方法 Student(String name,String sex,int age){ this.name = name; this.sex = sex; this.age = age; } void setAge(int age) { this.age = age; } int getAge() { return age;
Java实验02 面向对象（上）
将~军的博客
11-21 1万+
实验二 面向对象（上） 实验2-1 定义学生类 一、实验描述 1、 考核知识点 名称：类和对象 2、 练习目标  掌握类定义的方式  掌握如何在类中定义成员变量和成员方法 3、 需求分析 在面向对象的思想中最核心就是对象，在程序中创建对象的前提是需要定义一个类。本实验设计一个表示学生的类，该类具有表示姓名的属性name和表示年龄的属性age，同时还具有表示说话行为的方法speak()，用于输出学生的姓名和年龄。 4、 设计思路（实现原理） 1）使用class关键字定义一个表示学生类型的类，类名为Stu
Java语言基础复习
m0_64714024的博客
06-23 137
语言基础
【Java进阶知识】Java中涉及到的对象比较
Moo_Lavender的博客
11-25 291
在Java中，我们常常涉及到对象的比较问题，总体来说就两种：一种是比较是否相等，另一种就是比较两个对象之间的大小关系。接下来一一介绍： 一、相等比较 通常我们在比较两个对象是否相等时，用到的就是“==”运算符和Object类下的equals方法。有关于这二者的区别，大家可以参考我的另一篇博客—>hashCode，equals，== 三者的区别是什么？ 这里简单的来说，==运算符通常是比较...
面向对象OOP
Healer_小振的博客
10-30 329
面向对象（OO） 面向对象分析（OOA） 面向对象设计(OOD） 面向对象分析与设计（OOAD） 面向对象编程（OOP） 面向对象： 1.类和对象 1）定义：现实生活是有很多对象组成的，基于对象抽出了类 2）对象：真实存在的单个个体/东西 类：代表一类个体 3）类：是对象的模板/模子，对象是累的具体实例 是一钟引用数据类型 4）类中可以包含： （1）对象所共有的属性/数据------变量（实例变量、静态变量） （2）对象所共有的行为/动作------方法 5）一...
java泛型
weixin_33957648的博客
09-27 807
什么是泛型？ 泛型（Generic type 或者 generics）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。 可以在集合框架（Collection framework）中看到泛型的动机。例如，Map 类允许您向一个 Map 添加任意类的对象，即使最...
SpringBoot-项目4-购物车(添加入购物车，购物车列表，购物车商品数量加减操作)
热门推荐
zhangxuelong461的博客
03-02 2万+
64. 购物车-创建数据表 # 注意：没有添加相应的not null约束 CREATE TABLE t_cart ( cid INT AUTO_INCREMENT COMMENT '购物车数据id', uid INT COMMENT '用户id', pid INT COMMENT '商品id', num INT COMMENT '商品数量', price BIGINT(20) ...
java -jar详解
最新发布
05-17
当我们执行java -jar命令时，Java虚拟机会读取Manifest文件中的Main-Class属性，并执行这个类的main方法。 需要注意的是，使用java -jar命令来运行Java应用程序时，当前工作目录会被设置为jar文件所在的目录。因此...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值