——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
一、面向对象概述
1.类实质上就是封装对象属性和行为的载体，类是同一类事物的统称。
2.对象是类抽象出来的一个实例（万物皆对象），该类是事物实实在在的个体。
3.面向对象的三大特点：①封装；②继承；③多态。
（1）面向对象的特点：
1.是一种更符合我们思想习惯的思想
2.可以将复杂的事情简单化
3.将我们从执行者变成了指挥者，角色发生了转换
我们在解决问题的时候，就是找对象，如果没有对象，就创造对象去解决方法。
我们描述小汽车的时候，有轮胎数、颜色，这些是事物的属性；还有汽车的运行，这些是事物的行为。我们在定义类的时候，就是定义类中的成员，其中成员变量对应着事物的属相，成员方法对应着事物的行为。
如我们可以定义一个Car类就可以这样：
class Car{
int num;//车的轮胎数
String color;//车的颜色
void run(){
System.out.println(num+"..."+color);
}
}（2）成员变量和局部变量的区别
主要是四个方面的区别：
A:在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
B:在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
C:生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
下面举个例子：
// 基本类
class Variable {
int num = 40;
public void show(){
// 错误的: 可能尚未初始化变量num2
// int num2 ;
/*
int num2 = 20;
System.out.println(num2);
*/
// int num = 30 ;
System.out.println(num);
}
}
// 测试类
class VariableDemo {
public static void main(String[] args){
// 创建对象
Variable v = new Variable();
// System.out.println(v.num);
// 调用show方法
v.show();
}
}
程序执行的结果是：
二、封装
封装的引入就是为了隐藏实现细节，保证一些数据的安全。仅对外提供公共的方法对其访问。
（1）封装的好处
①隐藏实现细节，提供公共的访问方式
②提高了代码的复用性
③提高安全性。
（2）具体的实现
// 学生类
class Student {
// 成员变量
String name ;// 姓名
private int age ;// 年龄
// 定义一个方法来给age赋值
public void setAge(int a){ // -18
if(a < 0 || a > 120){
System.out.println("你输入的年龄不正确");
}else{
age = a ;
}
}
// 成员方法
public void show(){
System.out.println(name);
System.out.println(age);
}
}
// 测试类
class StudentDemo {
public static void main(String[] args){
// 创建学生对象
Student s = new Student();
// 给成员变量赋值
s.name = "小红";
// s.age = 18 ;
s.setAge(18);
// 调用show方法输出所有的成员变量
s.show();
System.out.println("--------------------");
// 创建学生对象
Student s1 = new Student();
// 给成员变量赋值
s1.name = "小花";
// s1.age = -18;
s1.setAge(-18);
// 调用show方法输出所有的成员变量
s1.show();
}
}程序执行的结果是：
三、this关键字
我们之前说过: 起名字要做到”见名知意”，我们在方法中使用参数赋值的时候就可以使用this关键字来代表本类对象的引用。也就是说谁调用方法,这个方法中的this代表的就是谁。
下面是具体的代码实现：
// 定义一个学生类
class Student {
// 成员变量
private String name ; // 姓名
private int age ; // 年龄
// 提供对应的get和set方法
public String getName(){
// return name ; // 存在一个隐含的this
return this.name ;
}
public void setName(String name){
// 我们变量的访问遵循一个"就近原则"
// 我们需要的是将传递进来的name赋值给成员变量的name
// name = name ;
// 我们要访问成员变量需要使用对象对其访问,那么谁又可以代表当前类的一个对象呢?
// 这时候java就给我们提供了一个关键字: this
this.name = name ;
}
public int getAge(){
return age ;
}
public void setAge(int age){
this.age = age ;
}
}
// 测试类
class StudentDemo {
public static void main(String[] args){
// 创建学生对象
Student s = new Student();
// 给成员变量赋值
s.setName("小菲菲");
s.setAge(13);
// 输出所有的成员变量
System.out.println(s.getName() + "---" + s.getAge());
// 创建学生对象
Student s1 = new Student();
// 给成员变量赋值
s1.setName("大菲菲");
s1.setAge(18);
// 输出所有的成员变量
System.out.println(s1.getName() + "---" + s1.getAge());
}
}程序执行的结果是：
四、构造方法
构造方法就是创建对象,给对象中的成员进行初始化用的。
※构造方法的格式特点
a:方法名与类名相同
b:没有返回值类型，连void都没有
c:没有具体的返回值
下面举个例子可以看看：
// 手机类
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());
}
}程序执行的结果是：
看过上面的例子后，我们还需要注意两个事项：
1.如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
2.如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
五、static关键字
这里先讲讲static关键字的特点
1.随着类的加载而加载
2.优先于对象存在
3.被类的所有对象共享。举例：咱们班级的学生应该共用同一个班级编号。其实这个特点也是在告诉我们什么时候使用静态?如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
4.可以通过类名调用，其实它本身也可以通过对象名调用。推荐使用类名调用。静态修饰的内容一般我们称其为：与类相关的，类成员
程序：
// 人类
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 = "美国";
p.show();
p2.show();
}
}执行的结果是：
六、继承
继承使用extends关键字，它的好处是：
1.提高了代码的复用性；
2.让类与类之间产生了关系，给第三个特征多态提供了前提；
3.提高了代码的维护性；
（1）引出
继承其它类的类叫”子类”，被继承的类叫”父类”、”超类”、”基类”，当子类继承了父类后，就自动拥有了父类中允许被继承的成员；大家可以近似的认为：子类就是拥有了父类中的可以被继承的成员。
如下程序所示：
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();
}
}结果是：
在java中只支持单继承，不支持多继承的，但可以支持多层继承。
（2）继承的注意事项
1.子类不能继承父类中私有成员：
2.构造方法是不能被继承的；
3.当实例化一个子类对象时，会调用父类的构造方法，实例化一个父类对象；这个父类对象，是存储在子类对象空间内的。
4.不要为了部分功能而去继承：
5.当类和类之间是：是一个(is a)的关系时，使用继承，学员是传智播客的一员，教师是传智播客的一员，所以，Student可以继承自Person，Teacher也可以继承自Person
代码：
class A
{
String name;
private int age;//此成员不会被子类继承
private void show(){//此方法不会被子类继承
System.out.println("private的show()");
}
void show2(){
System.out.println("非私有的show2()");
}
A(){
System.out.println("A的构造方法");
}
}
class B extends A
{
B(){
System.out.println("B的构造方法");
}
}
class Demo
{
public static void main(String[] args)
{
B b = new B();
// System.out.println(b.name);//OK的，name可以被继承
// System.out.println(b.age);//NO的，编译错误，age私有的，不能被继承
// b.show();///NO的，编译错误，show私有的，不能被继承
// b.show2();//OK的，show2可以被继承
B b2 = new B();
}
}运行的结果是：
（3）继承中成员变量的关系
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();
}
}
结果是：
