Java学习——第五章 第六章

最新推荐文章于 2021-02-26 15:39:02 发布
最新推荐文章于 2021-02-26 15:39:02 发布
阅读量291 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48562157/article/details/107895658
版权

第五章 高级类的特性2

5.1关键字：static

1.类变量和实例变量

public class Chinese{
    //类变量不用实例化，直接类名.属性名就可以使用，是类的一部分，被所有这个类的实例化对象所共享  也可以叫做静态变量
    static String country;
    
    //实例变量，只有实例化之后才能使用，属于实例化对象的一部分，不能共用。
    String name;
    int age;
}

类变量

在这里插入图片描述

//类变量应用举例
public class Perosn {
    private int id;
    public static int total = 0;
    public Person(){
        total++;
        id = total;
    }
    public static void main(String args[]){
        Person Tom = new Person();
        Tom.id = 0;
        total = 100;//不用创建对象就可以访问静态成员
    }
}

//==================================================\\

public class OtherClass{
    public static void main(String args[]){
        Person.total = 100;//不用创建对象就可以访问静态成员
        //访问方式：类名.类属性，类名.方法
        System.out.println(Person.total);
        Person c = new Person();
         System.out.println(c.total);//输出101
    }
}

类方法

在这里插入图片描述

​ **因为不需要实例就可以访问static方法，因此static方法内部不能有this、super **

​ 重载的方法需要同时为static的或者非static的。

如果想让一个类的所有实例共享数据，就用类变量！！！

2.类属性、类方法的设计思想

在这里插入图片描述

3.单例（Singleton）设计模式——饿汉式

单例模式，软件的运行有且只有一个实例化对象（只会new一次）

public class Single {
	//私有的构造，构造方法私有化，调用这个类的人就不能直接使用new来创建对象
	private Single() {		
	}
	
	//私有的Single类型的类变量
	private static Single single = new Single();
	
	public static Single getInstance() {
		return single;
	}
}

//========================================\\

public class Text {
	public static void main(String[] args) {
        //new只用到了一次
		Single s = Single.getInstance();
		Single s1 = Single.getInstance();
		Single s2 = Single.getInstance();
		Single s3 = Single.getInstance();
		Single s4 = Single.getInstance();
	}

}

饿汉式，是在类加载之后，还没有人调用的时候，就先new好一个对象，以后不论谁来调用getInstance方法，都是直接返回之前new好的那个对象。

4.单例（Singleton）设计模式——懒汉式

public class Single1 {
	//先私有化构造方法，让外边不能直接new对象
	private Single1() {
		
	}
	private static Single1 s1 = null;
	
	public static Single1 getInstance() {
		if(s1 == null) {
			s1 = new Single1();
		}
		
		return s1;
	}

}

//===============================================\\

public class Text {
	public static void main(String[] args) {
		Single1 s = Single1.getInstance();
		Single1 s1 = Single1.getInstance();
		Single1 s2 = Single1.getInstance();
		Single1 s3 = Single1.getInstance();
		Single1 s4 = Single1.getInstance();
	}

}

懒汉式，最开始对象是null，在第一次有人调用getInstance方法是来new对象，以后再有人调用getInstance方法直接就返回之前第一次new好的对象。

5.2再谈main方法

在这里插入图片描述

5.3初始化块

1.初始化块作用

对Java对象进行初始化

2.程序的执行顺序

1.声明成员变量的默认值

2.显示初始化、多个初始化块依次被执行

3.构造器再对成员进行赋值操作

3.静态代码块

​ 静态代码块：一个类中初始化块若有修饰符，则只能被static修饰，称为静态代码块，当类被载入时，类属性的声明和静态代码块先后顺序被执行，且只被执行一次。

//static块通常用于初始化static（类）属性
class Person{
    public static int total;
    static{
        total = 100;//为total赋初始值
    }
    ......//其他属性或方法声明
}

4.静态代码块与非静态代码块的区别

在这里插入图片描述

5.4关键字：final

​ 在Java中证明类、属性和方法时，可使用final来修饰，表示“最终”。

（1）final标记的类不能被继承。

