Java入门第二季

声明

本文内容(文字及图片)大部分来自慕课网——Java入门第二季，仅作为学习笔记，建议读者从慕课网获取更多相关内容。如该网站中素材不同意该笔记使用，请以评论形式告知，我会立即删除。

本课程学习时间：2015.12.24～2015.12.24 累计学习时间7h+-

类和对象

什么是类和对象

对象

万物皆对象，客观存在的事物皆为对象。

类

类是模子，确定对象将会拥有的特征(属性)和行为(方法)。

特点

1. 类是对象的类型。
2. 具有相同属性和方法的一组对象的集合。

类和对象的关系

类是抽象的概念，而对象是一个能够看得见，摸得着的具体实体。

如何定义Java中的类

定义类

所有的Java程序都以类class为组织单元。

步骤:

1. 定义类名 public class 类名{…}
2. 编写类的属性 public class 类名{属性1;属性2;}
3. 编写类的方法 public class 类名{属性1;属性2;方法1;方法2;}

举例:

package com.imooc;
//1. 定义一个类
public class Telphone{
	//2. 属性(成员变量)有什么
	float screen;
	float cpu;
	float mem;
	//3. 方法 干什么
	void call(){
		System.out .println("Telphone有打电话的功能！");
	}
	void sendMessage(){
		System.out.println("Telphone有发短信的功能");
	}
}

如何使用Java中的对象

1.创建对象

//类名 对象名 = new 类名();
Telphone phone = new Telphone();

2.使用对象

//引用对象的属性 : 对象名.属性
phone.screen = 5;
//引用对象的方法 : 对象名.方法名()
phone.sendMessage();

本节课示例代码：

//Telphone.java
package com.imooc;
//1. 定义一个类
public class Telphone{
	//2. 属性(成员变量)有什么
	float screen;
	float cpu;
	float mem;
	//3. 方法 干什么
	void call(){
		System.out .println("Telphone有打电话的功能！");
	}
	void sendMessage(){
		System.out.println("screen : "+ screen + " cpu : " + cpu + "mem : " + mem + " Telphone有发短信的功能");
	}
}
//InitialTelphone.java
package com.imooc;
public class InitialTelphone {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Telphone phone = new Telphone();
		phone.sendMessage();
		//给实例变量复制
		phone.screen = 5.0f;
		phone.cpu = 1.4f;
		phone.mem =2.0f;
		//调用对象的方法
		phone.sendMessage();
	}
}

Java中的成员变量和局部变量

1.成员变量：在类中定义，用来描述对象将要有什么。

2.局部变量：在类的方法中定义，在方法中临时保存数据。

区别:
1.作用域不同。

2.初始值不同。成员变量会被自动赋初始值，局部变量不会被赋初始值。

3.两类变量同名时，局部变量具有更高优先级。

Java中的构造方法

1.使用new+构造方法 创建一个新的对象

2.构造方法是定义在Java类中的一个用来初始化对象的方法，构造方法与类同名且没有返回值

//1.无参构造方法的使用
main():
	Telphone phone = new Telphone();
class Telphone:
	public Telphone(){
		System.out.println("Telphone构造方法执行了"):
	}<Br/>
//2.含参构造方法的使用
main():
	Telphone phone = new Telphone(4.0f, 2.0f, 2.0f);
class Telphone:
	public Telphone(float newScreen, float newCpu, float newMem){
		screen = newScreen;
		cpu = newCpu;
		mem = newMem;
	}

Java 中的 static 使用之静态变量

Java 中被 static修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特殊性更推荐用类名访问~~

public class HelloWorld {
    // 定义静态变量，保存班级名称
    static String className = "JAVA开发一班";
	public static void main(String[] args) {
		// 使用类名访问静态变量，输出班级名称
		System.out.println(HelloWorld.className);
	}
}

Java 中的 static 使用之静态方法

与静态变量一样，我们也可以使用 static修饰方法，称为静态方法或类方法。其实之前我们一直写的 main 方法就是静态方法。
Tips

• 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。
• 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量。
• 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。

Java 中的 static 使用之静态初始化块

在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用 static修饰初始化块，就称为静态初始化块。

需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。

初始化顺序：静态初始化块>初始化块>构造方法

举例：

public class HelloWorld {

    String name; // 声明变量name
	String sex; // 声明变量sex
	static int age;// 声明静态变量age
    
    // 构造方法
	public HelloWorld() { 
		System.out.println("通过构造方法初始化name");
		name = "tom";
	}
    
    // 初始化块
	{ 
		System.out.println("通过初始化块初始化sex");
		sex = "男";
	}
    
    // 静态初始化块
    static { 
		System.out.println("通过静态初始化块初始化age");
		age = 20;
	}
    
