JAVA入门2

课程地址：https://www.imooc.com/learn/124

powerDesign-uml下载地址：http://www.uml.org.cn/UMLTools/powerDesigner/powerDesignerToolIntroduction.htm

 

1、类和对象

1.1对象

1.2定义java中的类

定义类的首字母要大写

1.3使用java的对象

常常把属性称为实例变量

默认值是0

1.4成员变量，局部变量

成员变量

调用成员变量

局部变量只能在内部使用

1.5java中的构造法方法

1.6Java 中的 static 使用之静态变量

咱们能够基于一个类建立多个该类的对象，每一个对象都拥有本身的成员，互相独立。然而在某些时候，咱们更但愿该类全部的对象共享同一个成员。此时就是 static 大显身手的时候了！！

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

使用 static 能够修饰变量、方法和代码块。

本小节，咱们先认识一下静态变量。

例如，咱们在类中定义了一个 静态变量 hobby ，操做代码以下所示：

运行结果：

要注意哦：静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收！~~

1.7Java 中的 static 使用之静态方法

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

运行结果：

须要注意：

一、 静态方法中能够直接调用同类中的静态成员，但不能直接调用非静态成员。如：

若是但愿在静态方法中调用非静态变量，能够经过建立类的对象，而后经过对象来访问非静态变量。如：

二、 在普通成员方法中，则能够直接访问同类的非静态变量和静态变量，以下所示：

三、 静态方法中不能直接调用非静态方法，须要经过对象来访问非静态方法。如：

public class HelloWorld {
    
    // 定义静态变量score1
    static int score1 = 86;
    // 定义静态变量score2
	static           int score2 = 92; 

    // 定义静态方法sum，计算成绩总分，并返回总分
	public static    int sum() { 
      
      return score1+score2;
      
	}

	public static void main(String[] args) {
        
        // 调用静态方法sum并接收返回值
		int allScore =HelloWorld.sum();
        
		System.out.println("总分：" + allScore);
	}
}

1.8static 使用之静态初始化块

Java 中能够经过初始化块进行数据赋值。如：

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

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

咱们来看一段代码：

运行结果：

经过输出结果，咱们能够看到，程序运行时静态初始化块最早被执行，而后执行普通初始化块，最后才执行构造方法。因为静态初始化块只在类加载时执行一次，因此当再次建立对象 hello2 时并未执行静态初始化块。

2、封装

2.1面向对象特性-封装

 

设为私有属性

发现不能调用

get和set方法

使用

2.2使用包管理java中的类

2.3访问修饰符

2.4this关键字

类里面自动建立get，set方法

调用方法

2.5java中的内部类

定义：

内部类（ 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();
	}
}

（1）成员内部类：

内部类中最多见的就是成员内部类，也称为普通内部类。咱们来看以下代码：

运行结果为：

从上面的代码中咱们能够看到，成员内部类的使用方法：

一、 Inner 类定义在 Outer 类的内部，至关于 Outer 类的一个成员变量的位置，Inner 类可使用任意访问控制符，如 public 、 protected 、 private 等

二、 Inner 类中定义的 test() 方法能够直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a

三、 定义了成员内部类后，必须使用外部类对象来建立内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );

四、 编译上面的程序后，会发现产生了两个 .class 文件

其中，第二个是外部类的 .class 文件，第一个是内部类的 .class 文件，即成员内部类的 .class 文件老是这样：外部类名$内部类名.class

另外，友情提示哦：

一、 外部类是不能直接使用内部类的成员和方法滴

可先建立内部类的对象，而后经过内部类的对象来访问其成员变量和方法。

二、 若是外部类和内部类具备相同的成员变量或方法，内部类默认访问本身的成员变量或方法，若是要访问外部类的成员变量，可使用 this 关键字。如：

运行结果：

//外部类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();
	}
}

（2）静态内部类

特色是：

一、 静态内部类不能直接访问外部类的非静态成员，但能够经过 new 外部类().成员 的方式访问 

二、 若是外部类的静态成员与内部类的成员名称相同，可经过“类名.静态成员”访问外部类的静态成员；若是外部类的静态成员与内部类的成员名称不相同，则可经过“成员名”直接调用外部类的静态成员

三、 建立静态内部类的对象时，不须要外部类的对象，能够直接建立 内部类 对象名= new 内部类();

运行结果 ： 

//外部类
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();
	}
}

（3）方法内部类

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

必定要注意哦：因为方法内部类不能在外部类的方法之外的地方使用，所以方法内部类不能使用访问控制符和 static 修饰符。

//外部类
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();
	}
}

 

3、继承

3.1java中的继承

‘

’

父类写好

建立子类，并创建关系

建立测试类

3.2java中的方法重写

测试调用

3.3继承初始化顺序

先执行父类的构造方法，再执行子类的构造方法

10被20覆盖了，属性的初始化是先执行的，而后执行构造方法

3.4final关键字

（1）final修饰类

子类会报错

（2）final修饰方法

子类方法不容许覆盖或重写

（3）final修饰属性

子类属性报错

final关键字修饰属性，系统不会自动初始化

（4）final修饰变量

不容许修改变量

3.5super的使用

main里调用属性

main调用父类方法

main调用子类方法

父类无参的构造方法

子类的无参构造方法，隐式的显示

会自动执行父类构造方法

此时不是第一行，构造方法就不能够了

注意报错

子类没有显示调用父类的构造方法

父类定义一个有参的构造方法

报错

3.6java中的object类

包名+地址

eclipse自带根据对象属性生成自带toString方法

执行main后生成

 

即便是两个对象的属性值同样，也是不一样的地址

相似于==判断

eclipse提供了生成equals的方法

删除hash方法

分析

4、多态

4.1java中的多态

建立工程，默认选项

建立父类

建立子类

建立测试类

引用的多种形态

不能子类引用指向父类

父类写方法

子类重写方法

obj1（）调用的是父类方法

obj2（）调用的是子类方法

建立cat类，继承animal类

cat里不重写建立方法

子类继承父类的方法

子类独有地方法

main中不能经过继承调用子类独有的方法

练习

4.2多态中引用类型的转换

子类转换成父类

父类到子类，不容许

强制转换

强制转换存在风险，虽然编译器不保存，可是运行会报错

如何避免强制转换风险的问题呢？

使用：instanceof关键字

4.3java中的抽象类

定义父类为抽象类

定义子类，早年电话，继承父类

建立子类，智能电话

建立测试类

4.5java中的接口

extends关键字和implements关键字是不能调换的

一般在给接口命名的时候前面会加上一个大写的‘i’字母，用来区分和普通的类名不一样

声明接口的时候，省略掉了abstract关键字

声明接口里的方法时，也省略了abstract关键字

一般abstract关键字是不写的

书写接口

接口的建立

建立psp类，继承玩游戏

用接口来描述

接口的使用

内部类使用后，注意分号结束，经过接口调用

经过new和.直接调用

说明：在安卓开发和高级框架开发中，常常会使用匿名内部类的方式来使用接口

4.6UML简介

、

按住鼠标左键进行连线

选择继承关系

接口定义好

实现关系是虚线，继承关系是实线

修改父类返回值

子类自动修改

根据图像生成java语言

和之前作对比

改写统一名称方法，从新生成java

5、阶段练习

创建父类

建立子类

继承关系

多态关系

新建抽象类

子类继承抽象类

效果同样，可是更合理

6、综合练习

分析同窗案例：

右边更合理，不一样类型的车用不一样类

使用继承关系

使用多态