java面向对象-类与对象,java面向对象菜鸟教程
本文是最后一篇文章：java——面向对象详细介绍(1)
11、子类访问父类和方法覆写
子类不能直接访问父类的私有成员；
但是，子类可以调用父类中的非私有方法来间接访问父类的私有成员。
Person类中有一个私有字段名称，name，Student inherits Person。
新学生()。姓名；
新生()。getName()；
子类扩展了父类(子类是父类的特例)
主要是基于父类，然后添加自己的字段和方法。
方法覆盖原因：
当父类中的方法不适合子类时，子类具有与父类相同的方法。
判断涅槃：在子类方法前面加@Override可以编译通过，说明是方法的重写。
调用被重写的父类方法：使用。方法名(参数)；
重写方法时要遵循的原则(两小一大):
(一起):
签名必须相同；
(两小):
子类方法的返回值类型小于或等于父方法的返回值类型。
子类方法声明抛出的异常应该小于或等于父方法声明抛出的异常；
(I):子类的访问权限应该大于或等于父方法的访问权限；
子类需要覆盖父类方法。
当父类的一个方法不适合子类本身的特征行为时，父类中应该改变的方法被覆盖。
12、super关键字和调用父类构造方法
表示父类对象的默认引用。
如果子类要调用父类被覆盖的实例方法，可以用super作为调用者调用父类被覆盖的实例方法。
使用super调用父类方法。
使用super调用父类的构造函数
调用构造方法
这个(参数列表)用于调用这个类中的另一个重载构造函数。
子类构造函数调用父类构造函数的super(参数列表)
子类调用父类的构造方法时：
Super必须放在第一句话里
Java在执行子类的构造函数之前，会不带参数地调用父类的构造函数，以初始化从父类继承的成员。
当子类创建一个对象时，它默认调用父类的无参数构造方法。如果子类构造方法显示指定要调用其他父类构造方法，则调用指定的父类构造方法，取消父类的无参数构造方法。
例如：
包审查演示；
A级
字符串名称；
一个(){
System.out.println(父类的默认隐式构造函数！);
}
一个(字符串名){
System.out.println(父类的显式构造函数！);
}
}
B类扩展了A{
B(){
超级(空)；
System.out.println(子类的默认隐式构造方法！);
}
}
公共类演示10 {
公共静态void main(String[] args) {
new B()；
}
}13、面向对象之多态
多态：指同一实体同时有多种形式。
比如你去面馆吃面，说我想吃面，那么；老板，你可以给我牛肉面，鸡蛋面等。
也就是说，‘脸’有很多形态，也就是说实体有很多形态；
编译时的类型由声明变量时使用的类型决定，运行时的类型由实际赋给变量的对象决定。
如果编译时类型和运行时类型不同，就会发生多态性。
例如：
前提：学生扩展人员：
Person p=新人()；
学生s=新生()；
Person p=新生()；//多态性
引用关系：父类变量指向子类实例对象。
实现多态的机制：
父类的引用变量可以指向子类的实例对象，而程序调用的方法是在运行时动态绑定的，也就是引用变量指向的真实实例对象的方法，也就是运行在内存中的对象的方法，而不是引用变量的类型中定义的方法。
多态的作用:
把不同的子类当作父类，就可以屏蔽不同子类之间的差异，编写通用代码，进行通用编程，满足不断变化的需求。
只修改方法的实现，不修改方法的声明。
继承是多态产生的前提条件;
分类：
编译时多态性：方法重载
运行时多态性：方法重写
例如：
包装测试；
班级狗{
void eat(){
System.out.println(普通狗吃普通狗粮！);
}
}
类HashDog exte
system . out . println(‘哈士奇吃哈士奇狗粮！’);
}
}
赞高狗类扩展狗{
void eat(){
system . out . println(‘藏獒吃藏獒的狗粮！’);
}
}
//定义动物园的喂食方式
动物园类{
无效进料(狗d){
d . eat()；
}
}
公共类演示11 {
公共静态void main(String[] args) {
dog HD=new HashDog()；
dog ZD=new ZangAoDog()；
Zoo z=new Zoo()；
z.feed(高清)；
进给(ZD)；
}
}输出：
哈士奇吃哈士奇狗粮！
藏獒吃藏獒的狗粮！
14、引用变量类型转换
向上转换(子类父类):(自动完成)
父类名父类对象=子类实例；
向下转换(父类子类):(强制完成)
Name子类object=(子类名)父类实例；
类的对象名实例
判断此时指定变量名引用的真实类型是否是当前给定的类或子类；
我的总结：对象的类型和类必须有继承关系。
例如：
类A扩展了B{}
b b=new A()；
If(b实例A){.
}2、面向对象（2）
1、基本数据类型的包装类
简介：Java主张一切都是对象，但在数据类型的划分上有基本数据类型和引用数据类型。那么我们如何调用基本数据类型对象呢？
如何解决写爬虫IP受阻的问题？立即使用。
除了整数和字符定义的名字与对应的基本类型有较大区别外，其他六个都是大写的。
Integer、byte、float、double、short和long都是Number类的子类。(班号后面描述)；
Character和Boolean是Object的直接子类；
所有8个职业都是最终修饰的(不可继承)。
2、基本数据类型和包装类相互转换
基本数据类型打包类：
它是通过相应包装类的构造方法来实现的。
除了Character，其他打包类都可以传入一个string参数来构建一个打包类对象。
类基本数据类型
包装的实例方法xxxValue()；//xxx表示包装类对应的基本数据类型。
例如：
布尔bool=false
布尔b2=新布尔(bool)；
整数i=新整数(3)；
int I2=I . int value()；
Boolean b1=新布尔值(“真”)；//真
布尔型B2=B1 . boolean value()；
Float f=新的Float( 3.14 )；//3.14
Integer i2=新整数( 123s )；//NumberFormatException备注：
自动包装和拆包
jdk1.5开始出现的特性：
自动打包：一个基本类型变量可以直接赋给对应的打包类对象或对象对象。
自动解包：允许将打包类对象直接分配给相应的基本数据类型。
例如：
整数I=3；//包装
int I2=I；//解包
Object flag=new布尔值(false)；
if(flag instanceof Boolean){
布尔b=(布尔)标志；
布尔B2=b；
}3、基本类型和String之间的转换
字符串基本类型，除了Character之外的所有包装类都提供parseXxx(String s s)静态方法，用于将特定字符串转换为基本类型变量；
Type String，String类有一个静态方法valueOf()，用于将基本类型的变量转换为String类型。
String str= 17
int I=integer . parse int(str)；///字符串-基本类型
string S1=string . value of(I)；//基本类型-String4、Object类
所有类的公共父类，一旦一个类继承了一个没有显示的类，它的直接父类一定是Object。
对象可以接收所有数据类型。
类OOXX扩展对象{}相当于类ooXX {}
常用方法
Public boolean equals(Object obj):对象比较
PublicHashCode():获取对象的哈希代码。
PublicTostring():对象描述
对象的toString()方法：“对象的描述”
建议所有类都重写此方法。
当直接打印一个对象时，调用该对象的toString()方法。//不写出来。
打印对象时，实际调用的对象实际指向的类的自描述；
完全限定的类名@十六进制hashCode值，相当于
完全限定类名@ IntegertoHexString(此对象。hashCode)
Equals还确定它是否指向同一个对象。
没有实际意义，必要时可以重写。
公共布尔等于(对象对象){}
String重写Object的equals方法：只比较字符序列。
==用于判断两个变量是否相等。
基本类型：
类型：必须指向同一个对象才为真。
只能比较两个具有父子或对等关系的对象。
新字符串( 1)==新字符串( 1 )；
5、代码块
代码块是指用 { 0 } 括起来的一段代码，根据代码块的位置可以分为四种类型：
公共代码块；
构造一个代码块；
静态代码块；
同步代码块(解释线程何时同步)。
代码块中变量的范围：
只在自己的区域内有效(前后{ })；
公共代码块：
公共代码块是直接在方法或语句中定义的代码块：
公共void show(){
公共代码块
}
构建代码块：
直接写在类中的代码块：
优先于构造方法的执行，构造代码块会在每次实例化一个对象之前执行。
例如：
公开课演示{
{
System.out.println(我是积木)；
}
公开演示(){
System.out.println(我是构造函数)；
}
公共静态void main(String[] args) {
Demo D1=new Demo()；
Demo D2=new Demo()；
}
}静态代码块
用静电装饰的积木：
不管创建了多少个对象，静态代码块只执行一次，并可用于为静态变量赋值。
例如：
包审查演示；
/**
*测试每个代码块的优先级。
*优先级顺序：静态代码块>构造代码块>普通代码块
*注意：不管创建多少个对象，静态代码块只执行一次！
*/
公开课演示13 {
Demo13(){
System.out.println(我是构造函数！);
}
{
System.out.println(我是一个积木！);//只有在对象实例化的时候才会调用！
}
静态{
System.out.println(我是一个静态代码块！);
}
公共静态void main(String[] args) {
new demo 13()；
new demo 13()；//再次创建对象，证明不管对象创建多少次，静态代码块只执行一次。
System.out.println(我是一个普通的代码块！);
}
}输出：
我是静态代码块！
我在构建代码块！
我是施工方法！
我在构建代码块！
我是施工方法！
我是一个普通的代码块！
6、构造方法的私有化
有时候，为了避免外界创建某个类的实例，我们将某个类的构造方法私有化，也就是用私有来修饰它的构造方法：
在外面怎么用？
提供了Get方法！如果不提供，外界是无法创建对象的！(对反射无效)
例如：包审查演示；
班级学生{
//将构造方法私有化
二等兵斯图(){
}
}
公开课演示15 {
公共静态void main(String[] args) {
Stu s=new Stu()；
}
}单一模式(singleton pattern)饥饿和懒惰
目的：整个应用程序中只有一个实例，对该类型实例的所有引用都指向该实例。
比如一个国家只有一个皇帝(XXX)。这个时候大家的“皇帝”指的就是XXX本人。
常见的单例模式类型：
中文singleton:直接定义对象。
懒惰的单例：只给变量，不初始化变量；
我的总结：
中国式的，静态修改，用类加载加载，会损失性能，但是方法比较简单。
懒人风格第一次用的时候比较慢，因为需要加载！线程，不安全！
包审查演示；
//单一模式
//饿中国风，直接构造对象。
类SingleDemo{
私有静态single demo S1=new single demo()；
private SingleDemo(){
//提供一个私有化的构造方法，那么外界就无法构造对象了！
}
公共静态SingleDemo getS1() {
返回S1；
}
}
//懒，先定义，但不要创建对象
类SingleDemo2{
私有静态SingleDemo2 s3
private SingleDemo2(){
//提供一个私有化的构造方法，那么外界就无法构造对象了！
}
public static single demo 2 gets 3(){//这是一个方法，返回值是创建的对象！
if(s3==null){
S3=new single demo 2()；
}//和饿了么-中国风的区别，所以这时候我们正好创建了对象！
返回S3；
}
}
公开课演示14 {
公共静态void main(String[] args) {
single demo S1=single demo . get S1()；
single demo S2=single demo . get S1()；
singledemo 2 S3=singledemo 2 . gets 3()；
singledemo 2 S4=singledemo 2 . gets 3()；
system . out . println(S1==S2)；
system . out . println(S3==S4)；
}
}
输出：true true
注意：枚举更安全。
包审查演示；
枚举学生{
杰克；
//将构造方法私有化，反射不能创建对象，安全。
二等兵斯图(){
}
}
公开课演示15 {
公共静态void main(String[] args) {
}
}8、final 关键字
Final可以修饰类、方法和变量。
最终修饰的类不能被继承，但它可以继承其他类。
最终修饰的方法不能被重写，但父方法可以被重写。
final修改的变量称为常量，这些变量只能赋值一次。
当类是局部的时，只能访问由final修饰的局部变量。
final修改的引用类型变量是指变量的引用不能改变，而不是变量的值；
例如：
包审查演示；
最终类名{
}
ClassName扩展名称{//error，报告一个错误，因为名称是用final修饰的。
}
公开课演示15 {
公共静态void main(String[] args) {
}
}9、抽象类
在写类的时候，我们经常会为类定义一些方法。这些方法用来描述类的行为，所以这些方法都有特定的方法体。
然而有时候，一个父类只是知道它的子类应该包含哪些方法，却无法确切知道子类是如何实现这些方法的。
抽象方法的定义：由abstract关键字修饰的类称为抽象类；
总结：抽象类用私有来修饰，私有修饰的方法(没有方法体)可以在其中使用，强制子类重写；
可以理解为带有一些公共方法的总结类。
你可以定义用abstract修饰的抽象方法。
抽象方法只有返回类型和方法签名，没有方法体。
备注：
类可以包含普通的方法。
抽象类不能创建实例对象(不是新的)
子类在创建子类之前必须覆盖所有抽象方法，否则子类必须被视为抽象类。
列出几个常见的抽象类：
流的四个基本父类
输入流、输出流、读取器、写入器
我的总结：
抽象是类的特例：具有类的所有特征，但不能实例化；一般来说，它必须有抽象方法。
类是不能实例化的，有时候近似的实例化是多态机制的体现，而不是真正的实例化。
例如：
Socket s=new Socket()；
output stream OS=s . get output stream()；
左边是OutputStream类型变量的声明，右边是抽象类OutputStream的实例对象！
包testDemo2
抽象类人{
}
班级学生拓展人{
}
公共类演示2 {
公共静态void main(String[] args) {
Person p=新生()；//体现多态性，父类声明实例化子类对象。而不是实例化抽象类。
}
}abstract方法
当事物被分析时，共同的内容被发现，向上提取就发生了。会有一种特殊的情况，函数声明是一样的，但是函数主体不一样。
然后你也可以提取，但是只能提取方法声明，不能提取方法体。那么这个方法就是一个抽象方法。
抽象[非私有访问修饰符]返回值类型方法名(参数列表)；
抽象方法应该存储在抽象类中。
抽象方法也可以存在于接口中。
例如：
包审查演示；
抽象类Person3{
抽象void show()；
抽象void inof()；
无效转弯(){
}
}
类NewP扩展Person3{
@覆盖
void show() {
}
@覆盖
void inof() {
}
//如果不覆盖，会报错。
}
公开课演示15 {
公共静态void main(String[] args) {
//new person 3()；报告错误！因为抽象类不能实例化。
}
}10、抽象类的体现-模板模式
抽象类是从几个具体子类中抽象出来的父类，抽象程度高；以这个抽象类作为子类的模板，可以避免子类设计的随意性；
抽象类的体现主要是模板模式设计。抽象类作为很多子类的通用模板，子类在抽象类的基础上扩展，但子类一般保留抽象类的行为。
写一个抽象父类，提供多个子类的公共方法，留下一个或多个抽象方法给子类实现，这就是模板设计模式；
模板应用的简单规则：
1.抽象的父类只能定义一些需要使用的方法，剩下的交给子类来实现；
2.父类提供的方法只是定义了一个通用的算法，它的实现必须依赖于子类的辅助；
我的总结：
如果父类的方法不想被子类重写，可以用final关键字修饰它。
例如：
包审查演示；
//模板模式
//抽象类包含很多抽象方法，所以子类必须被覆盖！
抽象类方法{
抽象double mul()；//如果返回值类型为void，下面会报错。因为没有返回值，所以无法引用！
抽象double divid()；
void show(){
system . out . println( area is: mul())；//周长
system . out . println( area is: divid())；//面积
}
}
类平方扩展方法{
双d；
公共广场(双d) {
super()；
this.d=d
}
@覆盖
double mul() {
返回d * d
}
@覆盖
double divid() {
返回4 * d；
}
}
类循环扩展方法{
双r；
公共环路(双r)
super()；
this.r=r
}
@覆盖
double mul() {
返回2 * 3.14 * r；
}
@覆盖
double divid() {
返回3.14 * r * r
}
}
公开课演示16 {
公共静态void main(String[] args) {
正方形s=新正方形(5)；
s . show()；
cir le c=new cir le(4)；
c . show()；
}
}以上是这次java面向对象的详细讲解，以后会继续为大家整理。
如文中有明显错误请指正，谢谢！
更多JAVA相关问题，请访问PHP中文网：JAVA视频教程。以上是java——的详细内容——面向对象详细介绍(二)。更多信息请关注我们的其他相关文章！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。