	public void show() {
		System.out.println("姓名：" + name + "，性别：" + sex + "，年龄：" + age);
	}
    
	public static void main(String[] args) {
        
        // 创建对象
		HelloWorld hello = new HelloWorld();
		// 调用对象的show方法
        hello.show();
        
	}
}

输出为：

通过静态初始化块初始化age
通过初始化块初始化sex
通过构造方法初始化name
姓名：tom，性别：男，年龄：20

封装

什么是Java中的封装

概念

将累的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

好处

1. 只能通过规定的方法访问数据。
2. 隐藏类的实例细节，方便修改和实现。

方法

隐藏属性，设置set/get属性来对属性的值进行修改。

使用包管理Java中的类

包的作用

1. 管理Java文件
2. 解决同名文件冲突

定义包:package包名

注：必须放在Java源程序的第一行，包名间可以使用”.”号隔开。eg.com.immoc.MyClass

系统中的包

1. java.(功能).(类)
2. java.lang.(类) 包含Java语言基础的类
3. java.util.（类) 包含Java语言中各种工具类
4. java.io.(类) 包含输入、输出相关功能的类

包的使用

1. import com.xxx.xxx
2. Java中，包的命名规范是全小写字母拼写
3. 使用的时候可以加载某个包下的所有文件，也可以加在某个具体子包下的所有文件，使用*代替即可

Java 中的访问修饰符

修饰符：可以修饰属性和方法的访问范围

访问修饰符的总结：

1. private:本类
2. 默认(缺省):本类、同包
3. protected:本类、同包、子类
4. public:本类、同包、子类、其他

Java 中的 this 关键字

this关键字代表当前对象，为了区分属性和参数的名称，常使用this关键字

什么是 Java 中的内部类

概念

内部类（ Inner Class）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

作用

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据
3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

   分类

• 成员内部类
• 静态内部类
• 方法内部类
• 匿名内部类

  示例

  //外部类HelloWorld
  public class HelloWorld {
      
      // 内部类Inner，类Inner在类HelloWorld的内部
      public class Inner {
          
  		// 内部类的方法
  		public void show() {
  			System.out.println("welcome to imooc!");
  		}
  	}
      
  	public static void main(String[] args) {
          
          // 创建外部类对象
  		HelloWorld hello = new HelloWorld();
          // 创建内部类对象
  		Inner i = hello.new Inner();
          // 调用内部类对象的方法
  		i.show();
  	}
  }

Java 中的成员内部类

//外部类HelloWorld
public class HelloWorld{
    
    //外部类的私有属性name
    private String name = "imooc";
    
    //外部类的成员属性
    int age = 20;
    
	//成员内部类Inner
	public class Inner {
		String name = "爱慕课";
        //内部类中的方法
		public void show() { 
			System.out.println("外部类中的name：" + HelloWorld.this.name);
			System.out.println("内部类中的name：" + name);
			System.out.println("外部类中的age：" + age);
		}
	}
    
	//测试成员内部类
	public static void main(String[] args) {
        
        //创建外部类的对象
		HelloWorld o = new HelloWorld (); 
        
        //创建内部类的对象
		Inner inn = o. new Inner();
        
        //调用内部类对象的show方法
		inn.show();
	}
}

Java 中的静态内部类

//外部类
public class HelloWorld {
    
    // 外部类中的静态变量score
    private static int score = 84;
    
    // 创建静态内部类
	public static class SInner {
        // 内部类中的变量score
        int score = 91;
        
		public void show() {
			System.out.println("访问外部类中的score：" + HelloWorld.score);
			System.out.println("访问内部类中的score：" + score);
		}
	}

	// 测试静态内部类
	public static void main(String[] args) {
		// 直接创建内部类的对象
        SInner si = new SInner();
        
        // 调用show方法
		si.show();
	}
}

Java 中的方法内部类

方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。

//外部类
public class HelloWorld {
    
    private String name = "爱慕课";
    
    // 外部类中的show方法
    public void show() { 
		// 定义方法内部类
		class MInner {
			int score = 83;
			public int getScore() {
				return score + 10;
			}
		}
        
		// 创建方法内部类的对象
        MInner mi = new MInner();
        
        // 调用内部类的方法
		int newScore = mi.getScore();
        
		System.out.println("姓名：" + name + "\n加分后的成绩：" + newScore);
	}
    
	// 测试方法内部类
	public static void main(String[] args) {
        
		// 创建外部类的对象
        HelloWorld mo = new HelloWorld();
        
        // 调用外部类的方法
		mo.show();
	}
}

继承

Java中的继承

