黑马程序员----构造方法及继承

                                      ------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

 第一讲 面向对象构造方法

一,构造方法特点:
A: 方法名与类名相同
B: 没有返回值类型,连void也没有
C: 没有返回值
   构造方法的作用:
是给成员变量进行初始化
二,构造方法格式:  public 类名(){} 这是一个无参的构造方法
注意:如果我们没有给出构造方法,系统会给我们提供一个无参的构造方法,
而成员变量,系统会给其赋与默认值,基本数据类型 int为 0 ,引用数据类型为null
而如果我们定义了一个带参的构造方法,也是有默认值的,它会被你定义的成员覆盖
二,创建对象并赋值:
两种方式,看下面代码:

class Phone {

	// 成员变量
	private String brand ;		// 品牌
	private String color ;		// 颜色
	private int    price ;		// 价格

	// 构造方法
	public Phone(){}

	public Phone(String brand , String color , int price){
		this.brand = brand ;
		this.color = color ;
		this.price = price ;
	}

	// 提供get和set方法
	public String getBrand(){
		return brand ;
	}

	public void setBrand(String brand){
		this.brand = brand ;
	}

	public String getColor(){
		return color ;
	}

	public void setColor(String color){
		this.color = color ;
	}

	public int getPrice(){
		return price ;
	}

	public void setPrice(int price){
		this.price = price ;
	}

}

// 测试类
class PhoneDemo {

	public static void main(String[] args){
		
		// 创建手机对象方式1
		Phone p = new Phone();

		// 给成员变量赋值
		p.setBrand("苹果");
		p.setColor("白色");
		p.setPrice(100);

		// 获取成员变量
		System.out.println(p.getBrand() + "---" + p.getColor() + "---" + p.getPrice());

		System.out.println("----------------------------------");

		// 创建手机对象方式2
		Phone p2 = new Phone("三星" , "黑色" , 50);

		// 获取成员变量
		System.out.println(p2.getBrand() + "---" + p2.getColor() + "---" + p2.getPrice());
	}
}

第二讲 static关键字

一,static的特点:
A: 随着类的加载而加载
B: 优先于对象存在
C: 被所有对象共享
D: 可以通过类名来调用
也可以通过对象名调用
建议使用类名对其调用
static是可以修饰成员变量各成员方法的,被static修饰的成员变量能被整个类访问.
二,static的注意事项:
静态方法中是没有this关键字的,静态是随着类的加载而加载,this是随着对象存在而在
三,静态方法调用总结:
静态只能访问静态,非静态则可以访问静态跟非静态
看下面代码

class Person {

	// 成员变量
	String name ;			// 姓名
	// String country ;		// 国籍

	static String country ;
	
	public void show(){
		System.out.println(name + "---" + country);
	}
}

// 测试类
class PersonDemo {

	public static void main(String[] args){
		
		// 创建一个对象
		Person p = new Person();

		// 给成员变量赋值
		p.name = "凤姐";
		p.country = "中国";

		// 调用show方法
		p.show();

		// 创建第二个对象
		Person p2 = new Person();

		//给成员变量赋值
		p2.name = "刘亦菲";
		// p2.country = "中国";

		// 调用show方法
		p2.show();

		System.out.println("-----------------------");

		p.country = "美国";//从这里可以看出,被static修饰的country被共享了
		p.show();
		p2.show();

	}

}

第三讲 main方法的解析及静态变量与成员变量的区别

一,main方法的格式解释:
   public static void main(String[] args){}
   public(公共的): 由于main方法是被JVM调用的,所以要求访问权限最大
   static(静态的): 由于main方法是被JVM调用的,所有可以不用创建对象,直接使用类名调用
   void(空): 由于main方法是被JVM调用的,所以不需要返回值
   main(主要的): main是一个特殊的单词,可以被JVM识别
   String[] args: 用来接收键盘录入数据
