------- android培训、java培训、期待与您交流！ ---------
黑马程序员____面向对象（中）
引言：Java提倡的万物皆对象，但是数据类型的划分出现了基本数据类型和引用数据类型，那么我们怎么能把基本数据类型称为对象呢？
除了Integer和Character定义的名称和对应的基本类型差异大，其他六种都是将首字母大写就可以了。
Integer,Byte,Float,Double,Short,Long都是Number类的子类。(Number类后面讲)；
Character和Boolean都是Object直接子类；
8个类都是final修饰的(不可被继承)。
把基本数据类型→包装类：
通过对应包装类的构造方法实现
除了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;
}
我的总结：对于基本数据类型和包装类之间的装换，我们可以直接的用，相互转换，因为java5之后的自动拆箱、装箱功能！即便不知道这个，其实使用中也不影响！
String →基本类型，除了Character外所有的包装类提供parseXxx(String s)静态方法，用于把一个特定的字符串转换成基本类型变量；
基本类型→ String，String 类有静态方法valueOf()，用于将基本类型的变量转换成String类型。
String str = "17";
int i = Integer.parseInt(str);//String --> 基本类型
String s1 = String.valueOf(i);//基本类型 --> String
所有类的公共父类，一旦一个类没有显示地继承一个类则其直接父类一定是Object。
一切数据类型都可用Object接收
class OOXX extends Object{}等价于class ooXX {}
常见方法
public boolean equals(Object obj)：对象比较
public int hashCode()：取得该对象的Hash码
public String toString()：对象描述
public class Demo {
public static void main(String args[]) {
Integer x = 128;
Integer y =128;
System.out.println(x==y);//x==y是两个对象进行比较，结果为faulse,创建对象所赋值存储在常量区
System.out.println(y.equals(x));//equals 方法（是String类从它的超类Object中继承的）被用来检测两个对象是否相等，即两个对象的内容是否相等，区分大小写。
//*******************************
int x1 = 128;
Integer y1 =128;
System.out.println(x1==y1);//在这个比较当中Interger会自动拆箱成int类型，输出结果为ture。
System.out.println(y1.equals(x1));//同第二个
}
}
代码块指的是使用"{}"括起来的一段代码，根据代码块存在的位置可以分为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;
/**
* 测试各代码块的优先级
* 优先级顺序：静态代码块 ＞ 构造代码块 ＞ 普通代码块
* 备注：无论创建几个对象，静态代码块只执行一次！
*/
publicclass Demo13 {
Demo13(){
System.out.println("我是构造方法！");
}
{
System.out.println("我是构造代码块！");//实例化对象的时候才会去调用！
}
static{
System.out.println("我是静态代码块！");
}
publicstaticvoid main(String[] args) {
new Demo13();
new Demo13();//再次创建对象，证明无论创建几次对象，静态代码块都只执行一次
System.out.println("我是普通代码块！");
}
}
输出：
我是静态代码块！
我是构造代码块！
我是构造方法！
我是构造代码块！
我是构造方法！
我是普通代码块！
有的时候我们为了避免外界创建某类的实例，就将某类的构造方法私有化，即将它的构造方法用private修饰：
外界如何用到？
提供get方法！不提供的话外界就没法创建对象！（对反射无效）
Eg：package reviewDemo;
class Stu{
//将构造方法私有化
private Stu(){
}
}
publicclass Demo15 {
publicstaticvoid main(String[] args) {
Stu s = new Stu();
}
}
目的：整个应用中有且只有一个实例，所有指向该类型实例的引用都指向这个实例。
好比一个国家就只有一个皇帝(XXX)，此时每个人叫的“皇帝”都是指叫的XXX本人;
常见单例模式类型：
饿汉式单例：直接将对象定义出来
懒汉式单例：只给出变量，并不将其初始化；
我的总结：
饿汉式，static修饰，随着类的加载而加载，会损耗性能，但是方法相对简单
懒汉式 第一次用的时候相对较慢，因为需要加载！线程，不安全！
package reviewDemo;
//单例模式
//饿汉式,直接把对象构造出来
class Single{
privatestatic Singles = new Single();
private Single(){
//提供私有化的构造方法，那么外界就不能构造对象了！
}
publicstatic Single getInstance() {
returns;
}
}
//懒汉式，先定义，但是不创建对象
备注：枚举更加安全些
package reviewDemo;
enum Stu{
jake;
//将构造方法私有化起来，反射也不能创建对象，安全
private Stu(){
}
}
publicclass Demo15 {
publicstaticvoid main(String[] args) {
}
}
① final可以修饰类,方法,变量。
② final修饰类不可以被继承，但是可以继承其他类。
③ final修饰的方法不可以被覆写,但可以覆写父类方法。
④ final修饰的变量称为常量，这些变量只能赋值一次。
⑤ 内部类在局部时，只可以访问被final修饰的局部变量。
⑥ final修饰的引用类型变量,表示该变量的引用不能变,而不是该变量的值不能变;
Eg：
package reviewDemo;
finalclass Name{
}
class NewName extends Name{//ERROR，报错，因为Name有final修饰
}
publicclass Demo15 {
publicstaticvoid main(String[] args) {
}
当编写一个类时，我们往往会为该类定义一些方法，这些方法是用来描述该类的行为方式，那么这些方法都有具体的方法体。
但是有的时候，某个父类只是知道子类应该包含怎么样的方法，但是无法准确知道子类如何实现这些方法。
抽象方法的定义：通过abstract关键字来修饰的类称为抽象类；
我的总结：
抽象类用private修饰，里面可以有用private修饰的方法（没有方法体），强制子类进行覆写；
可以理解为：具有某些公共方法的一个总结类。
可以定义被abstract修饰的抽象方法
抽象方法只有返回类型和方法签名，没有方法体。
备注：
抽象类可以含有普通方法
抽象类不能创建实例对象（不能new）
需要子类覆盖掉所有的抽象方法后才可以创建子类对象，否则子类也必须作为抽象类
列举常见的几个抽象类：
流的四个基本父类
InputStream，OutputStream，Reader，Writer
我的总结：
抽象类是类的一种特殊情况:据有类的一切特点,但是不能实例化;一般的都得带有抽象方法。
抽象类不可以实例化，有时看到的近似实例化是多态机制的体现，并不是真正的实例化。
Eg：
Socket s = new Socket();
OutputStream os = s.getOutputStream();
左边是OutputStream类型变量的声明，右边是获取抽象类OutputStream的一个实例对象！
package testDemo2;
abstractclass Person{
}
class Student extends Person{
}
publicclass Demo2 {
publicstaticvoid main(String[] args) {
Person p = new Student();//体现的是多态，父类声明实例化子类对象。而不是抽象类实例化
}
}
abstract方法
分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是功能声明相同，但功能主体不同。
那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。
abstract [非private访问修饰符] 返回值类型方法名称(参数列表);
抽象方法要存放在抽象类中。
抽象方法也可以存在于接口中
Eg：
package reviewDemo;
abstractclass Person3{
abstractvoid show();
abstractvoid inof();
void turn(){
}
}
class NewP extends Person3{
@Override
void show() {
}
@Override
void inof() {
}
//不覆写的话会报错
}
publicclass Demo15 {
publicstaticvoid main(String[] args) {
//new Person3();报错！因为抽象类不可以实例化
}
}
抽象类是多个具体子类抽象出来的父类,具有高层次的抽象性;以该抽象类作为子类的模板可以避免子类设计的随意性;
抽象类的体现主要就是模板模式设计,抽象类作为多个子类的通用模板,子类在抽象类的基础上进行拓展,但是子类在总体上大致保留抽象类的行为方式;
编写一个抽象父类,该父类提供了多个子类的通用方法,并把一个或多个抽象方法留给子类去实现,这就是模板设计模式;
模板模式应用的简单规则:
1.抽象父类可以只定义需要使用的某些方法,其余留给子类去实现;
2.父类提供的方法只是定义了一个通用算法,其实现必须依赖子类的辅助;
我的总结：
如果父类的方法不想被子类覆写，那么可以在前面加上final关键字修饰。
Eg：
package reviewDemo;
//模板模式
//抽象类中包含很多的抽象方法，子类必须去覆写！
abstractclass Method{
abstractdouble mul();//返回值类型如果是void的话，下面报错，因为没有返回值，无法引用！
abstractdouble divid();
void show(){
System.out.println("面积是："+mul());//周长
System.out.println("面积是："+divid());//面积
}
}
class Square extends Method{
doubled;
public Square(double d) {
super();
this.d = d;
}
@Override
double mul() {
returnd * d;
}
@Override
double divid() {
return 4 * d;
}
}
class Cirle extends Method{
doubler;
public Cirle(double r) {
super();
this.r = r;
}
@Override
double mul() {
return 2 * 3.14 * r;
}
@Override
double divid() {
return 3.14 * r * r;
}
}
publicclass Demo16 {
publicstaticvoid main(String[] args) {
Square s = new Square(5);
s.show();
Cirle c = new Cirle(4);
c.show();
}
}
相关推荐
黑马程序员_毕向东_Java基础视频教程第05天-01-面向对象(概述).avi
黑马程序员 - Java基础教学 - 05 - 面向对象（1）.doc
1、 面向对象、跨平台性、健壮性、安全性、可移植性、多线程性、动态性等。 2、 JRE（Java Runtime Environment，Java 运行时环境），它相当于操作系统部分，提供了 Java 程序运 行时所需要的基本条件和许多 Java ...
传智播客_Java培训_毕向东_Java基础[03-面向对象]系黑马程序员_毕向东_Java基础视频教程
黑马程序员 - Java基础教学 - 08 - 面向对象（4）-多态.doc
C++机房预约系统：面向对象，文件操作，黑马程序员，部分优化，模板
含面向对象，异常处理和常用类，线程技术，集合框架，IO操作，网络编程，文件操作，反射机制，
黑马程序员 - Java基础教学 - 06 - 面向对象（2） - 关于静态static的那些事.doc
1、面向对象都有哪些特性以及你对这些特性的理解12 1、 Java 中实现多态的机制是什么 1、 Java 中异常分为哪些种类13 2、 调用下面的方法，得到的
编程就是让计算机为解决某个问题而使用某种程序设计语言编写程序代码，并最终得到结果的过程。 Java是SUN(Stanford University Network，斯坦福大学网络...是简单易学，完全面向对象，安全可靠，与平台无关的编程语言
在下载和比较了大量同类书籍后不得不承认孙卫琴老师的这本书循序渐进由浅入深是最好的Java入门教程，同时它的...本资源包含《Java面向对象编程》的电子书，实例源代码，课后题答案等可以说是当前该书最全的资源了。。。
（1）aop：面向切面编程，扩展功能不是修改源代码实现 （2）ioc：控制反转， - 比如有一个类，在类里面有方法（不是静态的方法），调用类里面的方法，创建类的对象，使用对象调用方法，创建类对象的过程，需要new...
C++面向对象——B站黑马程序员视频学习笔记。
linux编程，ppt文档，gdb，makefile，linux编程概述
第1章 Java开发入门一．填空题1. 面向对象，SUN 2. JavaSE，JavaEE，JavaME3.面向对象、跨平台性、支持多线程4. JDK5.bin
《JavaScript前端开发案例教程》是面向计算机相关专业的一门Web前端基础课程，涉及JavaScript语言基础、数组、函数、对象、BOM、DOM、事件、正则表达式、Ajax、jQuery等内容。
精选12种与多线程和并发处理相关的设计模式 264张图表 + 300段Java示例程序 = 轻松学习多线程编程 日本经典多线程入门书，原版长销11年！ 本书适合以下读者阅读 a....b....c....对面向对象开发感兴趣的人
观看黑马程序员Java零基础视频教学，从60P方法开始总结的知识集合，请使用Xmind打开，如果需要学习请配合视频打开：https://www.bilibili.com/video/BV17F411T7Ao
Qt是一个跨平台的C++图形用户界面应用程序框架。它为应用程序开发者提供建立艺术级图形界面所需的所有功能。它是完全面向对象的，很容易扩展，并且允许真正的组件编程。
面向对象的基础核心知识点之一，是日后学习JavaEE，JavaME的必备知识；注重基础的代码实例讲解， 让你轻松的学习Java基础知识，为以后学习铺平道路，打好基础；万丈高楼平地起，希望能帮助你！