黑马程序员-------面向对象基础知识2

第一讲继承 1. 为什么会有继承？在平时写代码的过程中，发现很多类都是具有共性的，将这些共性抽取出来变成一个父类，通过继承的方式来改进或者实现这些共性

2. 继承概述

把多个类中相同的内容给提取出来定义到一个类中。

如何实现继承呢?

Java提供了关键字：extends

格式：

class 子类名 extends 父类名 {}

好处：

A:提高了代码的复用性

B:提高了代码的维护性

C:让类与类之间产生了关系，是多态的前提

类与类产生了关系，其实也是继承的一个弊端：

类的耦合性增强了。

开发的原则：低耦合，高内聚。

耦合：类与类的关系

内聚：就是自己完成某件事情的能力

3.Java中继承的特点：

A:Java只支持单继承，不支持多继承。

有些语言是支持多继承，格式：extends 类1,类2,...

B:Java支持多层继承(继承体系) 4.继承的注意事项：

A:子类只能继承父类所有非私有的成员(成员方法和成员变量)

B:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。

C:不要为了部分功能而去继承那么，我们什么时候考虑使用继承呢?

继承其实体现的是一种关系："is a"。比如说：爸爸是个人，狗是个动物

继承示例：

//使用继承前
/*
class Student {
	public void eat() {
		System.out.println("吃饭");
	}
	
	public void sleep() {
		System.out.println("睡觉");
	}
}

class Teacher {
	public void eat() {
		System.out.println("吃饭");
	}
	
	public void sleep() {
		System.out.println("睡觉");
	}
}
*/

//使用继承后
class Person {
	public void eat() {
		System.out.println("吃饭");
	}
	
	public void sleep() {
		System.out.println("睡觉");
	}
}

class Student extends Person {}

class Teacher extends Person {}

class ExtendsDemo {
	public static void main(String[] args) {
		Student s = new Student();
		s.eat();//调用Person的方法
		s.sleep();//调用Person的方法
		System.out.println("-------------");
		
		Teacher t = new Teacher();
		t.eat();//调用Person的方法
		t.sleep();//调用Person的方法
	}
}

注意： Java中继承的特点：

A:Java只支持单继承，不支持多继承。

有些语言是支持多继承，格式：extends 类1,类2,...

B:Java支持多层继承(继承体系) class Father {}

class Mother {}

class Son exnteds Father {} //正确的

class Son extends Father,Mother {} // 错误的

5.super关键字用于在子类中,可以直接访问父类的数据

this和super的区别

分别是什么呢?

this代表本类对应的引用。

super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员

怎么用呢?

A:调用成员变量

this.成员变量调用本类的成员变量

super.成员变量调用父类的成员变量

B:调用构造方法

this(...) 调用本类的构造方法

super(...) 调用父类的构造方法

C:调用成员方法

this.成员方法调用本类的成员方法

super.成员方法调用父类的成员方法

6.方法的继承(重写)和重载方法重写：子类中出现了和父类中方法声明一模一样的方法。

方法重载：

本类中出现的方法名一样，参数列表不同的方法。与返回值无关。

子类对象调用方法的时候：

先找子类本身，再找父类。

方法的重写和super的示例:

//定义一个手机类，里面有一个拨打的方法
class Phone {
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
}

//继承手机类
class NewPhone extends Phone {
	public void call(String name) {
		//重写call方法并且使用supper调用父类方法
		super.call(name);
		System.out.println("可以听天气预报了");
	}
}

class ExtendsDemo9 {
	public static void main(String[] args) {
		NewPhone np = new NewPhone();
		np.call("林青霞");
	}
}

方法重写的注意事项

A:父类中私有方法不能被重写

因为父类私有方法子类根本就无法继承

B:子类重写父类方法时，访问权限不能更低

最好就一致

C:父类静态方法，子类也必须通过静态方法进行重写

其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解

子类重写父类方法的时候，最好声明一模一样。

第二讲多态 1. 多态概述：同一个对象(事物)，在不同时刻体现出来的不同状态。

比如说猫是猫。猫也是动物 2.多态的前提：

A:要有继承关系。

B:要有方法重写。

其实没有也是可以的，但是如果没有这个就没有意义。

动物 d = new 猫();

d.show();

动物 d = new 狗();

d.show();

C:要有父类引用指向子类对象。

父 f = new 子(); 3.多态中的成员访问特点：

A:成员变量

编译看左边，运行看左边。

B:构造方法

创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。

C:成员方法

编译看左边，运行看右边。

D:静态方法

编译看左边，运行看左边。

(静态和类相关，算不上重写，所以，访问还是左边的)

由于成员方法存在方法重写，所以它运行看右边。对于运行和编译的特点，有个示例：

class Fu {
	public int num = 100;

	public void show() {
		System.out.println("show Fu");
	}
	
	public static void function() {
		System.out.println("function Fu");
	}
}

class Zi extends Fu {
	public int num = 1000;
	public int num2 = 200;

	public void show() {
		System.out.println("show Zi");
	}
	
	public void method() {
		System.out.println("method zi");
	}
	
	public static void function() {
		System.out.println("function Zi");
	}
}

class DuoTaiDemo {
	public static void main(String[] args) {
		//要有父类引用指向子类对象。
		//父 f =  new 子();
		Fu f = new Zi();
		System.out.println(f.num);
		//找不到符号
		//System.out.println(f.num2);
		
		f.show();
		//找不到符号
		//f.method();
		f.function();
	}
}