​ 提高安全性，提高程序的可读性。如：String类、System类、StringBuffer类

（2）final标记的方法不能被子类重写。

​ 如：Object类中各getClass( )。

（3）final标记的变量（成员变量或局部变量）即称为常量。

​ 名称大写，且只能被赋值一次。如：final标记的成员变量必须在声明的同时或者每个构造方法中或代码块中显式赋值，然后才能使用。常量定义名称约定使用大写，如果多个单词组成名称，用_连接。

如：final double PI=3.14； final NAME_1 = “Sam”;

5.5抽象类（abstract class）

1.关于抽象类

​ 随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计硬要保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于他没有具体的实例，这样的类叫做抽象类。

在这里插入图片描述

2.抽象类举例

	public abstract class Animal{
		public abstract void text();//只要类中有一个抽象方法，类就必须是一个抽象类
		
		public abstract void move();
	}
   class Dog extends Animal{

	@Override
	public void text() {
		
	}

	@Override
	public void move() {
		System.out.println("狗的移动方法是跑");
	}
	   
   }
   class Fish extends Animal{

	@Override
	public void text() {
		
	}

	@Override
	public void move() {
		System.out.println("鱼的移动方法是游");
	}
	   
   }

3.抽象类应用

在这里插入图片描述

解决方案

Java允许类设计者指定：超类声明一个方法但不提供实现，该方法的实现由子类提供。这样的方法称为抽象方法。有一个或更多抽象方法的类称为抽象类。

Vehicle是一个抽象类，有两个抽象方法

