luogg_java学习_06_面向对象特性之封装和继承

这篇博客总结了1天,希望自己以后返回来看的时候理解更深刻,也希望可以起到帮助初学者的作用.
**转载请注明 出自 : luogg的博客园 ** ,
因为前不久偶然发现某网站直接复制粘贴我的博客,交谈之后他们修改了出处.

封装

一, 封装的概念

  1. 类可以看成一个封装体,将对象的属性和方法封装到类中.
  2. 把不希望外界看到或调用的属性或方法用private 关键字修饰, 然后在属性或方法的类中创建一个可以间接让外部使用属性或方法的通道.

二, 封装的实现

  • 通常将类中的成员变量私有化 (private) ，那么再通过这个类创建对象后就不能访问该类的变量 , 通过对外提供方法（setXxx,getXxx）,可对该变量(xxx)进行访问。
  • boolean 类型的变量没有 getXX,只有 isXX;
  • IDE中可以右键source 快捷的设置变量的seter和geter方法
  • get方法有返回值和return
  • set方法无返回值,担有形参
public int getAge() {
		System.out.println(name + "的年龄是 : " + age);
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

三, this关键字的作用

1. 表示本类中的(age)属性

this.age = age;

2. this([实参]); 表示在构造方法中调用构造方法. 应写在构造方法中的第一行, 不然会报错,构造方法中只能使用一次.

//	设置构造函数
		public Person() {
			System.out.println("这是有0个参数的构造方法");
		}
		public Person(String name) {
			this.name = name;
			System.out.println("这是有一个参数的构造方法");
		}
		public Person(String name , int age , char sex) {
			this("张三");
			System.out.println("这是有3个参数的构造方法");
		}
		
		=================
	
		public class PersonTest {
			public static void main(String[] args) {
				Person p1 = new Person("",10,'男');
			}
		}

执行之后:
这里写图片描述

3. this表示当前对象

	//	this 的第三种用法:表示当前对象
	====ThisPerson类=====
	public void run() {
		System.out.println("runing....");
		System.out.println(this);
	}
	======主类======
	ThisPerson p3 = new ThisPerson();
		p3.run();
		System.out.println(p3 + "\n");

执行结果:
这里写图片描述

四, 构造方法 :

创建类的对象并初始化,具体方法day04写了.

五, 类的设计分析

根据要求写出类所包含的字段；
所有的字段(属性)都必须私有化；
封装之后的字段可通过 setter 和 getter 设值和取得；
按需求可添加若干构造方法；
根据需求可添加相应的方法；
类中的所有方法都不要直接处理(输出打印)，而是交给调用者去处理。

六, static(静态) 关键字的使用

  • static修饰的属性或方法称为静态属性或者静态方法.
  • 一旦属性或方法被static修饰,可以直接通过类名.方法()或者类名.属性调用.
  • 被static修饰的方法, 程序运行后不管用不用得到都会进入内存中的静态区.
  • 随着类的加载而加载, 优先于对象存在 , 被所有对象所共享 , 可以直接被类名调用
  • 静态方法只能访问静态成员, 非静态方法可以访问静态方法.
  • 静态方法中不可以使用this,super关键字
=====StaticPerson类中定义静态属性========
public class StaticPerson {
	static String name;
	int age;
	char sex;
}

======主类====

public class TestStatic {
	public static void main(String[] args) {
		StaticPerson.name = "张三";
		System.out.println(StaticPerson.name);
		fun();
	}
	public static void fun() {
		System.out.println("run..");
		StaticPerson.name = "张三";
		System.out.println(StaticPerson.name);
	}
}

输出结果:这里写图片描述

====================================

继承

一, 继承概念及优点

子类扩展其父类的功能，达到类的重用，降低开发成本

优点：

1、提高了代码的复用性。
2、让类与类之间产生关系，有了这个继承关系才有了多态的特性。
3、Java 语言中只支持单继承（有别于 C 语言）。因为多继承容易带来安全隐患（父类多了， 功能相同的话，就会出现调用不确定性，覆写一个方法，到底覆写的谁的？），但是java支持多层继承，即祖孙关系，祖先关系

二， 继承的实现

父类：超类，基类
子类：派生类

格式：

访问修饰符 class 子类名 extends 父类名(){}

三, 继承的限制

  • 在java中只允许单继承
  • 子类不能继承父类的私有成员
  • 父类的构造方法也不可以继承

四, 子类对象实例化过程

1、先实例化父类构造方法为父类中的属性初始化
2、再实例化子类构造方法
实质：在子类的构造方法中隐藏了一个 super()方法，调用父类中的构造方法

=======父类======
public class Person1 {
	int age = fun();
	
	public Person1() {
		System.out.println("父类的构造方法被调用了");
	}
	public int fun() {
		System.out.println("父类属性方法被执行了");
		return 0;
	}
}

============子类===============
public class Person1Test extends Person1 {
	int age = info();	
		
	public Person1Test() {
		//super();隐藏了,它默认先调用父类的构造方法
		System.out.println("子类的构造方法被执行");
	}
	
	public int info() {
		System.out.println("子类的属性被执行");
		return 0;
	}
}

=============主函数============
	public static void main(String[] args) {
		Person1Test p1 = new Person1Test();
	}

===输出结果=
这里写图片描述

五, super关键字的使用

1, 调用父类中的构造方法 super([参数]);
2, 调用父类中的普通方法 super.普通方法();
3, 调用父类中的属性 super.属性;

======父类Person类======

	public Person() {
		System.out.println("父类无参构造方法被调用");
	}
	public Person(String name) {
		System.out.println("父类一个参数的构造方法被调用");
	}
	
	public String fun() {
		System.out.println("父类中的属性被初始化了");
		return name;

=========子类Student类========
public void run(int id) {
		super.fun();
		System.out.println("子类的属性被初始化");
	}
	
	public Student() {
		super("张三");
		System.out.println("子类构造方法被调用");
	}
	
===========主函数===========
public static void main(String[] args) {
		Student s1 = new Student();
		s1.id = 10;
		System.out.println(s1.id);
	}

输出结果:
这里写图片描述

六,包及访问权限

包的使用：import 包名.子包名.* 或 import 包名.子包名.类
访问修饰符:
这里写图片描述

七, 方法的重写

当父类的某个方法不适合于子类本身的特征行为时就当覆写父类中应当改变的方法。

方法覆写时应遵循的原则(一同两小一大)：

(一同):方法签名必须相同;
(两小):
子类方法的返回值类型比父类方法的返回值类型更小或相等
子类方法声明抛出的异常应比父类方法申明抛出的异常更小或相等;
(一大):子类方法的访问权限应比父类方法更大或相等;

实现规则：

（1）在子类中定义了与父类中同名的方法；
（2）方法名称、参数类型、返回值类型、全部相同
（3）并且子类中的的同名方法的访问权限不用比父类中的同名方法更严格         private访问修饰符 权限最低,最严谨

====父类====
public class Person {
	public void run() {
		System.out.println("父类正在跑步...");
	}
}
====子类===
public class Student {
	public void run() {
		System.out.println("子类正在跑步!!!");
	}
}
====主函数====
public static void main(String[] args) {
		Student s = new Student();
		s.run();
	}

输出结果 : 子类正在跑步!!!

八, final 关键字的使用

作用：

（1）声明类：声明类的时候表示该类不能再被继承
（2）声明方法：声明方法的时候表示该方法不能在被子类被覆写
（3）声明变量：声明变量的时候表示该变量变成常量（常量：一旦赋值之后，里面的值不能再变）

九, 难点

重写和重载的区别

这里写图片描述

super关键字和this关键字的区别

这里写图片描述

十,语句块

普通块

写在方法里面的 (方法, if语句 switch等等)
{}

构造块

写在类里边 {}

静态块

写在类里边 static{}

执行的先后顺序 :

静态快先被执行
构造块之后被执行
构造方法最后被执行
静态块只在创建对象时候执行一次,不管创建多少个对象,只执行一次

posted @ 2016-08-17 20:49  洛GG  阅读(234)  评论(0)  编辑  收藏  举报