第1章 类和对象
1-1 什么是类和对象
1-2 如何定义 Java中的类
如何定义一个类：
1.类的重要性：所有java程序都是以类class为组织单元的，是基本元素。
2.类是模子，确定对象将会拥有什么样的特征（属性）和行为（方法）。先有类才能够描述具体对象。
3.类的组成：属性和方法
4.定义一个类的顺序：
a.定义类名：class是定义类的关键字。
b.编写类的属性
c.编写类的方法.
1-3 如何使用 Java 中的对象...
使用对象的步骤：
1．创建对象（实例化）
创建对象：类名 对象名 = new 类名（）；
Telphone phone = new Telphone()；
2.使用对象
使用对象的属性：对象名.属性
phone.screen = 5;//给screen属性赋值5
引用对象的方法：对象名.方法名（）
phone.sendMessage();//调用sendMessage()方法。
1-4 Java 中的成员变量和局部变量
成员变量和局部变量
1.成员变量
描述对象有什么（在类中定义）
类中所有方法都可以使用
2.局部变量
临时保存数据（在类的方法中定义）
只能在当前方法中使用
成员变量与局部变量的区别:
1.作用域不同
局部变量作用域仅限于定义它的方法内；
成员变量作用域在整个类内部都可见；
2.初始值不同
java会给成员变量一个初始值；
java不会给局部变量赋予初值；
3.变量名
在同一方法中，不允许有同名局部变量；
在不同方法中，允许有同名局部变量；
4.不同类同名变量的优先级
两类变量同名是，局部变量具有更高优先级
1-5 Java 中的构造方法
当没有指定构造方法时，系统会自动添加无参的构造方法；当有指定的构造方法时，无论有参数无参，系统都不会自动添加无参的构造方法；构造方法能重载，参数不同，调用时会自动根据参数情况进行选择；使用new+构造方法创建一个新的对象，构造方法是用来初始化对象的方法，与类名称相同
静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收！
1-6 Java 中的 static 使用之静态变量
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特殊性更推荐用类名访问~~
使用 static 可以修饰变量、方法和代码块。
1-7 Java 中的 static 使用之静态方法
与静态变量一样，我们也可以使用 static 修饰方法，称为静态方法或类方法。其实之前我们一直写的 main 方法就是静态方法。
1、 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。
2、 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量。
3、 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。
1-8 Java 中的 static 使用之静态初始化块
Java 中可以通过初始化块进行数据赋值。如：
在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。
需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。
通过输出结果，我们可以看到，程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。由于静态初始化块只在类加载时执行一次，所以当再次创建对象 hello2 时并未执行静态初始化块。
第2章 封装
2-1 什么是 Java 中的封装
面向对象三大特性:封装、继承、多态
1.封装:无法直接访问类的属性（类的属性设置为private）即隐藏属性，用setter和getter方法来访问修改。
2.封装的好处:只能通过规定的方法访问数据；隐藏类的实例细节,方便修改和实现
封装的实现步骤:
1、修改属性的可见性-属性前面加上修饰符private
2、创建getter/setter方法-用于属性的读写
3、在getter/setter方法中加入属性控制语句-对属性值的合法性进行判断
eg:
public class Telphone{
private float screen;
private float cpu;
private float mem;
public float getScreen(){
return screen;
}
public void setScreen(float newScreen){
screen=newScreen;
}
}
public static void main(String[] args) {
Telphone phone=new Telphone();
phone.setScreen(6.0f);
System.out.println("screen:"+phone.getscreen());}
2-2 使用包管理 Java 中的类
1.包的作用：
管理java文件
解决同名文件冲突
2.定义包：package 包名
注：必须放在java源程序的第一行
包名间可以使用"."号隔开
eg:com.imooc.MyClass
3.系统中的包
java.(功能).(类)
java.lang.(类)包含java语言基础的类
java.util.(类)包含java语言中各类工具类
java.io.(类)包含输入、输出相关功能的类
4.包的使用
1）可以使用import关键字，在某个文件使用其他文件中的类。
import com.imooc.music.MyClass
2）java中，包的命名规范是全小写字母拼写
3）使用的时候不但可以加载某个包下的所有文件
eg：com.imooc.
也可以加载某个具体子包下的所有文件
eg:com.imooc.music.
2-3 Java 中的访问修饰符
访问修饰符，定义对象的使用范围，private,默认，protected,public，范围依次增强
private:本类
默认：当前包
protected：本类，当前包，子类
public:公交车
2-4 Java 中的 this 关键字...
1、this关键字代表当前对象
this.属性 操作当前对象的属性
this.方法 调用当前对象的方法
2、封装对象属性的时候，经常会使用this关键字
2-5 什么是 Java 中的内部类
JAVA中的内部类
问：什么是内部类呢？
答：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
问：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！
答：内部类的主要作用如下：
- 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
- 内部类的方法可以直接访问外部类的所有数据，包括私有的数据
- 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
问：内部类有几种呢？
答：内部类可分为以下几种：
成员内部类
静态内部类
方法内部类
匿名内部类
2-6 Java 中的成员内部类
内部类：<br>
内部类是在类里面创建的类。<br>
内部类可以直接使用外部类的所有成员及方法。<br>
外部类则不能直接使用，必须先创建内部类的对象，再通过对象来调用。<br>
如果在其他类中使用内部类，必须先创建外部类对象，在通过外部类对象创建内部类对象。
/**
- 内部类的使用方法
- */
package com.my.inner;
public class InnerClass {
private float size;
public String num;
public void time(){
System.out.println("2016.7.11");
}
public String InnerTest(){ //外部类使用内部类的成员或方法，需先创建内部类对象。
Phone p = new Phone();
p.name = "asus";
return p.name;
}
public class Phone {
private String name;
private int money;
int size;
public void ownsize(float s){
InnerClass.this.size = s; //如果内部类的成员变量与外部类相等，这样来使用外部类的变量
time();
}
}
public static void main(String[] args) {
Phone xiaomi = new InnerClass().new Phone();//内部类对象的创建
xiaomi.name = "xiaomi";
xiaomi.money = 1499;
xiaomi.ownsize(5.0f);
}
}
2-7 Java 中的静态内部类
静态内部类：
内部类只能直接访问外部类的静态成员变量或则方法，需要先实例化外部类的对象才能调用外部类的成员变量或成员方法。
内部类与外部类相同的变量或方法，如果想调用该变量或方法，可以直接外部类名+成员/方法。
内部类对象的创建不需要先创建外部类对象。
package com.my.staticinnerclass;
/*
静态内部类的使用
*/
public class SInnerClass {
private int a = 99;
static int b = 1;
private void print(){
System.out.println("SInnerClass");
}
public static class SInner{
int b = 1;
public void test(){
System.out.println("外部类的b值为："+SInnerClass.b);//当内部类成员变量与外部类相同时，使用外部类成员变量的方法
System.out.println("内部类的b值为："+b);
new SInnerClass().print();//使用非静态的外部类成员变量或成员方法
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
SInner sinner = new SInner(); //内部类对象的创建方法
sinner.test();
}
}
2-8 Java 中的方法内部类
方法内部类：
方法内部类指在外部类成员方法中创建的类。所以不能是由static，public等等控制符和修饰符。
方法内部类对象只能在成员方法中创建和使用。
/**
- 方法内部类的使用
*/
package com.my.fncinner;
public class FncOuter {
private int a;
public void print(){
class FInner { //在外部类的方法里创建方法内部类
int a;
public void print(){
System.out.println("this is FuncInner: a = " + a);
System.out.println("Out class a = " + new FncOuter().a);
}
}
FInner finner = new FInner();//方法内部类对象只能在外部类方法中创建和使用。
finner.print();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
FncOuter fncouter = new FncOuter();
fncouter.print();
}
}
第3章 继承
3-1 Java 中的继承
//Java中的继承
1、继承就是类与类的一种关系，Java中的继承是单继承，也就是一个类只有一个父类
2、继承的好处：子类拥有父类的所有属性和方法（父类属性和方法修饰符不能是private）；实现代码复用；
3、语法规则：class 子类 extends 父类{...}
Eclipse创建Java类的选项里，superclass可以选择父类(可能需要手动输入搜索；
3-2 Java 中的方法重写
、方法的重写：如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法
2、语法规则：
a.返回值类型
b.方法名
c.参数类型及个数
都要与父类继承的方法相同，才叫方法的重写
3-3 Java 中的继承初始化顺序
继承的初始化顺序：
1.初始化父类再初始化子类。
2.先执行初始化对象中的属性，再执行构造方法中的初始化。
父类对象-->属性初始化--->构造方法
子类对象-->属性初始化--->构造方法
3-4 Java 中的 final 的使用
final 关键字
1.final 修饰类，该类不能被继承
2.final 修饰方法，该方法不能被覆盖（重写），但可以被继承（extends）
3.final 修饰属性，该属性不会自动进行隐式的初始化
4.final 修饰变量，该变量的值智能赋值一次，即变为常量
3-5 Java 中的 super 的使用
super关键字指的是父类对象
1.访问父类的属性
super.age
2.访问父类的方法
super.eat()
子类的构造的过程当中必须调用其父类的构造方法 相当于super();默认是调用无参的
如果子类的构造方法中没有显示调用父类的构造方法,系统会默认调用父类无参的构造方法.
如果要显示的调用父类的构造方法,必须在子类的构造方法第一行中添加super();
如果子类构造方法中既没有显示调用父类的构造方法,而父类又没有无参的构造方法,则编译出错,如果父类是定义了有参的构造方法,那么子类必须super.(父类的参数),或者父类中添加一个无参的构造方法,否则出错 因为默认调用的是super();是无参的。
一个类中没有定义构造方法,则系统会默认为此类定义一个无参的构造方法.如果自定义了一个带参的构造方法,则系统不会为其添加无参的构造方法.
3-6 Java 中的 Object 类 I
Object类是所有类的父类,如果一个类没有使用extends关键字明确标识继承另外一个类,那么这个类默认继承Object类,且Object类中的方法适合所有子类
1.toString()方法
在Object类里面定义toString()方法的时候返回的对象的哈希code码(对象地址字符串)
如果我们在代码里面直接输出一个对象,会输出这个对象在内存中的地址,我们把它称为哈希码,哈希码是通过哈希算法生成的一个字符串用来唯一区分对象的
可以通过重写toString()方法表示出对象的属性
(我们经常在输出对象的时候希望得到子类的属性值,那么我们就要重写从父类继承来的toString()方法,eclipse中右键菜单栏-源码source-生成generate toString(),他就会根据我们对象的属性帮我们生成一个toString()方法来输出属性值)
getClass()可以得到一个类对象,当我们new的时候得到的是一个类的对象如果对象调用getClass()方法我们得到的是类对象,类对象描述的是类的代码信息(类的代码信息:这个类有哪些属性\它是什么类型\变量名是什么\它有哪些方法\方法名是什么\方法里面的代码是什么;而类的对象关注的是对象的属性值的信息或者说这个对象的数据信息)
3-7 Java 中的 Object 类 II
equals（）----返回值是布尔类型
比较的是对象的引用是否指向同一块内存地址-------对象实例化时，即给对象分配内存空间
使用方法如：dog.equals(dog2);
如果是两个对象，但想判断两个对象的属性是否相同，则重写equals（）方法
1.地址是否相同----if (this == obj)
2.对象是否为空----if (obj == null)
3.getClass（）可以得到类对象，判断类型是否一样-----if (getClass() != obj.getClass())
new出来的是类的对象，关注的是类的属性的具体的数据；
类对象是类的代码信息，关注的是类有什么属性和方法
4.属性值是否一样----if (age != other.age)
第4章 多态
4-1 Java 中的多态
多态： 指的是对象的多种形态
主要分为 引用多态 、方法多态
继承是多态的实现基础，别忘了子父类要有继承关系.
多态特性：
一、引用多态
1.父类引用可以指向本类对象 Animal obj1 = new Animal();
2.父类引用可以指向子类对象 Animal obj2 = new Dog();
但是我们不能用子类的引用指向父类对象 Dog obj3 = new Animal();//错
二、方法多态
1.在父类Animal中定义一个eat()方法，输出一个语句(动物有吃的能力); 在子类Dog中重写eat()方法，输出一个语句（狗是吃肉的）; 那么我们在测试类main函数里面，如果obj1.eat() ，那么调用的是父类的方法. 若用obj2调用eat()方法，那么调用的是子类的方法.
2.还有一种情况，比如创建一个继承父类Animal的子类Cat ，但是Cat里并不重写继承的eat()方法. 然后，我们在测试类main函数里创建一个子类对象, Animal obj3 = new Cat(); 然后调用 obj3.eat(); 那么，结果调用的则是子类继承父类的方法. (输出结果：动物有吃的能力)
3.最后一种特殊情况，多态的特性是不能使用的. 若在子类添加一个独有的方法 public void watchDoor() ，含有一句输出语句(狗具有看门的能力); 那么我们在测试类的main函数当中(得先定义好对象Animal obj2 = new Dog() )，就不能用obj2.watchDoor()，即不能通过父类的引用调用子类的方法.
4-2 多态中的引用类型转换
从对象的内存角度来理解.
假设现在有一个父类Father,它里面的变量需要占用1M内存.有一个它的子类Son,里面的变量需要占用0.5M内存.
现在通过代码来看看内存的分配情况:
2.f = new Father();//系统将分配1M内存.
Son s = new Son();//系统将分配1.5M内存!因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.由于s中包含了父类的实例,所以s可以调用父类的方法.
3.Son s1 = s;//s1指向那1.5M的内存.
Father f1 = (Father)s;//这时f1会指向那1.5M内存中的1M内存,即是说,f1只是指向了s中实例的父类实例对象,所以f1只能调用父类的方法(存储在1M内存中),而不能调用子类的方法(存储在0.5M内存中).
Son s2 = (Son)f;//这句代码运行时会报ClassCastException.因为f中只有1M内存,而子类的引用都必须要有1.5M的内存,所以无法转换.
Son s3 = (Son)f1;//这句可以通过运行,这时s3指向那1.5M的内存.由于f1是由s转换过来的,所以它是有1.5M的内存的,只是它指向的只有1M内存.
从对象的内存角度来理解.
假设现在有一个父类Father,它里面的变量需要占用1M内存.有一个它的子类Son,里面的变量需要占用0.5M内存.
现在通过代码来看看内存的分配情况:
2.f = new Father();//系统将分配1M内存.
Son s = new Son();//系统将分配1.5M内存!因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.由于s中包含了父类的实例,所以s可以调用父类的方法.
3.Son s1 = s;//s1指向那1.5M的内存.
Father f1 = (Father)s;//这时f1会指向那1.5M内存中的1M内存,即是说,f1只是指向了s中实例的父类实例对象,所以f1只能调用父类的方法(存储在1M内存中),而不能调用子类的方法(存储在0.5M内存中).
Son s2 = (Son)f;//这句代码运行时会报ClassCastException.因为f中只有1M内存,而子类的引用都必须要有1.5M的内存,所以无法转换.
Son s3 = (Son)f1;//这句可以通过运行,这时s3指向那1.5M的内存.由于f1是由s转换过来的,所以它是有1.5M的内存的,只是它指向的只有1M内存.
4-3 Java 中的抽象类
抽象类定义
1、语法定义：
抽象类钱使用abstract关键字修饰，则该类为抽象类。
2、应用场景：
a、在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法
b、从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。
3、作用：
限制规定子类必须实现某些方法，但不关注实现细节。
4、使用规则：
a、abstract定义抽象类
b、abstract定义抽象方法，只有声明，不需要实现
c、包含抽象方法的类是抽象类
d、抽象类中可以包含普通的方法，也可以没
4-4 Java 中的接口
接口=全局常量+公共的抽象方法；
接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。
2.接口用interface定义，语法：
[修饰符] interface abstract 接口名 [extends 父接口1，父接口2……]
{//中括号中为可选项
零个到多个常量定义……
零个到多个抽象方法的定义
}
3.接口就是用来被继承、被实现的，修饰符一般建议用public，不能使用private和protected修饰接口。
4.接口中的属性是常量（public static final修饰），系统会自动加上
5.接口中的方法只能是抽象方法（public abstract修饰），系统会自动加上
6.使用接口：一个类可以实现一个或多和接口，实现接口使用implements关键字。java中一个类只能继承一个父类，可以通过实现多个接口作补充
7.继承父类实现接口的语法：
[修饰符] class 类名 extends 父类 implements 接口1，接口2……{
类体部分}//如果继承的是抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法
如果要继承父类，继承父类必须在实现接口之前
接口命名时首字母为I，以区分类名。可通过add继承父接口
8.实现时可以利用接口的引用指向实现了接口的对象，调用其方法，如 ：
IPlay ip1=new Psp();ip1.playGame();
9.接口的使用还经常与匿名内部类配合（匿名内部类就是没有名字的内部类，多用于关注实现而不关注实现类的名称）
语法格式：
Interface i=new Interface(){
public void method(){
System.out.print("匿名内部类实现接口的方式……");}}
//即通过创建接口的对象，直接写出实现的方法，再调用此方法
还可以直接创建并调用方法，如：
new IPlay(){
public void playGame(){
System.out.println("……");}}.playGame();
4-5UML 简介
本节视频比较详细地介绍了UML的基本概念，POWER DESIGNER的使用方法。
UML简介：
1、Unified Modeling Language，统一建模语言/标准建模语言，是支持模型化和软件系统开发的图形化语言；是一个支持模型化和软件系统开发的图形化语言；为软件开发的所有阶段提供模型化的可视化支持
2、用例图：可视化表达系统如何满足业务规则和特定的用户需求；
3、序列图：表述计算机角色和相互关系，按照交互发生的顺序显示对象之间的交互；
4、类图/类别图：描述类之间的关系，类中的属性和方法；
5、UML类图、业务逻辑和所有支持结构一同被用于定义全部的代码结构；