继承是类与类的一种关系，是一种”is a”的关系。在Java中，继承是单继承。子类拥有父类的所有属性和方法，实现代码的复用。

//语法
class 子类 extends 父类{
...
}

Java 中的方法重写

什么是方法的重写：

如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法。

语法规则

1. 返回值类型与父类相同
2. 方法名与父类相同
3. 参数类型及个数与父类相同

Java中的继承初始化顺序

继承初始化顺序：

1. 先初始化父类再初始化子类
2. 先执行初始化对象中属性，再执行构造方法中的初始化
   总的来说，先执行父类对象的属性初始化，然后执行父类的构造方法，再执行子类对象的属性初始化，再执行子类对象的构造方法。

Java中的final的使用

final可以修饰类、方法、属性和变量

1. final修饰类，则该类不允许被继承
2. final修饰方法，则该方法不允许被覆盖
3. final修饰属性(则该类的属性不会进行隐式的初始化或在构造方法中赋值)
4. final修饰变量，则该变量的值只能赋一次值，即变为常亮。

Java中super的使用

super关键字：在对象的内部使用，可以代表父类对象。

1. 访问父类的属性。eg. super.age;
2. 访问父类的方法。eg. super.eat();

super的应用

• 子类的构造的过程当中必须调用其父类的构造方法。
• 如果子类的构造方法中没有显式调用父类的构造方法，则系统默认调用父类无参的构造方法。
• 如果显式的调用构造方法，必须在子类的构造方法的第一行。
• 如果子类构造方法中既没有显式调用父类的构造方法，而父类又没有无参的构造方法，则编译出错。

Java中Object类

Object类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认集成Object类。Object中的方法，适合所有子类。

1. toString()
2. equals();//比较的是对象的引用是否指向同一块内存地址

多态

对象具有多种形态

Java中的多态

1. 引用多态——使用父类的引用指向本类或子类的对象

   Animal obj1 = new Animal();//父类的引用是可以指向本类的对象
   Animal obj2 = new Dog();//父类的引用是可以指向子类的对象

2. 方法多态——创建本类对象时，调用的方法为本类方法。创建子类对象时，调用的方法为子类的方法或继承的方法。

多态中的引用类型转换

引用类型转换

1. 向上类型转换（隐式/自动类型转换），是小类到大类型的转换
2. 向下类型转换（强制类型转换），是大类型到小类型
3. instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题

举例：

Dog dog = new Dog();
Animal animal = dog;//自动类型提升 向上类型转换
if(animal instanceof Dog){
	Dog dog2 = (Dog)animal;//向下类型转换 强制类型转换
}
else
	System.out.println("无法进行类型转换 转换成Dog类型");
	
if(animal instanceof Cat){
Cat cat = (Cat)animal;//1.编译时 Cat类型 2.运行时 Dog类型
}
else
	System.out.println("无法进行类型转换 转换成Cat类型");

Java中的抽象类

1. 语法定义：抽象类前使用abstract关键字修饰，则该类为抽象类
2. 作用：不关注子类的实现，

Java中的接口

1. 接口概念：类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，借口不关心这些类的内部数据，也不关心这些类方法的实现细节，它只规定这些类里必须提供某些方法。
2. 接口定义：和类定义不同，定义接口不再使用class关键字，而是使用interface关键字。
3. 语法格式：

   [修饰符] interface 接口名 [extends 父接口1,父接口2,...]{
       零到多个常量定义...
       零到多个抽象方法的定义...
   }

Tips:

• 接口就是用来被继承、被实现的，修饰符一般建议使用Public，不能使用private,protected
• 接口中的属性是常量，即使定义时不添加public static final修饰符，系统也会自动加上
• 接口中的方法是抽象方法，即使定义时不添加public abstract修饰符，系统也会自动加上

1. 匿名内部类

2. IPlayGame ip3 = new IPlayGame(){
   	@Override
   	public void playGame() {
   		// TODO Auto-generated method stub
   		System.out.println("使用匿名内部类的方式实现接口");
   	}
   };
   ip3.playGame();
   new IPlayGame(){
   	public void playGame() {
   		// TODO Auto-generated method stub
   		System.out.println("使用匿名内部类的方式实现接口2");
   	}
   }.playGame();

UML简介

UNL概念——统一建模语言或标准建模语言

• 是一个支持模型化和软件系统开发的图形化语言
• 为软件开发的所有阶段提供模块化和可视化支持

UML图示

常用UML图

1. 用例图——用例图能够以可视化的方式，表达系统如何满足所收集的业务规则，以及特定的用户需求等信息。
2. 序列图
3. 类图——描述类和类的关系

UML建模工具

Visio、Rational Rose、PowerDesigner