this
赵本山问奥尼尔：“我的爸爸的爸爸是谁？”
奥尼尔：“不知道”
赵本山：“你傻啊，是我爷爷”
奥尼尔回去问科比：“我的爸爸的爸爸是谁？”
科比：“不知道”
奥尼尔：”你傻啊，是赵本山的爷爷“
就像这个笑话一样，不同的人，用this时，指向的对象也是变的。
普通方法中，this总是指向调用该方法的对象
//this在成员方法中的用处
//this就是指代当前对象，是一个隐式参数 public class thissss
{
public static void main(String []args)
{
Student s1 = new Student();
s1.name = "小白";
s1.age = 17;
s1.study();
System.out.println(s1.name);
Student s2 = new Student();
s2.name = "小徐";
s2.age = 18;
s2.study();
}
} class Student
{
int age;
String name;
public void study()
//在创建成员方法(函数)的时候会自动传一个this参数,指向该对象的地址,但是是隐藏的
{
this.name = "小黑";
//s1.name = "小黑";
//这条语句是错误的,因为对象要在类创建完成之后才有
//但是使用this.name就可以给类进行赋值
//因为this指向创建的对象的地址,所以this.name就会找到该对象中study()方法的地址
//对这个地址进行操纵,总而更改当前对象的值
System.out.println(name+"在学习");
}
}
图解：
构造方法中，this总是指向正要初始化的对象
//this在构造方法中的用处
//用来指向正在初始化的对象
public class thissss2
{
public static void main(String []args)
{
Student s1 = new Student(17);
System.out.println(s1.age);
Student s2 = new Student(18); }
} class Student
{
int age;
String name;
public Student(int age)
{
//age = age
//直接写age指代的是public void Student(String name,int age)传进来的name,就近原则
//this.age指代的是当前正在初始化的对象中的String age;
this.age = age;
}
} 输出结果：
age = age时，输出的是0，并非是正常的结果
this.age = age时,输出的是正常的结果17
原因也是因为会默认传一个this参数，用来指向当前使用这条命令的对象的地址，这样就可以正确的初始化当前对象中成员变量的值了
注意：this不能用于static方法（学了static方法就知道为什么了）
变量的种类
实例变量、类变量、常量都是属于成员变量的，成员变量又被称为全局变量
public class A{
String id; //实例变量
private String Tel; //实例变量
private int size; //实例变量
private static String depart; //类变量
final String design="样式"; //常量
}
/*其中实例变量、类变量、常量都是属于成员变量的，成员变量又被称为全局变量，
成员变量的范围比实例变量更宽泛 */
方法（函数）的种类
实例方法（instance method）：或叫成员方法（member method）。供实例用的方法，必须要先有实例，才能通过此实例调用实例方法。
静态变量 / 类变量
提问：有一群小孩在玩堆雪人，不时有新的小孩加入，请问如何知道现在有多少人在玩呢？请使用面向对象的思想，编程解决。
public class Demo1
{
public static void main(String []args)
{
int total = 0;
Child ch1 = new child(3,"小徐");
ch1.joinGame();
total++; Child ch2 = new child(4,"小白");
ch2.joinGame();
total++;
//查看总人数的时候,只需要输入total的值就可以了
//但是要求是使用面向对象的方法,课时这个total并没有封装到对象中去
}
} //定义kid类
class Child
{
int age;
String name;
public Child(int age,String name)
{
this.age = age;
this.name = name;
}
public void joinGame()
{
System.out.println("有一个小孩加入了");
}
}
一般人的思维
从上面的例子中可以看到，要是有一个所有对象都能操作的变量就好了，而java中确实有这个变量，叫做静态变量（也叫类变量）
public class Demo1
{
public static void main(String []args)
{
Child ch1 = new Child(3,"小徐");
ch1.joinGame();
Child ch2 = new Child(4,"小白");
ch2.joinGame();
System.out.println("公有="+ch2.total);
//也可以直接用类访问静态变量
System.out.println("公有="+Child.total); }
} //定义kid类
class Child
{
int age;
String name;
//total是静态变量, 因此可以被任何一个对象访问
static int total = 0;
public Child(int age,String name)
{
this.age = age;
this.name = name;
}
public void joinGame()
{
total++; //在这里进行计数操作
System.out.println("有一个小孩加入了");
}
}
静态变量实现
什么是：静态变量（类变量）？
类变量是该类的所有对象的共享变量，任何一个该类的对象去访问它是，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。
静态变量的定义语法
访问修饰符 static 数据类型 变量名;
静态变量的访问方法
- 类名 . 静态变量名
- 对象名 . 静态变量名
加深静态方法的理解的小例子
public class Demo2
{
static int i=1;
static //静态区域块只会被执行一次
{
i++;
}
public Demo2()
{
i++;
} public static void main(String []args)
{
Demo2 t1 = new Demo2();
System.out.println(t1.i);
Demo2 t2 = new Demo2();
System.out.println(t2.i); }
}
猜猜看吧
原理：
public class Demo2
{
static int i=1;
static //静态区域块只会被执行一次
{
i++;
System.out.println("静态区域块");
}
public Demo2()
{
i++;
System.out.println("成员方法Demo2");
} public static void main(String []args)
{
Demo2 t1 = new Demo2();
System.out.println(t1.i);
Demo2 t2 = new Demo2();
System.out.println(t2.i); }
} 输出结果：
静态区域块
成员方法Demo2
3
成员方法Demo2
4
运行结果和原理
不创建对象static也会执行，原理将来会讲
public class Demo2
{
static int i=1;
static //静态区域块只会被执行一次
{
i++;
System.out.println("静态区域块");
}
public Demo2()
{
i++;
System.out.println("成员方法Demo2");
} public static void main(String []args)
{
}
} 输出结果：
D:\myJavaDemo\Day3>java Demo2
静态区域块
static
静态方法（类方法）
小例子：
public class Demo3
{
public static void main(String []args)
{
//创建一个学生
Stu stu1=new Stu(29,"aa",340);
Stu stu2 = new Stu(29,"aa",290);
System.out.println(stu2.getTotalFee());
//此时这个语法是有歧义的，感觉输出的是stu2的学费,但是输出的是所有学生的费用
}
} class Stu
{
int age;
String name;
int fee;
static int totalFee; public Stu(int age,String name,int fee)
{
this.age = age;
this.name = name;
totalFee+=fee;
}
public int getTotalFee()
{
return totalFee;
}
}
使用静态方法
java中有一个规则，静态变量原则用静态方法去访问和操作，约定俗成的。并且
- 静态方法中不能对非静态变量操作
- 但普通的成员方法可以操作静态变量，
- 静态变量都可以被操作，非静态方法不能被静态方法操作
public class Demo3
{
public static void main(String []args)
{
//创建一个学生
Stu stu1=new Stu(29,"aa",340);
Stu stu2 = new Stu(29,"aa",290);
//可以直接使用Stu类名来访问这个静态方法
System.out.println(Stu.getTotalFee()); }
} class Stu
{
int age;
String name;
int fee;
static int totalFee; public Stu(int age,String name,int fee)
{
this.age = age;
this.name = name;
totalFee+=fee;
}
public static int getTotalFee() //区别就是这条语句中多了一个static
{
return totalFee;
}
}
静态方法（函数）
什么时候使用静态方法？
如果有一个方法（函数）需要让所有的对象去共享的时候，就可以设计成为静态方法
静态方法的语法
访问修饰符 static 数据返回类型 方法名 ()
{
//语句;
} //注意静态方法中不能访问非静态变量,例如: 成员属性
使用方法
类名 . 静态方法名
对象名 . 静态方法名
类变量与实例变量的区别
静态变量(类变量)
int a;
String name; 实例变量
int static a;
String static name;
- 加上static称为静态变量或类变量 ,否则称为实例变量
- 类变量是与类相关的,公共的属性
- 实例变量是属于每个对象个体的属性
- 类变量可以通过 类名.类变量名 直接访问
静态方法（类方法）与实例方法的区别
静态方法(类方法)
public static int getTotalFee()
{
return totalFee;
} 实例方法
public int getTotalFee()
{
return totalFee;
}
- 类方法属于与类相关的，公共的方法
- 实例方法属于每个对象个体的方法
- 类方法可以通过 类名.类方法名 直接访问
四大特征——抽象、封装、继承、多态
一般是说java有三大特征，即封装、继承、多态。但有人也会把抽象算进去，如顺平
抽象
我们前面在定义一个类的时候，实际上就是把一类事物共有的属性和行为提取出来，形成一个物理模型（模板）。这种研究问题的方法称为抽象。
封装
封装就是把抽象出的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作（成员方法），才能对数据进行操作。
就像电视机一样，电路板被保护在内部，我们不能直接操作电路板，但是我们可以通过电视机上的按钮来的操作电路板，从而达到我们的目的。
访问控制修饰符
小例子：访问公有的成员变量
public class Demo4
{
public static void main(String []args)
{
Clerk clerk1 = new Clerk("小花",24,4567.6f);
System.out.println("名字是"+clerk1.name); }
} class Clerk
{
public String name; //public共有的
private int age; //private私有的
private float salary; public Clerk(String name,int age,float sal)
{
this.name = name;
this.age = age;
this.salary = sal;
}
} 输出结果：
名字是小花
公有
但访问私有的成员变量时，会报错
public class Demo4
{
public static void main(String []args)
{
Clerk clerk1 = new Clerk("小花",24,4567.6f);
System.out.println("名字是"+clerk1.name); }
} class Clerk
{
public String name; //public共有的
private int age; //private私有的
private float salary; public Clerk(String name,int age,float sal)
{
this.name = name;
this.age = age;
this.salary = sal;
}
} 报错信息：
Demo4.java:11: 错误: salary 在 Clerk 中是 private 访问控制
System.out.println("薪水是"+clerk1.salary);
^
1 个错误
私有
通过成员方法去控制和访问私有的属性
public class Demo4
{
public static void main(String []args)
{
Clerk clerk1 = new Clerk("小花",24,4567.6f);
System.out.println("薪水是"+clerk1.getSal()); }
} class Clerk
{
public String name; //public共有的
private int age; //private私有的
private float salary; public Clerk(String name,int age,float sal)
{
this.name = name;
this.age = age;
this.salary = sal;
}
//通过一个成员方法去控制和访问私有的属性
public float getSal()
{
return this.salary;
}
} 输出结果：
薪水是4567.6
通过公开的成员方法访问私有的属性
因为成员方法是公开的(public)，可以被使用。
就像我们使用电视机的时候不能通过操作电路板来换台、调节音量，但是我们可以通过操作电视机给我们提供的按钮来进行换台、调节音量的操作。电视机上的按钮就相当于成员方法。
- 厂商不让我们操作电路板，但是让我们操作按钮来间接操作电路板。
- 类不让我们访问私有的属性，但是让我们使用成员方法来访问私有属性。
Java提供四种访问控制修饰符号 控制 方法和变量 的访问权限
- 公开级别：用 pulic 修饰，对外公开
- 受保护级别：用 protected 修饰，对子类和同一个包中的类公开
- 默认级别：没有修饰符号，像同一个包的类公开
- 私有级别：用 private 修饰，只有类本身可以访问，不对外空开
包
从包开始，就不用记事本写程序了，改成用eclipse了
包的必要性？
有这样的一种情况，小白定义了一个类取名为Dog，赛拉也定义了一个类取名为Dog，然后他们俩就打起来了。我们使用myeclipse来模拟一下这种情况
小徐此时站了起来，说：“你们是傻吗？不知道包的作用！”
.代表再分一层
包的作用
- 区分相同名字的类
- 当类很多时，可以很好的管理
- 控制访问范围
打包命令
命令一般放在文件开头的地方
package com.shunping; //这条命令会自动生成,会自动把字节码放到com.shunping这个包中去
命名规范
//包名都是小写字母 , 用 . 隔开 , 比如
com.sina.shunping
常用的包
一个包下，包含很多的类，java中常用的包有：
- java.lang.* —— 这个包是自动引入的
- java.util.* —— 工具包
- java.net.* —— 网络开发包
- java.awt.* —— 窗口工具包
引入一个包
语法 : import 包;
import java.awt.* ;
我们引入一个包的主要目的是使用该包下的类
用包来控制访问范围
package com.xiaoqiang; public class Test
{
public static void main(String[] args)
{
Dog dog1 = new Dog(); //验证同包下的权限访问情况
System.out.println(dog1.a); } }
class Dog
{
public int a;
protected String name;
String color;
private float price; //验证同类下的权限访问情况
public void ab1()
{
System.out.println(this.a); }
}
在小强的Dog类中创建四种类型的访问控制修饰符
同类下的访问权限
同包下的访问权限——没有私有属性的price类
不同包下的访问权限用——用小明去访问小强中的Dog类
在小强的包下新建一个公有的Cat类，里面的内容和Dog相同，此时小明的访问情况为
package com.xiaoqiang; public class Cat
{
public int a;
protected String name;
String color;
private float price; public void ab1()
{
System.out.println(this.a); }
}
小强下的公有Cat类
权限访问情况为——只能访问公有类
如果我就是想访问其它的属性呢？
——这时就要用到封装的思想，用公有的成员方法去访问私有属性
package com.xiaoqiang; public class Cat
{
public int a;
protected String name;
String color;
private float price; //提供一个访问name的成员方法
public String getName()
{
return this.name; } }
在Cat类中提供一个访问name属性的成员方法
继承
为什么有继承？
小例子：我们定义小学生，中学生，大学生类
public class Demo
{
public static void main(String[] args)
{
} } //小学生类
class Pupil
{
//定义成员属性
private int age;
private String name;
private float fee; //交费
public void pay(float fee)
{
this.fee = fee;
}
} //中学生类
class MiddleStu
{
//定义成员属性
private int age;
private String name;
private float fee; //交费
public void pay(float fee)
{
this.fee = fee*0.8f;
}
} //大学生类
class ColStu
{
//定义成员属性
private int age;
private String name;
private float fee; //交费
public void pay(float fee)
{
this.fee = fee*0.1f;
}
}
类中成员属性重复现象
继承就可以很好的解决代码重复问题，让我们的编程更加靠近人类的思维。
当多个类中存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法。这样所有的子类不需要重新定义这些属性和方法，只需要通过extends语句来把父类的这些属性和方法继承过来就行。
public class Demo
{
public static void main(String[] args)
{
} }
//将学生的共有属性抽象出来, 做一个父类
class Student
{
public int age;
public String name;
public float fee; }
//小学生类
class Pupil extends Student{
//交费
public void pay(float fee)
{
this.fee = fee;
}
}
//中学生类
class MiddleStu extends Student{
//交费
public void pay(float fee)
{
this.fee = fee*0.8f;
}
}
//大学生类
class ColStu extends Student{
//交费
public void pay(float fee)
{
this.fee = fee*0.1f;
}
}
简单的继承例子
继承的语法
class 子类 extends 父类 ;
//这样子类就会自动拥有父类定义的某些属性和方法，有些东西是继承不了的
深入探讨——父类的哪些属性（变量）、方法被子类继承了
父类:
{
public int a;
protected int b;
int c;
private int d; public int getA(){}
protected int getB(){}
int getC(){}
private int getD(){}
}
————————————继承————————————
子类:
{
public int a;
protected int b;
int c; public int getA(){}
protected int getB(){}
int getC(){}
}
可以看出只有private修饰符的属性和方法不能被子类继承，所以不希望子类继承的属性和方法，只需要把那个属性和方法设置为private属性即可
继承的注意事项
- 子类最多只能继承一个父类（指直接继承），可以通过接口进行多重继承 ，之后会讲
- java所有类都是Object类的子类
- JDK6中有202个包，3777个类、接口、异常、枚举、注释和错误，掌握150个就是大神了
- 在做开发的时候，强烈建议大家多查jdk帮助文档，还是不会就google
import javax.swing.*;
public class Demo2 extends JFrame { public static void main(String[] args) {
Demo2 demo2 = new Demo2(); }
public Demo2()
{
this.setVisible(true);
this.setSize(200 , 200);
} }
案例：利用继承调用出一个windows框框来
如果不使用继承的话，需要调用一些复杂的命令
方法重载
在多态前要先了解一下方法重载（overload）和方法覆盖（override）
思考一下：编写一个名为Abc的类，能返回两个整数中较大的一个
- 若果是接收两个float型的数，返回较大数
- 如果是接收散了int型的数，返回最大数
public class Demo3 {
public static void main(String[] args) {
Abc test1 = new Abc();
System.out.println(test1.getMax(23, 78));
}
}
class Abc
{
public int getMax(int i,int j)
{
if(i>j)
{
return i;
}
else
{
return j;
}
}
}
返回两个整数中较大的数
public class Demo3 {
public static void main(String[] args) {
Abc test1 = new Abc();
Abc test2 = new Abc();
System.out.println(test1.getMax(23, 78));
System.out.println(test1.getMaxFloat(9.8f, 12.2f));
}
}
class Abc
{
public int getMax(int i,int j)
{
if(i>j)
{
return i;
}
else
{
return j;
}
}
public float getMaxFloat(float a,float b)
{
if(a>b)
{
return a;
}
else
{
return b;
}
}
}
返回两个小数中较大的一个
可以看出我们是又专门加一个，比较小数的成员方法，有没有方法用一个方法来进行比较呢？
这个时候有可以利用方法重载的特性——可以定义重名的两个成员方法，让编译器自己选择用哪个？
package com.xiaohui;
/*
* 作者:我聊啊
* 时间:2018.9.11
* 功能:了解方法重载
*/
public class Demo3 {
public static void main(String[] args) {
Abc test1 = new Abc();
Abc test2 = new Abc();
System.out.println(test1.getMax(23, 78));
System.out.println(test1.getMax(9.8f, 12.2f));
} } class Abc
{
public int getMax(int i,int j)
{
if(i>j)
{
return i;
}
else
{
return j;
}
}
public float getMax(float a,float b)
{
if(a>b)
{
return a;
}
else
{
return b;
}
}
}
方法重载
方法重载的概念
简单地说：方法重载就是在类的同一种功能的多种实现方式，到底使用哪种方式，取决于调用者给出的参数。
注意事项
- 方法名一定相同
- 方法的参数类型，个数，顺序至少有一项不同——（顺序：(int a , double b)改成(double a , int b)）
- 返回类型也可以不相同，但是如果只有返回类型不一样，是不能够构重载的
- 方法的访问控制修饰符可以不同，如果只是修饰符不同，也是不能够构成重载的
方法的覆盖（重写）
既然子类可以继承父类的属性和方法，这样可以提高代码的复用性，这个很好，可是问题来了！！
假设我要写三个类——猫、狗、猪，显然这三个都是动物，他们之间一定存在着相同的特点。根据类的抽象特征，我们可以把他们的相同点提取出来，形成一个父类Animal，然后继承。
但是问题来了，动物都会叫，但是叫声是不一样的，怎样解决子类和父类方法的异同！
这是就体现出了方法覆盖（重写）的特性了
public class Demo4
{
public static void main(String[] args) {
Cat cat1 = new Cat();
cat1.cry(); Dog dog1 = new Dog();
dog1.cry();
} } class Animal
{
int age;
String name;
//动物都会叫
public void cry()
{
System.out.println("我是动物,不知道怎么叫");
}
}
class Cat extends Animal
{
//覆盖了父类的方法
public void cry()
{
System.out.println("喵喵喵");
}
} class Dog extends Animal
{
//覆盖了父类的方法
public void cry()
{
System.out.println("汪汪汪");
}
}
方法覆盖——喵喵喵&汪汪汪
方法重写的核心思想：子类的某些方法和父类不一样，需要覆盖掉父类的方法
方法覆盖的概念
简单的说：方法覆盖就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的那个方法。
注意事项
- 子类的方法的返回类型，参数，方法名称要和父类方法的返回类型完全一致，否则编译会出错
- 子类方法不能缩小父类方法的访问权限，换句话说子类的权限可以比父类高
多态
所谓多态，就是指一个引用（类型）在不同情况下的多种状态。也可以这样理解：多态是指通过指向父类的指针，来调用在不同子类中实现的方法
案例
public class Demo6
{
public static void main(String[] args)
{
//多态
Animal an;//创建了一个Animal类引用变量,Animal类引用就是以后可以用来指向Animal对象的对象引用
an =new Cat(); //让这个动物的引用指向了猫这个实例(对象)
an.cry();
an = new Dog();
//以Dog类为模板,在堆空间里创建一个Dog类对象,简称为Dog对象
an.cry();
//an这个引用会自动判断引用是那种类型的
}
}
//动物类
class Animal
{
String name;
int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
} //动物会叫
public void cry()
{
System.out.println("不知道怎么叫");
} }
class Cat extends Animal
{
//猫自己叫
public void cry()
{
System.out.println("喵喵喵");
}
}
class Dog extends Animal
{
//狗自己叫
public void cry()
{
System.out.println("汪汪汪");
}
} 输出结果:
喵喵喵
汪汪汪
多态
如果没有这个特性，狗要叫就要创建一个狗的引用，猫要叫就要创建一个猫的引用，动物再多一点就会不方便管理。当然多态也能调用孙子类的方法。
package com.xiaohui; public class Demo7
{
public static void main(String[] args)
{
Master master = new Master();
master.feed(new Dog(), new Bone());
master.feed(new Cat(),new Fish());
//我想要他喂那种动物就喂那种懂我,我想喂他吃什么就吃什么
//
} }
//主人类
class Master
{
//给动物喂食物,使用多态,方法就可以用一个
public void feed(Animal an,Food f)
{
an.eat();
f.showName();
}
} class Food
{
String name;
public void showName()
{ }
}
class Fish extends Food
{
public void showName()
{
System.out.println("鱼");
}
}
class Bone extends Food
{
public void showName()
{
System.out.println("骨头");
}
}
//动物类
class Animal
{
String name;
int age;
//动物会吃
public void eat()
{
System.out.println("不知道吃什么");
}
} class Cat extends Animal
{
//猫进食
public void eat()
{
System.out.println("猫爱吃鱼");
}
} class Dog extends Animal
{
//狗进食
public void eat()
{
System.out.println("狗爱吃骨头");
}
}
想喂猫喂猫，想喂狗喂狗
如果Food类和Animal类下的子类有许多的话，Master类中的方法是无需改变的，只需要输入对应的动物和事物就可以了。否则我们想要狗吃骨头和猫吃鱼就要用这么多的代码来写
Dog dog1 = new Dog();
dog1.eat();
Bone bone1 = new Bone();
bone1.showName(); Cat cat1 = new Cat();
cat1.eat();
Fish fish1 = new Fish();
fish1.showName();
引用的注意事项：
- Java允许父类的引用变量引用它的子类的对象（对象）
Animal animal = new Cat()
这种转换是自动完成的
- 类型转换还有一些具体的细节要求,之后会进一步学医，比如子类能不能转换成父类，有什么要求等等...