11、子类接见父类和要领覆写
子类不能直接接见父类的私有成员；
然则子类能够挪用父类中的非私有要领来间接接见父类的私有成员。
Person类中有私有字段name,Student继承Person
new Sudent().name; ×
new Student().getName(); √
子类拓展父类（子类是父类的一种特殊情况）
重如果以父类为基础，然后增加属于自身的字段和要领。
要领覆写发生缘由：
当父类中某个要领不适合于子类时,子类涌现父类如出一辙的要领.
推断必杀技:子类要领前加上@Override能编译经由过程,表明是要领的覆写。
挪用被掩盖的父类要领：运用super.要领名(实参);
要领覆写时应遵照的准绳(一同两小一大)：
(一同):
要领署名必需雷同;
(两小):
子类要领的返回值范例比父类要领的返回值范例更小或相称
子类要领声明抛出的非常应比父类要领说明抛出的非常更小或相称;
(一大):子类要领的接见权限应比父类要领更大或相称;
子类须要覆写父类要领。
当父类的某个要领不适合于子类自身的特征行动时就当覆写父类中应当转变的要领。
12、super关键字和挪用父类组织要领
示意父类对象的默许援用
假如子类要挪用父类被掩盖的实例要领，可用super作为挪用者挪用父类被掩盖的实例要领。
运用super挪用父类要领
运用super挪用父类的组织要领
挪用组织要领
本类中挪用另一个重载组织要领用this(参数列表)
子类组织要领挪用父类组织要领用super(参数列表)
子类挪用父类的组织要领时：
super必需放在第一句
Java在实行子类的组织要领前会先挪用父类无参的组织要领，其目标是为了对继承自父类的成员做初始化操纵。
子类在建立对象的时刻，默许挪用父类的无参组织要领，如果子类组织要领中显现指定挪用父类其他组织要领，就挪用指定的父类组织要领，作废挪用父类无参组织要领。
Eg：
package reviewDemo;
class A{
String name;
A(){
System.out.println("父类默许隐式的组织要领！");
}
A(String name){
System.out.println("父类显式的组织要领！");
}
}
class B extends A{
B(){
super(null);
System.out.println("子类默许隐式的组织要领！");
}
}
public class Demo10 {
public static void main(String[] args) {
new B();
}
}
13、面向对象之多态
多态:指同一个实体同时具有多种形式
比如,你去面馆吃面,说我要吃面,那末;老板给我牛肉面,鸡蛋面等都能够,
这就是说"面"有多种形状,也就是说实体有多种形状;
编译时的范例由声明该变量时运用的范例决议,运转时的范例由现实赋给变量的对象决议。
假如编译时范例和运转时范例差别，就涌现多态。
Eg：
条件:Student extends Person:
Person p = new Person();
Student s = new Student();
Person p = new Student();//多态
援用关联:父类变量指向子类实例对象
完成多态的机制:
父类的援用变量能够指向子类的实例对象,而递次挪用的要领在运转期才动态绑定，就是援用变量所指向的真正实例对象的要领,也就是内存里正在运转的谁人对象的要领，而不是援用变量的范例中定义的要领。
多态的作用：
把差别的子类对象都看成父类来看，能够屏障差别子类对象之间的差别，写出通用的代码，做出通用的编程，以顺应需求的不停变化。
只修正要领的完成，没必要修正要领的声明
继承是多态发生的条件条件;
分类:
编译时多态：要领重载
运转时多态：要领覆写
Eg：
package test;
class Dog{
void eat(){
System.out.println("平常的狗吃平常的狗粮！");
}
}
class HashDog extends Dog{
void eat(){
System.out.println("哈士奇吃哈士奇的狗粮！");
}
}
class ZangAoDog extends Dog{
void eat(){
System.out.println("藏獒吃藏獒的狗粮！");
}
}
//定义一个动物园喂的要领
class Zoo{
void feed(Dog d){
d.eat();
}
}
public class Demo11 {
public static void main(String[] args) {
Dog hd = new HashDog();
Dog zd = new ZangAoDog();
Zoo z = new Zoo();
z.feed(hd);
z.feed(zd);
}
}
输出：
哈士奇吃哈士奇的狗粮！
藏獒吃藏獒的狗粮！
14、援用变量范例转换
向上转型（子类→父类）：(自动完成)
父类称号 父类对象 = 子类实例 ;
向下转型（父类→子类）：(强迫完成)
子类称号 子类对象 = （子类称号）父类实例 ;
对象名 instanceof 类
推断指定的变量名此时援用的真正范例是不是是当前给出的类或子类；
我的总结：对象的范例和类必需有继承关联
Eg：
class A extends B{}
B b = new A();
If(b instanceof A){ ...
}
2、面向对象（2）
1、基础数据范例的包装类
弁言：Java首倡的万物皆对象，然则数据范例的分别涌现了基础数据范例和援用数据范例，那末我们怎样能把基础数据范例称为对象呢？
除了Integer和Character定义的称号和对应的基础范例差别大，其他六种都是将首字母大写就能够了。
Integer,Byte,Float,Double,Short,Long都是Number类的子类。(Number类背面讲)；
Character和Boolean都是Object直接子类；
8个类都是final润饰的(不可被继承)。
2、基础数据范例和包装类互相转换
把基础数据范例 → 包装类：
经由过程对应包装类的组织要领完成
除了Character外，其他包装类都能够传入一个字符串参数构建包装类对象。
包装类 → 基础数据范例
包装类的实例要领xxxValue(); // xxx示意包装类对应的基础数据范例
Eg：
boolean bool = false;
Boolean b2 = new Boolean(bool);
Integer i = new Integer(3);
int i2 = i.intValue();
Boolean b1 = new Boolean("TRue");//true
boolean b2 = b1.booleanValue();
Float f = new Float("3.14");//3.14
Integer i2 = new Integer("123s");//NumberFormatException
备注：
自动装箱&自动拆箱
jdk1.5最先涌现的特征：
自动装箱：可把一个基础范例变量直接赋给对应的包装类对象或则Object对象
自动拆箱：许可把 包装类对象直接赋给对应的基础数据范例
Eg：
Integer i = 3;//装箱
int i2 = i;//拆箱
Object flag = new Boolean(false);
if(flag instanceof Boolean){
Boolean b = (Boolean)flag;
boolean b2 = b;
}
3、基础范例和String之间的转换
String → 基础范例，除了Character外统统的包装类供应parseXxx(String s)静态要领，用于把一个特定的字符串转换成基础范例变量；
基础范例 → String，String 类有静态要领valueOf()，用于将基础范例的变量转换成String范例。
String str = "17"; int i = Integer.parseInt(str);//String --> 基础范例 String s1 = String.valueOf(i);//基础范例 --> String
4、Object类
统统类的大众父类，一旦一个类没有显现地继承一个类则其直接父类一定是Object。
统统数据范例都可用Object吸收
class OOXX extends Object{}等价于class ooXX {}
罕见要领
public boolean equals(Object obj)：对象比较
public int hashCode()：取得该对象的Hash码
public String toString()：对象形貌
Object类的 toString()要领：“对象的形貌”
发起统统类都覆写此要领
直接打印输出对象时，会挪用该对象的toString()要领。//能够不写出来
打印对象的时刻,现实挪用的对象现实指向的类的自我形貌；
全限制类名+@+十六进制的hashCode值，等价于
全限制类名+@+IntegertoHexString(该对象.hashCode)
equals也是推断是不是指向同一个对象
没有现实意义，有必要能够重写
public boolean equals(Object obj) {}
String 覆写了 Object的equals要领：只比较字符的序列是不是雷同
==用于推断两个变量是不是相称
基础范例：
援用范例：必需指向同一个对象，才true
只能比较有父子或平级关联的两个对象
new String("1") == new String("1"); ？
5、代码块
代码块指的是运用"{}"括起来的一段代码，依据代码块存在的位置能够分为4种:
一般代码块;
组织代码块;
静态代码块;
同步代码块(线程同步的时刻解说)。
代码块里变量的作用域：
只在自身所在区域(前后的{})内有效；
一般代码块：
一般代码块就是直接定义在要领或语句中定义的代码块：
public void show(){
一般代码块
}
组织代码块：
直接写在类中的代码块:
优先于组织要领实行，每次实例化对象之前都邑实行组织代码块。
Eg：
public class Demo {
{
System.out.println("我是组织代码块");
}
public Demo(){
System.out.println("我是组织要领");
}
public static void main(String[] args) {
Demo d1 = new Demo();
Demo d2 = new Demo();
}
}
静态代码块
运用static 润饰的组织代码块:
优先于重要领实行，优先于组织代码块实行，不论有建立若干对象，静态代码块只实行一次，可用于给静态变量赋值；
Eg：
package reviewDemo;
/**
* 测试各代码块的优先级
* 优先级递次：静态代码块 ＞ 组织代码块 ＞ 一般代码块
* 备注：不管建立几个对象，静态代码块只实行一次！
*/
public class Demo13 {
Demo13(){
System.out.println("我是组织要领！");
}
{
System.out.println("我是组织代码块！");//实例化对象的时刻才会去挪用！
}
static{
System.out.println("我是静态代码块！");
}
public static void main(String[] args) {
new Demo13();
new Demo13();//再次建立对象，证实不管建立频频对象，静态代码块都只实行一次
System.out.println("我是一般代码块！");
}
}
输出：
我是静态代码块！
我是组织代码块！
我是组织要领！
我是组织代码块！
我是组织要领！
我是一般代码块！
6、组织要领的私有化
有的时刻我们为了防止外界建立某类的实例，就将某类的组织要领私有化，即将它的组织要领用private润饰：
外界怎样用到？
供应get要领！不供应的话外界就没法建立对象！（对反射无效）
Eg：package reviewDemo;
class Stu{
//将组织要领私有化
private Stu(){
}
}
public class Demo15 {
public static void main(String[] args) {
Stu s = new Stu();
}
}
Singleton形式(单例形式) 饿汉式和懒汉式
目标：全部运用中有且只要一个实例，统统指向该范例实例的援用都指向这个实例。
比如一个国度就只要一个天子(XXX)，此时每一个人叫的“天子”都是指叫的XXX本人;
罕见单例形式范例：
饿汉式单例：直接将对象定义出来
懒汉式单例：只给出变量，并不将其初始化；
我的总结：
饿汉式，static润饰，跟着类的加载而加载，会消耗机能，然则要领相对简朴
懒汉式 第一次用的时刻相对较慢，由于须要加载！线程，不平安！
package reviewDemo;
//单例形式
//饿汉式,直接把对象组织出来
class SingleDemo{
private static SingleDemo s1 = new SingleDemo();
private SingleDemo(){
//供应私有化的组织要领，那末外界就不能组织对象了！
}
public static SingleDemo getS1() {
return s1;
}
}
//懒汉式，先定义，然则不建立对象
class SingleDemo2{
private static SingleDemo2 s3 ;
private SingleDemo2(){
//供应私有化的组织要领，那末外界就不能组织对象了！
}
public static SingleDemo2 getS3() {//这是一个要领，返回值为建立的对象！
if(s3 == null){
s3 = new SingleDemo2();
}//和饿汉式的区分，此时才来建立对象！
return s3;
}
}
public class Demo14 {
public static void main(String[] args) {
SingleDemo s1 = SingleDemo.getS1();
SingleDemo s2 = SingleDemo.getS1();
SingleDemo2 s3 = SingleDemo2.getS3();
SingleDemo2 s4 = SingleDemo2.getS3();
System.out.println(s1 == s2);
System.out.println(s3 == s4);
}
}
输出：true true
备注：罗列越发平安些
package reviewDemo;
enum Stu{
jake;
//将组织要领私有化起来，反射也不能建立对象，平安
private Stu(){
}
}
public class Demo15 {
public static void main(String[] args) {
}
}
8、final 关键字
final能够润饰类,要领,变量。
final润饰类不能够被继承，然则能够继承其他类。
final润饰的要领不能够被覆写,但能够覆写父类要领。
final润饰的变量称为常量，这些变量只能赋值一次。
内部类在局部时，只能够接见被final润饰的局部变量。
final润饰的援用范例变量,示意该变量的援用不能变,而不是该变量的值不能变;
Eg：
package reviewDemo;
final class Name{
}
class NewName extends Name{//ERROR，报错，由于Name有final润饰
}
public class Demo15 {
public static void main(String[] args) {
}
}
9、笼统类
当编写一个类时，我们每每会为该类定义一些要领，这些要领是用来形貌该类的行动体式格局，那末这些要领都有详细的要领体。
然则有的时刻，某个父类只是晓得子类应当包括怎样的要领，然则没法正确晓得子类怎样完成这些要领。
笼统要领的定义：经由过程abstract关键字来润饰的类称为笼统类；
总结：笼统类用private润饰，内里能够有效private润饰的要领（没有要领体），强迫子类举行覆写；
能够理解为：具有某些大众要领的一个总结类。
能够定义被abstract润饰的笼统要领
笼统要领只要返回范例和要领署名，没有要领体。
备注：
笼统类能够含有一般要领
笼统类不能建立实例对象（不能new）
须要子类掩盖掉统统的笼统要领后才能够建立子类对象，不然子类也必需作为笼统类
枚举罕见的几个笼统类：
流的四个基础父类
InputStream，OutputStream，Reader，Writer
我的总结：
笼统类是类的一种特殊情况:占有类的统统特性,然则不能实例化;平常的都得带有笼统要领。
笼统类不能够实例化，偶然看到的近似实例化是多态机制的表现，并非真正的实例化。
Eg：
Socket s = new Socket();
OutputStream os = s.getOutputStream();
左侧是OutputStream范例变量的声明，右侧是猎取笼统类OutputStream的一个实例对象！
package testDemo2;
abstract class Person{
}
class Student extends Person{
}
public class Demo2 {
public static void main(String[] args) {
Person p = new Student();//表现的是多态，父类声明实例化子类对象。而不是笼统类实例化
}
}
abstract要领
剖析事物时，发现了共性内容，就涌现向上抽取。会有如许一种特殊情况，就是功用声明雷同，但功用主体差别。
那末这时候也能够抽取，但只抽取要领声明，不抽取要领主体。那末此要领就是一个笼统要领。
abstract [非private接见润饰符] 返回值范例 要领称号(参数列表);
笼统要领要存放在笼统类中。
笼统要领也能够存在于接口中
Eg：
package reviewDemo;
abstract class Person3{
abstract void show();
abstract void inof();
void turn(){
}
}
class NewP extends Person3{
@Override
void show() {
}
@Override
void inof() {
}
//不覆写的话会报错
}
public class Demo15 {
public static void main(String[] args) {
//new Person3();报错！由于笼统类不能够实例化
}
}
10、笼统类的表现-模板形式
笼统类是多个详细子类笼统出来的父类,具有高层次的笼统性;以该笼统类作为子类的模板能够防止子类设想的随意性;
笼统类的表现重要就是模板形式设想,笼统类作为多个子类的通用模板,子类在笼统类的基础上举行拓展,然则子类在总体上大抵保存笼统类的行动体式格局;
编写一个笼统父类,该父类供应了多个子类的通用要领,并把一个或多个笼统要领留给子类去完成,这就是模板设想形式;
模板形式运用的简朴划定规矩:
1.笼统父类能够只定义须要运用的某些要领,其他留给子类去完成;
2.父类供应的要领只是定义了一个通用算法,其完成必需依靠子类的辅佐;
我的总结：
假如父类的要领不想被子类覆写，那末能够在前面加上final关键字润饰。
Eg：
package reviewDemo;
//模板形式
//笼统类中包括许多的笼统要领，子类必需去覆写！
abstract class Method{
abstract double mul();//返回值范例假如是void的话，下面报错，由于没有返回值，没法援用！
abstract double divid();
void show(){
System.out.println("面积是："+mul());//周长
System.out.println("面积是："+divid());//面积
}
}
class Square extends Method{
double d;
public Square(double d) {
super();
this.d = d;
}
@Override
double mul() {
return d * d;
}
@Override
double divid() {
return 4 * d;
}
}
class Cirle extends Method{
double r;
public Cirle(double r) {
super();
this.r = r;
}
@Override
double mul() {
return 2 * 3.14 * r;
}
@Override
double divid() {
return 3.14 * r * r;
}
}
public class Demo16 {
public static void main(String[] args) {
Square s = new Square(5);
s.show();
Cirle c = new Cirle(4);
c.show();
}
}
以上是本次整顿的关于java面向对象的细致解说，后续会为人人继承整顿。
文中如有显著毛病请斧正，感谢！
更多JAVA相干题目请接见ki4网：JAVA视频教程
以上就是java———面向对象细致引见（二）的细致内容，更多请关注ki4网别的相干文章！