public abstract class Vehicle{
    //计算燃料效率的抽象方法
    public abstract double calcFuelEfficiency();
    //计算行驶距离的抽象方法
    public abstract double calcTripDistance();
}
public class Truck extends Vehicle{
    public double calcFuelEfficiency(){//写出计算卡车的燃料效率的具体方法}
    public double calcTripDistance(){//写出计算卡车行驶距离的具体方法}    
}
        
public class RiverBarge extends Vehicle{
    public double calcFuelEfficiency(){//写出计算驳船的燃料效率的具体方法}
    public double calcTripDistance(){//写出计算驳船行驶距离的具体方法}    
}
        
   //注意：抽象类不能实例化  new Vehicle()是非法的

4.抽象类问题

（1）为什么抽象类不仅可以使用final声明？

​ 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写弗雷德抽象方法，并提供方法体

（2）一个抽象类中可以定义构造器吗？

​ 抽象类可以有构造方法，只是不能直接船舰抽象类的实例对象而已。

​ 抽象类不能实例化 new Vehicle()是非法的

5.模板方法设计模式（TemplateMethod）

public abstract class Template{
    public final void getTime(){
        long start = System.currentTimeMills();
        code();
        long end = System.currentTimeMills();
        System.out.println("执行时间是：" + (end - start));
    }
    public abstract void code();
}
class SubTemplate extends Template{
    //计算循环10000次的时间
    public void code(){
        for(int i = 0; i < 10000; i++){
            System.out.println(i);
        }
    }
}

//Text类测试
public class Text{
     public static void main(String args[]){
         SubTemplate t = new SubTemplate();
         t.getTime();
     }
}

5.6接口

1.关于接口

在这里插入图片描述

2.接口的特点

在这里插入图片描述

举例：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.接口注意点

在这里插入图片描述

4.接口例题

用Java描述一个老师即会唱歌也会做菜

（1）分析

在这里插入图片描述

（2）创建类和接口并写出相关内容

//Person抽象类
public abstract class Person {
	int age;
	String name;
	int sex;
	abstract void showInfo();
}

//SCTeacher类
/**
 * 这个是描述会唱歌的厨师是一个老师的类
 * @author 13088
 *
 */
public class SCTeacher extends Person implements Cooking,Sing{
	String course;//教的科目
	public void setInfo(){
		super.age = 30;
		super.name = "Sam";
		super.sex = 0;//0man 1woman
		
		this.course = "数学";
	}

	@Override
	void showInfo() {
		System.out.println("会唱歌的厨师的老师的信息是：");
		System.out.println(super.age);
		System.out.println(super.name);
		System.out.println(super.sex);
		System.out.println(this.course);
	}

	@Override
	public void singing() {
		System.out.println(super.name + "老师擅长英文摇滚");
		
	}

	@Override
	public void fry() {
		System.out.println(super.name + "老师拿手的厨艺是炒菜");
		
	}
}

//Cooking接口
/**
 * 做饭的接口
 * @author 13088
 *
 */
public interface Cooking {
	void fry();

}

//Sing接口
/**
 * 唱歌的接口
 * @author 13088
 *
 */
public interface Sing {
	void singing();

}

//Text类
public class Text {
	public static void main(String[] args) {
		SCTeacher sct = new SCTeacher();
		
		sct.setInfo();
		
		sct.showInfo();
		
		sct.fry();
		
		sct.singing();
	}

}

（3）最终运行得：

在这里插入图片描述

5.工厂方法（FactoryMethod）

（1）什么是工厂方法

在这里插入图片描述

（2）工厂方法举例

宝马车的生产，有BMW产品接口，BMWFactory汽车生产工厂接口，Text测试类

package 第五章.ImportExample;
/**
 * 宝马车的产品接口
 * @author 13088
 *
 */
public interface BMW {
	//产品的信息介绍
	//车的发动方式
	void showInfo();
}

/**
 * 构建具体的车的类
 * @author 13088
 *
 */
class BMW3i implements BMW{

	@Override
	public void showInfo() {
		System.out.println("这个是宝马3系车");
	}
	
}
class BMW5 implements BMW{
	
	@Override
	public void showInfo() {
		System.out.println("这个是宝马5系车");
	}
	
}
class BMW7 implements BMW{
	
	@Override
	public void showInfo() {
		System.out.println("这个是宝马7系车");
	}	
}

package 第五章.ImportExample;
/**
 * 宝马车生产工厂的接口
 * @author 13088
 *
 */
public interface BMWFactory {
	BMW productBMW();
}

/**
 * 实现具体的车型的生产工厂
 * @author 13088
 *
 */
class BMW3Factory implements BMWFactory{

	@Override
	public BMW productBMW() {
		System.out.println("生产宝马3系车");
		System.out.println("改造宝马3系车，更名为BMW3i");
		return new BMW3i();
	}	
}

class BMW5Factory implements BMWFactory{
	
	@Override
	public BMW productBMW() {
		System.out.println("生产宝马5系车");
		return new BMW5();
	}	
}

class BMW7Factory implements BMWFactory{
	
	@Override
	public BMW productBMW() {
		System.out.println("生产宝马7系车");
		return new BMW7();
	}	
}

package 第五章.ImportExample;

public class Text2 {
	public static void main(String[] args) {
		BMW b3 = new BMW3Factory().productBMW();
		b3.showInfo();
		
		BMW b5 = new BMW5Factory().productBMW();
		b5.showInfo();
		
		BMW b7 = new BMW7Factory().productBMW();
		b7.showInfo();
	}
}

运行结果：

在这里插入图片描述

​ 其中工作人员A执行BMW接口与BMWFactory接口的工作，工作人员B执行Text方法。工厂方法能够实现：工作人员A修改代码不影响工作人员B的工作。

5.7内部类

1.关于内部类

在这里插入图片描述

public class Text2 {
	int i;
	public int j;
	private int l; 
	
	//内部类A
	class A{
		public void setText2Fileds(){
			Text2.this.i = 1;
			Text2.this.j = 2;
			Text2.this.l  =3;
		}
	}
		
		//设置信息   外部类要使用内部类的方法，需要先new内部类的对象
		public void setInfo() {
			new A().setText2Fileds();
		}
		
		//获取信息
		public void getInfo() {
			System.out.println(this.i);
			System.out.println(this.j);
			System.out.println(this.l);		
		}

	public static void main(String[] args) {
		Text2 t2 = new Text2();
		t2.setInfo();
		t2.getInfo();
	}
}

2.内部类特性

在这里插入图片描述

面向对象内容总结

在这里插入图片描述

第六章 异常处理

6.1 Java异常

1.关于异常

在这里插入图片描述
在这里插入图片描述

2.异常举例

（1）数组越界

package 第六章;

public class Test {
	public static void main(String[] args) {
		String[] strs = new String[] {"a","b","c"};
		
		for(int i = 0; i < 4; i++) {//0,1,2,3,strs没有第四个元素，这时要输出strs[3]就没有
			
			//java.lang.ArrayIndexOutOfBoundsException数组越界
			System.out.println(strs[i]);
		}			
	}
}

运行结果：

在这里插入图片描述

（2）空指针

public class Test {
	public static void main(String[] args) {
        
        A a = null;
		//java.lang.NullPointerException空指针异常
		System.out.println(a.i);
	}
}
class A{
	int i;
}

运行结果：

在这里插入图片描述

（3）错误运算

如任何数除以零不存在

package 第六章;

public class Test {
	public static void main(String[] args) {
        int a = 0;
		//java.lang.ArithmeticException运算错误
		System.out.println(2/a);
	}

运行结果：

在这里插入图片描述

3.常见异常

RuntimeException

（1）错误的类型转换

（2）数组下标越界

（3）空指针访问

IOException

（1）从一个不存在的文件中读取数据

（2）越过文件结尾继续读取EOFException

（3）连接一个不存在的URL

6.2异常处理

1.异常处理机制

在这里插入图片描述

2.捕获异常

//异常处理通过 try-catch-finally 语句实现的


try{//用try{}来括住一段有可能出现异常的代码段
    
}catch(ExceptionName1 e){//当产生ExceptionName1型异常时的处置措施
    
    //当不知道捕获的是什么类型的异常时，可以直接使用所有异常的父类Exception
    
}catch(ExceptionName2 e){//当产生ExceptionName2型异常时的处置措施
    
}finally{//finally可写可不写，它是捕获异常体系中最终一段会执行的部分
    
}

关于捕获异常

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.抛出异常

（1）声明抛出异常

在这里插入图片描述

举例

package 第六章;

public class Test1 {
	public static void main(String[] args) throws Exception {//可以在main方法继续抛出异常
		//main方法抛出异常到虚拟机上去，在程序中不能处理
		B b = new B();
//		try{//throws在代码这抛出的异常，在调用方去捕获处理
//		    b.test();
//		}catch(Exception e) {
//			e.printStackTrace();
//		}
		b.test();
	}

}
class B{
	int i;
	public void test() throws Exception{//可以使用throws在代码这抛出异常，在调用方捕获处理
		B b = null;
		System.out.println(b.i);
	}
}

（2）重写方法声明抛出异常的原则

重写方法不能抛出比被重写方法范围更大的异常类型

子类重写父类的方法时，子类不能抛出比父类方法范围更大的异常

class B{
	int i;
	//NullPointerException的父类是Exception
	public void test() throws NullPointerException{//可以使用throws在代码这抛出异常，在调用方捕获处理
		B b = null;
		System.out.println(b.i);
	}
}
class C extends B{
	@Override
	public void test() throws NullPointerException {
		//不能抛出Exception，子类C抛出的异常不能比父类B的异常NullPointerException范围更大
		
		super.test();
	}
}

（3）人工抛出异常

在这里插入图片描述

public class Test1 {
	public static void main(String[] args){
        B b = new B();
		try {
			b.test1(-100);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

class B{
	int i;
	//NullPointerException的父类是Exception
	public void test() throws NullPointerException{//可以使用throws在代码这抛出异常，在调用方捕获处理
		B b = null;
		System.out.println(b.i);
	}
	
	int age;
	public void test1(int age) throws Exception{
		if(age >=0 && age <= 150) {
			System.out.println("年龄是：" + this.age);
	}else{
		throw new Exception("这个年龄不在0~150之间");
	}
  }
}

运行结果：

在这里插入图片描述

4.创建用户自定义异常类

Java提供的异常的类一般是够用的，只有特殊的情况可能需要自己编写异常类，情况很少见

轩仔给你一刀
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 内存模型（三）-从源代码到指令序列的重排序
纯洁的明依
02-09 482
在执行程序时。为了提高性能，编译器和处理器常常会对指令做重排序。重排序分为3中类型： 1 编译器优化的重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。 2 指令级并行的重排序。现代处理器采用了指令集并行技术(ILP) ,来讲多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对机器指令的执行顺序。 3 内存系统的重排序。由于处理器使用缓存和读/写缓冲区。这便得...
Java指令重排序在多线程环境下的应对策略
Java知识图谱的博客
04-23 518
一、序言 指令重排在单线程环境下有利于提高程序的执行效率，不会对程序产生负面影响；在多线程环境下，指令重排会给程序带来意想不到的错误。 本文对多线程指令重排问题进行复原，并针对指令重排给出相应的解决方案。 二、问题复原 （一）关联变量 下面给出一个能够百分之百复原指令重排的例子。 public class D { static Integer a; static Boolean flag; public static void writer() { a =
关于Java对象的创建时有可能的指令重排
honourtun的博客
02-26 1869
今天看了一个指令重排的视频，说Java对象创建的过程中执行了3步。 开辟空间 初始化 赋值引用 初始化和赋值引用是有可能被指令重排的，所以产生了疑惑，初始化和赋值引用不是一个东西吗？ 接下来，我在网上遍历文章寻找Java对象创建时候的过程以用来解答心中的疑惑。 以下是我暂时理解的东西： 关于Java对象创建时的步骤其实聚焦于new这个关键字，举例说明: Person a = new Person(); a可以理解为一个句柄，不能称之为对象。 Person为类声明。 Person()为构
Java如何在main方法中实例化内部类对象
热门推荐
su1177的博客
03-11 1万+
今天我在实例化一个类是编译器报以下错误: No enclosing instance of type Person is accessible. Must qualify the allocation with an enclosing instance of type Person (e.g. x.new A() where x is an instance of Person). ...
java基础-- new 一个对象的过程
SmartShylyBoy的博客
11-12 1727
java new 一个对象的流程大体如下 一、类加载（方法区） java是使用双亲委派来进行类的加载的 双亲委托模型的工作过程是： 如果一个类加载器（ClassLoader）收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委托给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父类加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需要加载的类）时，子加载器才会尝试自己去加载。 使用双亲委托机制的好处是：能够有效确保
java第七版课后答案——第二章.doc
10-12
Java第七版课后答案——第二章 本节课后答案涵盖了Java编程语言的基础知识，包括变量、数据类型、运算符、控制结构、方法和输入/输出操作。本节答案中提供了两个Java程序的源代码，分别是AverageOfThree.java和...
第一行代码Java源代码第12章课程代码Java网络编
11-25
【Java网络编程基础】 在Java编程中，网络编程是一个重要的...通过学习和理解这些基本概念，并结合"第一行代码Java源代码第12章"中的实例，开发者能够掌握Java网络编程的基本技能，从而设计和实现自己的网络应用程序。
第一行代码Java源代码第1章课程代码Java简介共1
10-31
【标题】"第一行代码Java源代码第1章课程代码Java简介共1" 指的是一个关于Java编程语言入门的教程，源自郭霖的畅销书《第一行代码——Java》的第一章。这个标题暗示了内容可能涵盖了Java编程的基础概念，可能是为了...
Java第4章面对对象—— 反射学习 程序 .zip
03-18
在"第03节：JAVA反射机制.docx"文档中，你将深入了解到反射的基本概念和使用方法。 1. **Class对象**：每个类在Java中都有一个对应的Class对象，它包含了类的所有信息，如类名、构造器、方法、字段等。我们可以通过...
第一行代码Java源代码第15章课程代码DAO设计模式
最新发布
12-01
【标题】"第一行代码Java源代码第15章课程代码DAO设计模式"涉及的是Java编程中的一个重要概念——DAO（Data Access Object）设计模式。DAO模式是软件开发中用于访问数据库或持久化层的一种设计模式，它将业务逻辑与...
Java在main方法中添加对象_java 在main中创建具体的动物对象（用new）用该对象的tostring输出该对象的相关信息...
weixin_28963467的博客
02-25 799
展开全部创建 Animal 类来32313133353236313431303231363533e59b9ee7ad9431333363366233描述动物对象，并重写父类(Object)的 toString 方法，具体代码：publicclassAnimal{/***动物种类*/privateStringanimalSpecies;/***动物年龄*/privateintani...
类加载过程
XZSJ_Front的博客
11-10 365
类的生命周期 一个类的完整生命周期如下： 类加载过程 Class 文件需要加载到虚拟机中之后才能运行和使用，那么虚拟机是如何加载这些 Class 文件呢？ 系统加载 Class 类型的文件主要三步:加载->连接->初始化。连接过程又可分为三步:验证->准备->解析。 加载 类加载过程的第一步，主要完成下面3件事情： 通过全类名获取定义此类的二进制字节流 将字节流所代表的静态存储结构转换为方法区的运行时数据结构 在内存中生成一个代表该类的 Class 对象,作为方法区这些数据的访
java 应用题_java编程应用题！！！
weixin_42534100的博客
02-21 803
实例说明当顾客在商场购物时，卖家需要根据顾客的需求提取商品。对于汽车销售商场也是如此。用户需要先指定购买的车型，然后商家去提取该车型的汽车。本实例将实现一个简单的汽车销售...实例说明当顾客在商场购物时，卖家需要根据顾客的需求提取商品。对于汽车销售商场也是如此。用户需要先指定购买的车型，然后商家去提取该车型的汽车。本实例将实现一个简单的汽车销售商场，用来演示多态的用法。实现过程新建一个抽象类，名称...
java 创建一个抽象类_Java-抽象类
weixin_42370320的博客
02-13 4095
抽象类含有抽象方法的类就是抽象类1) 抽象方法：该方法有返回值，有参数，就是没有方法体，该方法没有方法实现2) 抽象方法的格式：abstract 返回值类型 方法名(参数列表)；3) 抽象类需要靠子类来重写抽象方法，以实现其功能public classTest1 {//抽象类：含有抽象方法的类//抽象方法：没有方法体的方法public static voidmain(String[] args) ...
JAVA 基础知识学习24
吴杨的博客
03-28 1509
简单的汽车销售商场当顾客在商场购物时，卖家需要根据顾客的需求提取商品。对于汽车销售商场也是如此。用户需要先指定购买的车型，然后商家去提取该车型的汽车。本实例将实现一个简单的汽车销售商场，用来演示多态的用法。实现过程如下：（1）编写类Car，该类是一个抽象类，其中定义了一个抽象方法getInfo()，实例代码如下：public abstract class Car { public abstra
设计模式-简单工厂模式/静态工厂方法（Static Factory Method）
Robert学习分享
08-10 2152
定义 简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。 优点 工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工
工厂模式（Factory）
weixin_30407099的博客
01-09 81
一、工厂模式介绍： 工厂模式实现了创建者和调用者的分离 工厂模式分类： 1.简单工厂模式 2.工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类 ​3.抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 面向对象设计的基本原则： OCP（开闭原则，Open-Closed Principle）： ...
第九周Java作业
小宇飞刀的BLOG
10-26 1792
本周主题：面向对象程序设计（三） Java 抽象类 Java 接口 Java 包(package) 一、Java 抽象类 1、抽象类的概念 在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方...
工厂模式：封装对象的创建（一、在基类中定义一个静态成员函数）
枫叶冷风
12-07 1573
当我们发现需要添加新的类型到一个系统中时，最明智的首要步骤就是用多态机制为这些新类型创建一个共同的接口。 用这种方法可以将系统中多余的代码与新添加的特定类型的代码分开。新类型的添加并不会搅乱已存在的代码...或者至少看上去如此。 起初它似乎只需要在继承新类的地方修改代码，但这并非完全正确，仍须创建对象，在创建对象的地方必须指定要使用的准确的构造函数。 因此，如果创建对象的代码遍布整个应用的程
Java语言程序设计-基础篇-中文ppt-第十九章.ppt
12-20
本资源是关于Java语言程序设计的基础篇，主要聚焦于第十九章——二进制I/O。在这一章中，作者详细探讨了Java中I/O操作的相关概念和技术，包括文本文件和二进制文件的区别、处理方式以及各自的优缺点。 首先，章节...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值