黑马程序员-------面向对象基础知识2

可以看出，最后的结果是符合多态成员访问特点的第三讲内部类 1. 内部类概述:

把类定义在其他类的内部，这个类就被称为内部类。

举例：在类A中定义了一个类B，类B就是内部类。

内部的访问特点：

A:内部类可以直接访问外部类的成员，包括私有。

B:外部类要访问内部类的成员，必须创建对象。简单示例：

class Outer {
	private int num = 10;
	
	class Inner {
		public void show() {
			System.out.println(num);
		}
	}
	
	public void method() {
		//找不到符号
		//show();
	
		Inner i = new Inner();
		i.show();
	}
}

2.内部类位置

成员位置:在成员位置定义的类，被称为成员内部类。

局部位置:在局部位置定义的类，被称为局部内部类。

示例：

class Outer {

//成员位置

class Inner1 {

}

public void method() {

//局部位置

class Inner2 {

}

3.成员内部类:

如何直接访问内部类的成员。

外部类名.内部类名对象名 = 外部类对象.内部类对象; 示例： Outer.Inner oi = new Outer().new Inner();

成员内部类的修饰符：

private 为了保证数据的安全性

static 为了方便访问数据

注意：静态内部类访问的外部类数据必须用静态修饰。

4.局部内部类

A:可以直接访问外部类的成员

B:在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能 class Outer {

private int num = 10;

public void method() {

class Inner {

public void show() {

}

5.匿名内部类

就是内部类的简化写法。

前提：存在一个类或者接口

这里的类可以是具体类也可以是抽象类。

格式：

new 类名或者接口名(){

重写方法;

}

匿名内部类是一个继承了该类或者实现了该接口的子类匿名对象。好处：简化书写

弊端：1、不能直接调用自己的特有方法、

2、不能做强转动作。

3、如果继承的父类或接口中有很多方法时，使用匿名内部类阅读性会非常差，且调用会很麻烦。所以匿名内部类中定义的方法有一般不超过3个。

interface Inter {
	public abstract void show();
	public abstract void show2();
}

class Outer {
	public void method() {
		//一个方法的时候
		/*
		new Inter() {
			public void show() {
				System.out.println("show");
			}
		}.show();
		*/
		
		//二个方法的时候
		/*
		new Inter() {
			public void show() {
				System.out.println("show");
			}
			
			public void show2() {
				System.out.println("show2");
			}
		}.show();
		
		new Inter() {
			public void show() {
				System.out.println("show");
			}
			
			public void show2() {
				System.out.println("show2");
			}
		}.show2();
		*/
		
		//如果我是很多个方法，就很麻烦了
		//那么，我们有没有改进的方案呢?
		Inter i = new Inter() { //多态
			public void show() {
				System.out.println("show");
			}
			
			public void show2() {
				System.out.println("show2");
			}
		};
		
		i.show();
		i.show2();
	}
}

class InnerClassDemo6 {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}

第四讲包 1.包的概述

在java中，管叫包，相当于文件夹。包里通常存放的是类文件，

因为我们在编写程序的时候，难免会有类名相同的情况，就如我们人名一样。

为了对类进行分类管理，java就有了包的出现，在不同包中可以有相同的类名，

调用的时候连同包名一起就行。包也是一种封装形式。在包中可以有很多类文件，但是只提供一个类文件，供外界使用。

2. 包的定义 package 包名;

多级包用.分开即可注意事项:

A:package语句必须是程序的第一条可执行的代码

B:package语句在一个java文件中只能有一个

C:如果没有package，默认表示无包名

3.包之间的访问 a、要访问其他包中的类，需要定义类的全称：包名.类名。

b、包如果不在当前路径，需要使用classpath设定环境变量，为JVM指明路径。

c、被访问的包中的类权限必须是public的。

d、类中的成员权限：public或者protected。protected是为其他包中的子类提供的一种权限。

类公有后，被访问的成员也要公有才可以被访问。不同包中的子类可以直接访问父类中被protected权限修饰的成员。同一个包中，protected只作用为覆盖。

四种权限权限修饰符：

本类同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)

private Y N N N

默认 Y Y N N

protected Y Y Y N

public Y Y Y Y

4.包的导入格式：import 包名;

这种方式导入是到类的名称。

注意：我们用谁就导谁。

下面是一个关于导入包的示例一个demo小程序

package com.abcd;

public class Demo {
	public int sum(int a,int b) {
		return a + b;
	}
}

导入这个包并运用

package cn.itcast;

import com.abcd.Demo;

class Test {
	public static void main(String[] args) {
		Demo d = new Demo();
		System.out.println(d.sum(10,20));
	}
}

黑马程序员-------面向对象基础知识2

继续阅读

黑马程序员-String类和正则表达式

IFIX数据绑定转发原理

黑马程序员 Java初级<三>---> 程序流程控制与函数

一维数组，二维数组数组二维数组

JAVA学习——static关键字

分布式架构核心概念

Java学习总结之IO

Java学习总结--002键盘录入+流程语句+方法重载

Java学习总结--032SimpleDateFormat类实现日期和字符串的相互转换

MyBatis开发Dao层的两种方式（Mapper动态代理方式）

Java学习总结（六） —— 内部类一、内部类二、匿名内部类

内部类学习总结

do...while循环语句

throws与throw关键字详解

计算器功能实现