向上转型
Java基础知识总结(超详细整理)
Java基础知识总结（超详细整理）Java语⾔的特点1.⾯向对象⾯向对象(OOP)就是Java语⾔的基础，也是Java语⾔的重要特性。
⾯向对象的概念：⽣活中的⼀切事物都可以被称之为对象，⽣活中随处可见的事物就是⼀个对象，我们可以将这些事物的状态特征（属性）以及⾏为特征（⽅法）提取并出来，并以固定的形式表⽰。
2.简单好⽤Java语⾔是由C和C++演变⽽来的，它省略了C语⾔中所有的难以理解、容易混淆的特性（⽐如指针），变得更加严谨、简洁、易使⽤。
3.健壮性Java的安全检查机制，将许多程序中的错误扼杀在摇蓝之中。
另外，在Java语⾔中还具备了许多保证程序稳定、健壮的特性（强类型机制、异常处理、垃圾的⾃动收集等），有效地减少了错误，使得Java应⽤程序更加健壮。
4.安全性Java通常被⽤在⽹络环境中，为此，Java提供了⼀个安全机制以防恶意代码的攻击，从⽽可以提⾼系统的安全性。
5.平台⽆关性Java平台⽆关性由Java 虚拟机实现，Java软件可以不受计算机硬件和操作系统的约束⽽在任意计算机环境下正常运⾏。
6.⽀持多线程在C++ 语⾔没有内置的多线程机制，因此必须调⽤操作系统的多线程功能来进⾏多线程程序设计，⽽ Java 语⾔却提供了多线程⽀持。
多线程机制使应⽤程序在同⼀时间并⾏执⾏多项任务，该机制使得程序能够具有更好的交互性、实时性。
7.分布式（⽀持⽹络编程）Java语⾔具有强⼤的、易于使⽤的⽹络能⼒，⾮常适合开发分布式计算的程序。
java中提供了⽹络应⽤编程接⼝()，使得我们可以通过URL、Socket等远程访问对象。
8.编译与解释共存Java语法基础标识符： ⽤来标识类名、对象名、变量名、⽅法名、类型名、数组名、⽂件名的有效字符序列。
合法的标识符：由字母、数字、下划线“_”、美元符号“$”或者“￥”组成，并且⾸字符不能是数字。
不能把java关键字和保留字作为标识符。
标识符对⼤⼩写敏感。
关键字：Java语⾔中已经赋予了特定含义的保留字： const、goto，Java版本中尚未使⽤，但以后版本可能会作为关键字使⽤变量：程序运⾏期间可以被改变的量。
Java日常练习题,每天进步一点点（11）
Java⽇常练习题,每天进步⼀点点（11）⽬录1、对接⼝的描述正确的是()2、类中的数据域使⽤private修饰为私有变量，所以任何⽅法均不能访问它。
3、已知如下类定义：4、在java的⼀个异常处理中，可以包含多个的语句块是（）。
5、关于Java语⾔中的final关键字的使⽤，下列说法正确的是（）6、在 main() ⽅法中给出的整型数组，如果将其写到⼀个⽂件中，需要（）。
7、下列有关Servlet的⽣命周期，说法不正确的是？8、What is displayed when the following is executed？9、假定Base b = new Derived（）; 调⽤执⾏b.methodOne（）后，输出结果是什么？10、下⾯关于变量及其范围的陈述哪些是不正确的（）答案汇总：总结承蒙各位厚爱，我们⼀起每天进步⼀点点！（⿏标选中空⽩处查看答案）1、对接⼝的描述正确的是()正确答案: A⼀个类可以实现多个接⼝接⼝可以有⾮静态的成员变量在jdk8之前，接⼝可以实现⽅法实现接⼝的任何类，都需要实现接⼝的⽅法题解：A，⼀个类只能有⼀个直接⽗类，但是继承是有传递性的。
⼀个类可以实现多的接⼝。
⼀个接⼝可以继承多个类。
B，接⼝中没有普通变量（普通成员变量），接⼝中都是常量，默认修饰符：public static finalC，JDK8之前，接⼝中的⽅法都是默认public abstract的，JDK8之后，接⼝中可以有static、default的修饰的⽅法，⼀旦被修饰，⽅法必须有⽅法体（抽象⽅法可是没有⽅法体的），接⼝中的⽅法都不能被private和protected 修饰，同时外部接⼝、类只能被public修饰或者不写，但是内部接⼝、类可以被四个访问修饰符修饰。
D，实现接⼝，其实就是需要重写接⼝中的abstract⽅法，⼀旦实现的类没有重写完，那么这个类必须是个抽象类（抽象类中可以没有抽象⽅法，但是有抽象⽅法的类必须是抽象类）。
JAVA多态性 ppt课件
a.fun1();
// 此方法被子类覆写过
}
}
PPT课件
6
对象的向下转型
class A{ public void fun1(){
// 定义类A // 定义fun1()方法
System.out.println("A --> public void fun1(){}") ;
} public void fun2(){
PPT课件
5
对象的向上转型
class A{ public void fun1(){
// 定义类A // 定义fun1()方法
System.out.println("A --> public void fun1(){}") ;
} public void fun2(){
// 定义fun2()方法
this.fun1() ;
A a = new B() ;
// 发生了向上转型的关系，子类 --> 父类
B b = (B)a ;
// 此时发生了向下转型关系
b.fun1() ;
// 调用方法被覆写的方法
b.fun2() ;
// 调用父类的方法
b.fun3() ;
// 调用子类自己定义的方法
}
}
PPT课件
7
多态禁忌
•千万不要出现这样的操作:就是将父类对象转换成为子类是类型 – Animal a=new Animal(); – Dog d4=(Dog)a;//类造型异常
}
}; class B extends A{
public void fun1(){
// 子类通过extends继承父类 // 覆写父类中的fun1()方法
协变关系名词解释__概述说明以及解释
协变关系名词解释概述说明以及解释1. 引言1.1 概述在计算机科学和软件工程领域，协变关系是一个重要概念。
它描述了一种类型系统中的关系，其中一个类型的对象可以被视为另一个类型的对象。
协变关系是面向对象编程中常见的特性，具有广泛的应用。
1.2 文章结构本文将详细介绍协变关系的定义、示例以及在不同领域中的应用。
同时，我们还会比较协变关系与逆变关系之间的区别，并讨论协变关系对程序设计产生的影响。
此外，我们将解释如何解析协变关系名词，阐述其重要性和意义，并探讨如何应用协变关系来解决问题。
最后，我们将总结回顾对协变关系的认识，并展望未来可能发展方向以及研究该概念所面临的挑战。
1.3 目的本文旨在帮助读者全面理解协变关系及其在软件开发中的作用。
通过阐述实际示例和概念解释，读者将能够更好地掌握这一概念并有效地应用于实际项目中。
无论是从业人员还是学术研究者，对协变关系的深入理解都将对他们的工作和学习有所裨益。
2. 正文2.1 协变关系定义在编程和数学领域中，协变关系是指在一个集合中，某个类型的变量的替代形式可以被接受。
换句话说，如果一个对象的类型可以被其超类型所替代而不会引发错误或者违反规则，则表明存在协变关系。
2.2 协变关系示例一个典型的协变关系示例是数组。
假设有两个类A和B，其中B是A的子类。
那么一个类型为A[]的数组可以被赋值为类型为B[]的数组，并且在使用过程中不会产生任何问题。
2.3 协变关系在不同领域中的应用协变关系在许多领域都有广泛应用。
在计算机科学领域，协变关系经常用于处理多态性和继承相关的问题。
它也被广泛应用于图形学、自然语言处理、机器学习等领域中。
3. 主要要点3.1 协变关系与逆变关系对比虽然协变关系描述了某个类型可以被其超类型替代这一概念，但逆变关系则表示超类型可以被其子类型替代。
这两种关系是相互对立但又密切相关的。
3.2 协变关系的形式化表达方式协变关系可以通过数学和编程语言中的强类型系统来进行形式化描述。
.net单词汇总
2．directory目录
3．stream流
4．encoding编码
5．exist存在
第十二章
1．serialize序列化
2．attribute属性
3．binary二进制
4．save节省
5．obsolete过时
第十四章
1．cinema电影
2．ticket门票
3．free免费
4．adventure冒险
第一章
1．class类
2．object对象
3．static静态
4．final不可更改
5．private私有
6．public公开
7．protect保护
8．overloading重载
9．constructor构造函数
10．encapsulation封装
第二章
1．inheritance继承
2．extend扩展，继承
4．map地图
5．iterator迭代器
6．generic泛型
7．remove删除
8．contain包含
9．key关键
10．value价值
第十章
1．JDBC一种用于执行SQL语句的Java API(Java数据库连接)
2．driver manager驱动程序管理器
3．connection连接
4．statement声明
3．super父类
4．override覆盖
5．constructor构造函数
6．public公开
7．abstract抽象
8．final不可更改
第三章
1．polymorphism多态
2．instance实例
3．override覆盖
马士兵-Java笔记
马士兵-Java笔记Java语言的特点:1. 一种面向对象的语言;2. 一种平台无关的语言，提供程序运行的解释环境;3. 一种健壮的语言，吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分(如:指针，内存的申请与释放等)。
Java两种核心机制:Java虚拟机、垃圾收集机制;一个Java源文件中最多只能有一个public类。
其他类的个数不限，如果源文件包含一个public类，它必须按该类名命名;Java标识符命名规则:1. 标识符由字母、下划线“_”、美元符“$”或数字组成;2. 标识符应以字母、下划线、美元符开头;3. Java标识符大小写敏感，长度无限制。
从本质上讲，变量其实是内存中的一小块区域，使用变量名来访问这块区域，因此，每个变量使用前必须要先申请(声明)，然后必须进行赋值(填充内容)，才能使用。
数据类型包括基本数据类型和引用数据类型:1. 基本数据类型:数值型:整数类型(byte,short,int,long)，浮点类型(float,double)字符型(char)布尔型(boolean)2. 引用数据类型:类(class)接口(interface)数组Java语言的整型常量默认为int型，声明long型常量可以后加‘l’或‘L’。
Java浮点型常量默认为double型，如要声明一个常量为float型，则需在数字后面加f或F.Boolean类型不可以转换为其他的数据类型。
整型，字符型，浮点型的暑假在混合运算中相互转换，转换时遵循一下原则:1. 容量小的类型自动转换为容量大的暑假类型;数据类型按容量大小排序为:Byte,short,char->int->long->float->doubleByte,short,char之间不会互相转换，他们三者在计算时首先会转换为int类型2. 容量大的暑假类型转换为容量小的数据类型时，要加上强制转换符，但可能造成精度降低或溢出;使用时要格外注意。
JAVA面试题及思考
JAVA⾯试题及思考===========================================学⽽时习之=============================================1.public class Test {public static void main(String[] args) {String str = "123";changeStr(str);System.out.print(str);}public static void changeStr(String str){str = "abc";}}关键词：java内存分配2.public class Test {static boolean foo(char c) {System.out.print(c);return true;}public static void main(String[] args) {int i = 0;for (foo('A'); foo('B') && (i < 2); foo('C')) {i++;foo('D');}}}关键词：c for3.public class B extends A {// here}class A {protected int method1(int a, int b) {return 0;}}//Which two are valid in a class that extends class A? (Choose two)//A. public int method1(int a, int b) { return 0; }//B. private int method1(int a, int b) { return 0; }//C. private int method1(int a, long b) { return 0; }//D. public short method1(int a, int b) { return 0; }//E. static protected int method1(int a, int b) { return 0; }关键词：override , overloadThe public type A must be defined in its own fileCannot reduce the visibility of the inherited method from AThe return type is incompatible with A.method1(int, int)This static method cannot hide the instance method from ADuplicate method method1(int, int) in type A⽅法重载是单个类内部，通常说⽅法调⽤ a. ⽅法名 b. 参数⽅法重写是继承关系中，全部相同，除了 a. ⼦可见度>=⽗可见度 b. ⼦final可终⽌继承4.public class Outer {public void someOuterMethod() {// Line 3}public class Inner {}public static void main(String[] args) {Outer o = new Outer();// Line 8}}// Which instantiates an instance of Inner?// A. new Inner(); // At line 3// B. new Inner(); // At line 8// C. new o.Inner(); // At line 8// D. new Outer.Inner(); // At line 8// E. new Outer().new Inner(); // At line 8关键词：内部类构造⽅法也是⽅法构造⽅法前必须有new 修饰谁调⽤⽅法：实例调⽤实例⽅法new，类调⽤类⽅法static还有⼀种内部类叫静态内部类5.CREATE TABLE zxg(a VARCHAR2(10),b VARCHAR2(10))INSERT INTO zxg VALUES('a',NULL);INSERT INTO zxg VALUES('b','234');INSERT INTO zxg(a,b) VALUES ('c','');INSERT INTO zxg(a,b) VALUES ('d','');SELECT*FROM zxg--1 a--2 b 234--3 c--4 dSELECT*FROM zxg WHERE b LIKE'%'--1 b 234--2 d关键词：LIKE , NULL关于oracle中like ‘%’ 或者 like '%%' 还有 is null ，is not null长度为零的字符串即空字符串varchar2 类型时为 null好⽐调⼀个⽅法的前提是调动者得存在6.//final 是形容词最终的，final 类不可以被继承，final 字段不可以被改变，final⽅法不可以被重写//The type A cannot subclass the final class B//Cannot override the final method from B//The final field A.s cannot be assigned//finally 是副词 try{}catch(){}finally{}//finalize() 是⽅法，垃圾回收机制关键词：final , finally , finalize7.Controlling Access to Members of a ClassAccess LevelsModifier Class Package Subclass Worldpublic Y Y Y Yprotected Y Y Y Nno modifier Y Y N NNprivate Y N N关于package的⼀个问题：package a;package a.b;有⽗⼦关系吗？在a中定义⼀个pckage-private 的类，该类能不能被a.b中的类访问？答案是：不能。
java基础知识点整合
面向对象3.1 面向对象介绍1.什么是面向对象对象其实就是现实生活中的各种物体,他们有各种各样的功能,当我们需要借助这些物体去完成我们的需求时,我们就是在面向这些对象,使用它们其中的功能,至于他们其中的功能是如何实现的,我们无需知道,只要能完成需求即可.2.什么是面向对象编程(OOP):Object Oriented Programming 是一种编程思想, 使用对象去进行编程.它的特点有: 封装, 继承, 多态3.对象从哪来:对象是需要先用类来描述, 然后使用类来创建.类是对象的描述, 对象是类的实例.4.面向对象的优点提高代码复用性.使用者无需关心对象其中是如何实现的.让程序员从一个编写者转换成一个使用者.更加符合人的思维能力,使编程更简单.3.2 定义类1.成员变量在类中用变量来描述这一类对象公有的特征.2.成员函数在类中用函数来描述这一类对象公有的行为.3.3 创建和使用对象1.怎么创建使用"new 类名()"形式创建一个对象2.怎么使用通过"."语法来访问类的成员.例如: Person p = new Person(); = "张三";p.eat();3.4对象的初始化过程1.加载类类在第一次使用的时候被加载到内存中2.初始化成员变量当创建对象的时候, 成员变量会初始化为默认值, 基本数据类型都是0, 引用数据类型都是null3.5对象的生命周期1.开始new关键字创建对象的时候, 生命周期开始2.结束没有任何引用指向对象, 该对象成为垃圾, 被虚拟机回收3.6 匿名对象1.什么是匿名对象没有任何引用指向的对象, 就叫匿名对象2.匿名对象有什么特点匿名对象在创建之后立即被回收, 只能使用一次3.7 封装1.什么是封装封装就是将一类事物的特征和行为封装在一个类中,定义成成员变量和成员函数创建对象之后, 这些成员函数可以访问自己的成员变量2.对成员变量的封装使用private关键字将成员变量私有化如果需要对外部提供访问方式, 写公有的get, set方法3.8 构造函数1.什么是构造函数构造函数是一个特殊的函数.函数名必须和类名一致.没有返回值类型.(不等于void,不能写任何返回值).可以写return,但是不能写return+值(尽量不要写).new关键字创建对象时自动调用2.应用场景如果我们希望一段代码在创建对象的时候执行, 就可以写在构造函数中通常我们使用构造函数对成员变量进行赋值3.构造函数和成员变量的执行顺序成员变量优先于构造函数先执行,因为通常使用构造函数都是对成员变量进行初始化,所以如果没有成员变量,构造函数是没有任何意义的.4.构造函数的重载和普通函数一样, 参数列表不同(类型不同,顺序不同,个数不同)即可.重载只与参数列表有关5.构造函数的调用在创建对象时自动调用.在构造函数的第一条语句可以使用"this(被调用的构造函数的实际参数)"的形式调用该类其他构造函数.6.自动生成构造函数在一个类中构造函数是一定存在的.因为在一个类中如果没有写任何的构造函数, 编译时也会自动生成一个无参的构造函数, 里面什么代码都没有.如果写了任何一个构造函数, 那么就不会有自动生成的了注意: 我们在类中只写了一个有参构造函数的时候,这个类就不能使用无参的构造函数创建对象了7.构造函数的访问权限通常构造函数的访问权限都是公有的, 因为构造函数就是为了让别人创建对象时调用的个别情况下在定义类时不希望外部创建对象, 这时可以使用private修饰构造函数, 例如: 单例设计模式(Singleton)3.9 成员代码块(构造代码块)1.什么是成员代码块在类中使用"{}"定义一段代码, 这段代码在创建对象的时候会自动运行2.成员代码块和构造函数的区别构造函数在创建对象的时候是N个选1个调用而代码块是一定执行构造函数可以传入参数代码块不能传入参数3.创建对象时内存中的工作顺序在内存中查找指定的类, 如果没有就加载类, 有则直接引用在内存中开辟一块空间, 将成员变量初始化为默认值, 0和null按照类代码从上到下的顺序, 执行代码块或者成员变量赋值执行构造函数中的代码4.在方法中也可以写代码块(方法代码块),但是不常用3.10成员变量和局部变量1.成员变量在类中定义的变量,(Field),在整个类都可以访问(用于描述着一类事物的共有特征).成员变量随着对象的建立而建立,存在于对象所在的堆内存中.成员变量有默认初始值(0/false/null)2.局部变量在方法/语句中定义的变量(Local Variable),存在于栈内存中.作用范围一结束,变量的空间会自动释放.局部变量是没有初始值的.3.同名问题在同一个作用域中成员变量不能重复, 局部变量也不能重复但是成员变量和局部变量可以同名, 他们互相不冲突4.访问问题在局部变量和成员变量同名的时候, 如果直接用变量名访问一个变量, 那么是先找局部变量, 如果不存在才找成员变量这时如果不想找局部变量, 直接找成员变量, 应该用"this.变量名"3.11 this关键字1.构造函数中"this(参数)"形式可以在构造函数的第一条语句中调用其他的构造函数"this.成员名"形式可以调用当前对象的成员2.普通函数中this用在普通的函数中, 可以代表调用当前函数的对象哪个对象调用this所在的函数,this就代表那个对象.3.内部类中可以使用外部类名.this.成员来访问外部类的成员.3.12静态(static)变量1.什么是静态变量用static修饰的成员变量就是静态变量(随着类的加载而加载)优先于所有非静态成员及成员代码块.2.静态变量和普通变量有什么不同静态变量在类加载后就初始化, 不用创建对象可以直接使用.静态变量被类的所有对象共享(在共享区), 通过一个对象改变, 所有对象都改变.静态变量可以使用"类名.变量名"形式访问, Java推荐使用这种方式, 而不是通过对象访问.3.类在什么时候加载类在第一次使用的时候加载例如: 创建对象, 使用静态变量, 使用静态方法定义变量的时候不加载类.4.静态变量在什么时候使用在定义一个类的时候, 如果希望这个类的所有对象共享一个数据时, 就可以使用静态成员变量.3.13静态(staitc)方法1.什么是静态方法用static修饰的方法就是静态方法静态方法类加载后可以直接运行可以使用"类名.方法名"调用2.什么时候使用静态方法如果一个方法没有访问任何外部的非静态成员, 那么就可以定义为static.这样在调用的时候不用创建对象即可使用, 给人提供方便, 并且效率更高.3. 静态方法使用的注意事项1. 静态方法不能直接访问方法外非静态成员.因为静态方法是随着类的加载而加载的,而非静态成员只有在对象创建才会加载.因此,当静态方法访问方法外非静态成员,对象不一定被创建,所以不能直接访问,除非在静态方法中创建本类对象,才可以访问,方法外静态成员.2. 与静态方法不能直接访问方法外非静态成员相反,非静态方法是可以访问静态成员的,因为,对象被创建了,这个类一定被加载到内存中,所以可以访问.3. 因为静态优先于对象存在,所以在静态方法中是不能出现this,super这两个关键字,道理很简单,静态被加载时还没有对象,而这两个关键字都和对象有关,所以不能使用.4. 静态的利与弊静态好处:1. 如果一个类里的某一个成员变量,他的所有需要共同使用它,没必要每一个对象都存储一份,可以将成员变量设为static,系统将进行单独空间(方法区/静态区) 存储,节省内存空间.2. 静态的成员可以直接被类名调用,使用简单.静态弊端:1. 因为静态是随着类加载而加载的的,所以其生命周期是和类同存亡的.所以生命周期很长,比较浪费内存空间.2. 因为静态只能访问静态,所以访问有一定的局限性.3. 因为主函数是静态的,所以用主函数调用的方法再不创建对象的情况下,只能都是静态的.3.14静态代码块1. 什么是静态代码块用static修饰的代码块类加载后直接运行, 只能执行一次(因为类只会加载一次),如果在一个类中有主函数,他是优先于主函数运行的.不能访问外部非静态成员2. 什么时候用静态代码块在定义一个类的时候, 如果希望某一段代码在别人使用这个类的时候就执行, 那么就可以写在静态代码块中.用于给类初始化.3.15单例设计模式设计模式:解决某一类问题最行之有效的方法.单例设计模式:让一个类只能创建一个对象.懒汉式和饿汉式饿汉式步骤:1.私有化构造函数.2.创建一个对象,并私有(防止类外改变对象内部内容).3.创建一个公有的,静态的方法,返回本类对象,使类外获取本类对象.懒汉式步骤:1.私有化构造函数.2.创建一个对象引用,并私有(防止类外改变对象内部内容).3.创建一个公有的,静态的方法,判断是否创建了一个对象如果创建了,返回本类对象, 如果没有创建,创建一个对象返回,使类外获取本类对象.3.16继承1.什么是继承定义一个类, 使用extends关键字可以继承另一个类, 得到父类的所有非私有属性和方法.2.继承的特点Java只支持单继承, 不支持多继承, 但可以多重继承.一个父类可以有多个子类, 但一个子类只有一个父类.3.java改良多继承的原因？提高代码的安全性,如果一个子类继承多个父类,而这多个父类中有同名的方法,子类要去访问的话,就不知道要访问哪一个方法了.降低了安全性..4.子类对象创建的过程子类对象之所以能调用父类的方法, 是因为在创建子类对象的时候, 其内部创建了一个父类对象.在new一个对象时,会先去子类构造函数,中寻找super()(如果没有显示指定父类构造函数)然后创建父类,然后再回到子类中创建对象.调用子类的方法时, 虚拟机会先在子类中查找是否包含该方法, 如果没有则找父类.在调用子类构造函数的时候, 一定会使用"super(参数)"形式调用父类构造函数创建父类对象.子类中必须要有一个构造函数含有super调用父类构造函数..super和this类似, 都是必须在构造函数的第一条语句使用如果构造函数写了this, 那么则不能写super, 反之亦然如果没写this也没写super, 默认会自动调用父类无参的构造函数5.方法覆盖(重写)覆盖可以让子类将从父类继承来的方法进行扩展,提高代码复用性,减少冗余.覆盖时子父类的方法名子必须相同, 包括返回值,参数列表,并且子类的权限必须大于或等于父类.只能覆盖非私有方法.6.重载（Overload）和重写（Override）的区别：重载:名字相同,参数列表不同只与参数列表相同.重写:子父类的方法名子必须相同, 包括返回值,参数列表,子类的权限必须大于或等于父类.(如果父类返回值是一个类,子类返回值可以是和父类相同的类或其子类).7.向上转型子类可以当作父类使用, 因为父类的功能子类都有Fu f = new Zi();如果一个方法要求传入一个父类类型对象, 我们也可以传入一个子类对象8.强制类型转换在子类当作父类来用时, 不能调用子类特有的成员.如果一定要调用, 需要把父类类型强转回子类类型.这种转换叫强制类型转换, 在编译时不论类型是否匹配都不会报错, 为了程序安全, 通常在转换之前使用instanceof进行判断.3.17Object类及其中常用方法1.什么是Object类Object类是Java中所有类的父类, 如果定义一个类不继承任何类, 默认继承ObjectObject类中的方法会被所有的类继承2.finalize任何对象在成为垃圾被销毁之前, 都会调用finalize 方法Object类中的finalize方法是空的, 什么都没有当我们希望在对象被销毁之前执行一段代码, 就可以在类中重写finalize方法, 把要执行的代码写在方法中.3.toStringtoString方法可以将一个对象转为字符串表示形式Object类中的toString方法返回的是"类名@内存地址"当我们希望调用toString时返回成员变量的值, 就可以重写该方法调用System.out.println()方法时会自动打印对象toString的返回值4.equalsequals方法是用来比较两个对象的Object类中equals方法默认比较的是对象的地址如果我们希望比较两个对象的属性, 那么可以重写equals方法, 在方法内比较所有的属性在比较字符串时如果希望比较两个字符串的内容, 就需要使用equals, String类是重写了equals的3.18 组合设计模式1.什么是组合设计模式在我们定义一个类的时, 如果需要使用另外一个类的方法, 就可以用组合设计模式.2.组合设计模式的写法在类中定义一个被组合类型的成员变量通过构造函数组合一个对象, 用成员变量引用在方法中使用成员变量调用被组合对象的方法3.组合设计模式和继承的区别不占用继承的位置, 当前类组合一个类之后还能继承其他类组合设计模式组合的类不能当作被组合的类使用3.19 多态1.多态的体现父类引用指向子类对象.(父类的引用可以接受自己的子类).2.多态的前提类与类之间必须有关系,要么继承,要么实现.子类与父类存在覆盖,因为在不强转的情况下,父类,不能访问子类特有的方法.3.多态的好处提高代码扩展性.4多态的弊端虽然提高了扩展性,但是只能使用父类父类引用访问父类成员(共有成员),为了能访问子类特有方法,父类的引用必须转成子类类型(向下转型).3.20 抽象1.什么是抽象类用abstract修饰的类就是抽象类, 抽象类中可以定义抽象方法2.什么是抽象方法用abstract修饰的方法就是抽象方法, 抽象方法在子类中必须全部重写3.什么时候用抽象类和抽象方法在我们定义类的时候, 如果多个类有相同的方法, 那么就应该把这些方法抽取到父类中定义完全相同的方法直接在父类中定义并实现, 如果只有方法签名(无方法体)一样而实现不同, 那么就可以在父类中定义抽象方法这样别人看到父类的时候就知道子类都有什么功能了, 方便他人阅读我们的代码, 也更好的支持了多态.4.抽象类细节有抽象方法的类必须声明为抽象类, 抽象类可以没有抽象方法抽象类不能创建对象子类继承抽象类时必须重写所有的抽象方法3.21 final修饰符1. final代表最终的, 可以用来修饰类, 方法, 变量.2. 被final修饰后的特点final的类不能被继承final的方法不能被重写final的变量只能赋值一次,在程序运行结束前,会一直存在与内存中.如果内部类在局部位置上,只能访问该局部中被final 修饰的变量.被final修饰的形参,第一次赋值是在调用它所在的函数时,不能再次赋值了.被final修饰的引用类型变量,不能在指向其他对象,但是他第一次指向的对象中的内容是可以改变的.final 只是修饰了引用.public static final 修饰的变量时全局变量,可以使用类名调用,名字全部大写3.22模板设计模式1.什么是模板设计模式在编程的过程当中, 如果经常要做一些类似的事, 其中某些步骤相同, 有些步骤不同, 这是就可以使用模板设计模式2.怎么使用模板设计模式定义一个抽象类定义一个final的方法在方法中写出每次相同的步骤, 不同的步骤写成抽象方法, 调用抽象方法每次实现不同的步骤时, 定义子类继承抽象类, 重写抽象方法即可, 相同的步骤无需重写直接调用final方法3.23接口1.什么是接口接口是一种特殊的抽象类2.接口和抽象类的区别抽象类用abstract class定义, 接口用interface定义抽象类中可以有不抽象的方法, 接口中所有方法都是抽象的抽象类用extends继承, 接口用implements实现抽象类可以继承抽象类, 接口可以继承接口抽象可以继承接口,接口不能继承抽象因为抽象类里面有可能会有非抽象方法..抽象类中的方法没有默认修饰符, 接口中的方法默认是public abstract修饰的抽象类中的成员变量没有默认修饰符, 接口中的成员变量默认是public static final 修饰的一个类只能继承一个抽象类, 一个类可以实现多个接口3.什么时候用抽象类, 什么时候用接口能用接口的时候就不用抽象类(没有任何不抽象的方法), 因为接口不占用继承位置如果需要定义不抽象的方法, 那么就必须使用抽象类.3.24 策略设计模式定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。
运行时类型识别
运⾏时类型识别1.RTTI1）运⾏时类型识别RTTI（Run-Time Type Identification），它能够获取基类指针或引⽤所指向的对象的实际类型，在C++中，为了⽀持RTTI 提供了两个运算符：typeid和dynamic_cast2）当某种情况下⽆法使⽤虚函数时，却要完成类似于虚函数的功能时，可以使⽤RTTI，后⾯将会举例讲解这种情况2.dynamic_cast2.1概念1）dynamic_cast运算符⽤于将基类的指针或引⽤安全地转换成派⽣类的指针或引⽤，这是安全的“向下转型”，⾄于“向上转型”，即派⽣类指针或引⽤转换为其基类指针或引⽤，本⾝就是安全的，尽管可以使⽤dynamic_cast进⾏转换，但这是没必要的，普通的转换已经可以达到⽬的，毕竟使⽤dynamic_cast是有开销的2）dynamic_cast使⽤形式：dynamic_cast<type*>(expression) dynamic_cast<type&>(expression) dynamic_cast<type&&>(expression) //右值引⽤其中type必须是⼀个类类型，并且通常具有虚函数，否则编译会报错3）当 expression 是基类指针或引⽤时：如果此基类指针或引⽤所指向对象是派⽣类类型的，这种转换是安全的，可以成功如果基类指针或引⽤所指向对象为基类类型，这种转化是不安全的，会失败4）对于指针，转换失败了，则返回结果0，即返回的指针为NULL，不会抛出bad_cast异常5）对于引⽤，转换失败了，则会抛出bad_cast异常class Base {public:Base() {};virtual void Show() { cout << "This is Base calss"; }};class Derived :public Base {public:Derived() {};void Show() { cout << "This is Derived class"; }};int main(){//第⼀种情况，转换成功Derived d;Base& base1 =d;Derived& der1 = dynamic_cast<Derived&>(base1);cout << "第⼀种情况：";der1.Show();cout << endl;//第⼆种情况Base b;Base &base2 = b;cout << "第⼆种情况：";try {Derived& der2 = dynamic_cast<Derived&>(base2);}catch (bad_cast){cout << "转化失败,抛出bad_cast异常" << endl;}return0;}3.typeid3.1概念1）typeid运算符⽤于返回表达式的类型2）typeid使⽤形式：typeid(expression)； 如果表达式的类型是类且⾄少包含有⼀个虚函数，则typeid返回表达式的动态类型，需要在运⾏时计算；否则，typeid操作符返回表达式的静态类型，在编译时就可以计算3）typeid运算符的返回值是type_info类的引⽤，ype_info类在头⽂件typeinfo中定义4）type_info类提供了public虚析构函数，以使⽤户能够⽤其作为基类。
赋值运算转换规则
赋值运算转换规则赋值运算转换规则是指在编程语言中，将一个值存储到变量中的过程中，可能会涉及到类型转换的过程。
当赋值运算符两边的数据类型不一致时，编译器会根据一定的规则进行类型转换，以使得赋值操作能够进行成功。
下面详细介绍常见的几种赋值运算转换规则。
-将较小的整型类型赋值给较大的整型类型，编译器会自动进行隐式类型转换，将较小的整型类型提升到较大的整型类型。
-将较大的整型类型赋值给较小的整型类型，编译器会进行截断操作，将较大的整型类型截断为较小的整型类型。
-将整型赋值给浮点型，编译器会自动进行隐式类型转换，将整型转换为对应的浮点型。
-将浮点型赋值给整型，编译器会进行截断操作，将浮点型截断为整型。
-将字符类型赋值给数字类型，编译器会将字符的ASCII码值赋给数字类型。
-将数字类型赋值给字符类型，编译器会根据数字的ASCII码值找到对应的字符进行赋值。
-将较小的数字类型赋值给较大的数字类型，编译器会进行隐式类型转换，将较小的数字类型提升到较大的数字类型。
-将较大的数字类型赋值给较小的数字类型，编译器会进行截断操作，将较大的数字类型截断为较小的数字类型。
-在面向对象的编程语言中，将一个对象赋值给另一个对象时，编译器会判断两个类型之间是否存在继承或实现关系。
-如果存在继承或实现关系，编译器会进行向上转型，将子类或实现类的对象赋值给父类或接口类型的变量。
-如果不存在继承或实现关系，编译器会报错，无法进行赋值操作。
6.赋值运算符的组合赋值转换规则在编程语言中，还存在一种常见的运算符形式是组合赋值运算符，如+=、-=、\*=、/=等。
这些组合赋值运算符将赋值操作与对变量的自身操作结合在一起，形成一种简化的赋值语法。
-组合赋值运算符的转换规则与简单的赋值运算转换规则相同，根据数据类型进行隐式类型转换或截断操作。
综上所述，赋值运算转换规则主要涉及到整型、浮点型、字符型等数字类型之间的转换以及对象之间的转换。
掌握这些规则有助于编程者使用赋值运算符时避免类型转换错误，提高程序的正确性和效率。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
向上转型
1.由导出类转型成基类，在继承图上是向上移动的，因此一
般会称为向上转型。由专用类转向公共类，所以比较安全。
导出类是基类的一个超集。
package
com.com;
publicclassInstrument{
publicvoidplay(){
System.out.println("upchange!");
}
staticvoidtune(Instrumenti){
i.play();
}
}
2.packagecom.com;
publicclassWindextendsInstrument{
publicstaticvoidmain(String[]args){
Windflue=newWind();
Instrument.tune(flue);//upcasting向上类型转换
}
}
由于wind类是继承自Instrument,所以wind类中包含了一个
Instrument类的类对象，所以可以可以调用类Instrument的方
法。在类Instrument的tune方法中传递的参数是Instrument类
类型的，在类wind方法中传递的是wind类类型的对象。
如果子类一定要调用基类的方法的时候可以用向上转型的方式。如果
子类不用调用父类的方法的时候，用组合的方式。。。！