二,静态变量与成员变量的区别
A:所属不同
静态变量属于类，所以也称为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
B:内存中位置不同
静态变量存储于方法区的静态区(共享区)
成员变量存储于堆内存
C:内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
D:调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
第四讲 继承

一,继承的定义
  当我们定义学员类：
学员：
学员编号,姓名,年龄,性别
教师：
教师编号,姓名,年龄, 性别
我们发现：
  1.学员和教师都属于咱们学校的"一个人员"；
  2.学员和教师中都定义一些"相同的成员"：  姓名,年龄,性别      
这时，我们可以将这些具有"相同类型"的成员，进一步抽取到一个新类中；
将这个新类作为"父类"，我们的"学员"和"教师"类可以"继承自"这个"父类"，达到
一个"代码重用的目的"
1.语法：子类继承时使用关键字：extends(重点)
2.继承其它类的类叫"子类"，被继承的类叫"父类"、"超类"、"基类"
3.当子类继承了父类后，就自动拥有了父类中允许被继承的成员；大家可以近似的认为：子类就是拥有了父类中的可以被继承的成员
4.作用：代码重用

class Person
{
	String name;//姓名
	int age;//年龄
	char sex;//性别

	void show(){
		System.out.println("我是黑马的一员，我骄傲！！");
	}
}
//Person的"子类"
class Student extends Person
{
	String stuNo;//学员编号
	int score;//分数；
}
//Person的"子类"
class Teacher extends Person
{
	String teaNo;//教师编号
}
//当再需要"员工类"时，也需要这些成员时，可以直接继承自"Person"
class Employee extends Person
{
	//自动拥有了Person的三个属性和一个方法；
}
class Demo 
{
	public static void main(String[] args) 
	{
		Student stu = new Student();
		System.out.println(stu.name);//继承的
		System.out.println(stu.age);//继承的
		System.out.println(stu.sex);//继承的
		System.out.println(stu.stuNo);//自己的
		stu.show();

		Teacher tea = new Teacher();
		System.out.println(tea.name);//继承的
		System.out.println(tea.age);//继承的
		System.out.println(tea.sex);//继承的
		System.out.println(tea.teaNo);//自己的
		tea.show();
	}
}

二,继承的特点
    1.Java中只允许单继承：一个类同时只能继承自一个类；
    2.Java中允许多级继承：
代码如下:

class A{
}
class B extends A{
}
class C extends B{
}
//错误的，Java中不能多继承
class D extends A,B{
}

三,继承的注意事项
    1.子类不能继承父类中私有成员：
    2.构造方法是不能被继承的；
    3.当实例化一个子类对象时，会调用父类的构造方法，实例化一个父类对象；这个父类对象，是存储在子类对象空间内的。
    4.不要为了部分功能而去继承：
    5.当类和类之间是：是一个(is a)的关系时，使用继承：学员是黑马的一员,教师是黑马的一员,所以，Student与Teacher都可以继承自Person

四,继承中成员变量的关系
   1.首先在子类局部范围找
   2.然后在子类成员范围找
   3.最后在父类成员范围找(肯定不能访问到父类局部范围)
   4.如果还是没有就报错。(不考虑父亲的父亲…)

 class A
{
	int num = 10;
}
class B extends A
{
	int a = 20;
	int num = 30;//子类成员变量，覆盖父类的成员变量；

	void show(){
		//就近原则；
		int num = 40;//局部变量，覆盖成员变量
		System.out.println("num = " + num);//40 注意：先找局部，再找成员，再找父类；
		System.out.println("this.num = " + this.num);//30，注意：如果本类没有，会向父类去找；
		System.out.println("super.num = " + super.num);//访问父类的num : 10
	}
}
class Demo 
{
	public static void main(String[] args) 
	{
		B b = new B();
		//在外部访问B中的成员变量
		/*
		System.out.println(b.num);
		System.out.println(b.a);
		*/
		b.show();
	}
}

五,this和super关键字
  this：1.永远指向本类对象的空间，它由JVM自动赋值，
2.它可以调用本类对象的成员属性、成员方法、构造方法
3.可以在本类的一个构造方法中调用另一个构造方法；
   注意：当在一个构造方法中使用this调用另一个构造方法时，this语句必须写在这个构造方法的第一句有效语句。
  super: 
1.一般用于"子类中"；
2.它永远指向本类的父类，它由JVM自动赋值；
3.它可以调用父类的成员变量、成员方法、构造方法；
4.当我们实例化一个子类对象时，JVM会先实例化此类的父类，并调用父类的"无参的构造方法";
注意：
1.当父类没有提供"无参构造方法"时而提供了其它带参的构造方法，那么JVM就不会为父类添加一个无参的构造方法，
         当我们实例化子类对象时，JVM会自动去实例化它的父类，如果父类中没有无参构造方法，JVM就不知道怎么调用带参
  的构造方法，所以我们在子类中，必须显示的使用super() 去调用父类中带参构造方法；
2.当在子类的构造方法中，使用super去调用父类的构造方法时，super语句必须方法第一句有效语句。
注意：在一个构造方法中，不能同时this()和super()。因为都需要在第一句话；

六,继承中成员方法的关系
1.子类中可以定义跟父类一模一样的方法；
 这时子类的方法会覆盖父类同名的方法，这种方式叫：方法重写；
2.一模一样的方法：
方法定义的语法：
访问修饰符   返回值类型     方法名 (形参列表)
        在子类中定义如下方法：
返回值类型 方法名 相同  ，形参列表不相同；编译可以通过，它类似于方法的重载。
返回值类型不同，方法名和形参列表都相同；编译错误。必须指定相同的返回值类型；
指：子类中的方法要与父类的方法具有相同的：返回值类型、方法名、形参列表。
        子类方法的"访问修饰符"可以和父类相同，也可以更宽；
private,(默认),protected,public:从窄到宽

七,方法重写
    1.有些时候，父类中定义了一些方法的实现；
    2.子类需要保留方法的名称，但希望做一些子类特有的事情，这个时候就可以重写父类中的方法
   注意:1.子类不能重写父类中的私有的方法；

 class A
{
	private void show(){
		System.out.println("A --> show()");
	}

	static void method(){
		System.out.println("A --> static method()");
	}
}
class B extends A
{
	//子类中可以定义show()方法，但绝对不是覆盖父类中private的show()方法，各自是各自的，这不是重写；
	public void show(){
		System.out.println("B --> show()");
	}

	static void method(){
		System.out.println("B --> static method()");
	}
}
class Demo 
{
	public static void main(String[] args) 
	{
		B b = new B();
		b.show();

		B.method();//没有重写时，访问的是父类的；当子类重写父类方法后，访问的是子类的。

	}
}

八,final关键字,super关键字,
    final关键字
     1.它表示最终的。
     2.它可以修饰类、成员变量、局部变量、成员方法；
     3.修饰类：此类代表"最终类"，不能被继承；
 修饰成员变量、局部变量：代表这个变量拥有最终的值，其值只能被赋值一次，一旦赋值后，其值不能更改；这叫：常量；
 修饰成员方法：表示"最终方法"，不能被重写；
以后我们在Java类库中，会看到类库中的一些类，会使用final关键字，我们要根据定义，去决定是否去继承，重写等操作；
        final在定义全局常量时，会经常用到：它经常会和static关键字一起使用
   super关键字
      1.经常用于子类中；
      2.它用来访问父类中的成员：成员变量，成员方法，构造方法
      3.一般时候，我们不需要显示的使用。
      4.有些情况，在子类中，要访问父类的成员时，必须要显示的使用super:
 1).当子类的成员，覆盖父类成员时，并且需要访问父类成员时；
 2).父类没有提供"无参的构造方法"