- 简单概念
- 成员方法
- this关键字
- 注意：
+++++++++++++++++++++++++++++++++++++++
1面向对象的三个特点：继承 封装 多态
2对象是什么 可以是车 可以是人 可以是任何能够具体描述的东西
3什么是类
类可以具有属性和方法
例如人类
具有什么样子的特点可以描述叫做属性
方法是指能够做什么事情（对象执行的操作）
用Class来定义类
class 类名
public class Person{
//省略类的内部具体的代码
}
@1定义类名要注意首字母要大写
@2访问修饰符如public、private、等是可选的
4属性的定义（对象所具有的特征）
public class Person1 {
public String name; //定义一个人的姓名
public String gender; //定义一个人的性别
public int age ; //定义年龄
}
5方法的定义
@1定义方法的格式:
【访问修饰符}】返回类型 方法名称 （参数类型 参数1，参数类型 参数2,）{
方法体代码
}
@2访问修饰符是可选的
@3返回类型可以是VOID，在定义方法时，返回类型为VOID时没有标明返回值，方法体中不必使用return；返回具体数值时，可以使用return返回数值，并且要注意返回值的对应类型，否则会出现编译错误。
@4当需要方法体执行时候才为方法传递参数列表，如果不需要传递参数就可以省略；小括号不可以省略，传递多个参数时用半角逗号进行分隔
public class person2 {
public String name;
public String gender;
public int age;
//定义人类的行为
public void work(){
System.out.println(this.name+"的工作理念，搞钱");
}
}
6 创建和使用对象
@1创建对象
格式 类名 对象名 =New 类（）
例如Person hanbing = new Person();
new是关键字
左边的类名为对象的数据类型
右边的类名（）为类的构造方法
@2使用JAVA对象
对象名,属性 //引用对象的属性
对象名.方法名（） //引用对象的方法
如下所示
public static void main(String[] args) {
//创建对象
person2 person2 = new person2();
//使用对象
person2.name = "老王"; //为对象的name属性赋值
person2.gender ="男"; //调用对象的gender的属性赋值
person2.age = 18; //调用对象的age的属性赋值
person2.work(); //调用对象的work方法
}
7对象数组
需求：
定义包含3个元素的对象数组，数据类型为Person，并使用for循环遍历
public static void main(String[] args) {
Person3[] person3s = {new Person3(22,"老王"),new Person3(23,"小王"),new Person3(24,"王炸")};
for (int i = 0; i < person3s.length; i++) {
System.out.println("age属性等于"+person3s[i].age+","+"name属性等于"+person3s[i].name);
}
}
对象数组，其实对象数组的数据基本类型就是具体的类名，对象数组存储的就是这个类的对象，每个数组元素就是一个对象，当根据下标找到某个元素时，可以按照对象的使用来使用该元素
类成员主要包含两部分：成员方法和成员变量
1 每个人都有不同的工作理念，在person类中定义工作的方法，并通过参数接受工作理念；
分析：带有参数的work()方法可以接受用户输入的内容。创建work()方法时定义的参数叫做形式参数，简称形参。调用方法时传入的参数叫做实际参数，简称实参。
eg:
public class Person4 {
public String name;
public String gender;
public int age;
//无参的工作方法
public void work(){
System.out.println(this.name+"工作理念: 搞钱");
}
//有参的工作方法
public void work(String contect){
System.out.println(this.name+"的工作理念:"+contect);
}
//带有返回值的无参方法
public String works(){
return "实现财富自由";
}
}
测试代码
public static void main(String[] args) {
Person4 person4 = new Person4();
person4.name ="老王";
person4.age =18;
person4.gender ="男";
//将works方法的返回值赋给 contect变量
String contect = person4.works();
System.out.println(person4.name+"的工作理念:"+contect);
}
输出结果为
老王的工作理念:实现财富自由 Process finished with exit code 0
2方法重载
方法重载是指一个类中定义多个同名的方法，但要求每个方法具有不同的参数类型和参数个数。
eg1：定义一个不带参数的work()的方法并观察 他们之间的区别。
public class Person5 {
public String name;
public String gender;
public int age;
public void eat(String name){
System.out.println(this.name+"邀请"+name+"共进晚餐");
}
public void work(){
System.out.println(this.name+"岁的工作理念: 搞钱");
}
public void work(String contect){
System.out.println(this.name+"的工作理念:"+contect);
}
}
一个需要输入参数一个不需要参数
@2方法重载的特点……………………重要
1在同一个类中
2方法名相同
3参数类型和个数不相同
4方法返回值不能作为判断方法之间是否构成方法重载的依据
3 成员变量
1成员变量的作用域
类中的属性，也就是直接定义在类里面的变量称为 成员变量，它定义在方法 的外部。
在下面代码person类中的name gender既不属于eat（）方法，也不属于work() 而属于
person类本身的属性，他们是person类的成员变量
代码如下
public class Person5 {
public String name=;
public String gender;
public int age;
public void eat(String name){
System.out.println(this.name+"邀请"+name+"共进晚餐");
}
public void work(){
int age =18;
System.out.println(this.name+age+"岁的工作理念: 搞钱");
}
public void work(String contect){
System.out.println(this.name+"的工作理念:"+contect);
}
public void showDetails(){
System.out.println("姓名是:"+this.name+",性别为"+this.gender+",年龄是:"+this.age);
}
}
注：成员变量可以在声明时赋初始值。
2 局部变量的作用域
局部变量就是定义在方法中的变量。
例如：
work()方法中的变量age就是全局变量。
注：虽然成员变量和局部变量age的名称都一样，但表示的并不是同一个变量，局部变量需要先赋值再使用。
3 成员变量和局部变量之间的区别：
@1作用域不同
局部变量的作用域仅限于定义它的方法，在该方法外无法访问它，成员变量的作用域在整个类内部都是可见的，所有的成员方法都可以使用它，如果访问权限允许，还可在类外部使用成员变量
@2初始值不同
对于成员变量，如果在类定义中没有赋予初始值,JAVA会自动给他一个默认值，基本数据类型的值为0，引用类型的值为null，但是java不会赋予局部变量初始值，因此局部变量需要赋值后使用。
@3同名规则
在同一个方法中，不允许有同名 的局部变量，在不同的方法里，允许有同名的局部 变量
局部变量可以和成员变量名同名，并一起 使用，局部变量具有更高的优先级
4.数据类型
在java中，变量的类型分为两种，一种是基本的数据，一种是引用数据类型
java中引用数据类型包括三种类：类 数组 接口
以下例子来介绍对比基本数据类型和引用数据类型的区别
public class Person {
public int age;
}
public static void main(String[] args) {
//基本数据类型
int num1=11;
int num2 =num1;
System.out.println("num1等于:"+num1);
num2=22;
System.out.println("把num1赋给num2后，修改num2的值."+"num1等于："+num1);
System.out.println("*********");
//引用数据类型
Person person1=new Person();
person1.age=11;
Person person2=person1;
System.out.println("person1.age等于:"+person1.age);
person2.age=22;
System.out.println("把person1对象赋给person2对象后，修改person2的age属性,"+"person1.age等于:"+person1.age);
}
分析如下:
int为基本数据类型，当初始化num1并赋值后，将num1赋给num2，然后修改num2的值，运行后发现num1的值没有改变。
class为引用数据类型，当实例化person1对象并对其属性赋值后，将person1对象赋给person2对象，然后修改person2的值，运行后发现person1的属性值发生变化。
几乎同样的操作，为什么会有完全相反的结果？这是因为int和class在内存种的存储方式不同，这也是基本数据类型和引用数据类型的主要区别。
对于基本数据类型，不同的变量会分配不同的存储空间，并且存储空间中存储的是该变量的值，赋值操作传递的是变量的值，改变一个变量的值不会影响另外一个变量的值
对于引用数据类型，赋值是把原对象的引用(可以理解内存地址)传递给另外一个引用，对数组而言，当用一个数组名直接给另一个数组赋值时，相当于传递一个引用，此时，这两个引用指向同一个数组，也就是指向同一内存空间。
4 构造方法
@1定义
1java中，当类创建一个对象时会自动调用该类的构造方法，构造方法分为默认构造方法和带参数的构造方法。
2构造方法的主要作用是进行一些数据的初始化
书写格式
【访问修饰符】方法名（【参数列表】）{
//省略
}
构造方法没有返回值
默认构造方法没有参数，因此参数列表可选
构造方法的方法名与类名相同
eg:
public class Person {
public String name;
public Person(){
this.name="寒冰";
}
}
在这个构造方法里面为person类的对象创建后，将其name值赋值为寒冰；如果没有编写自定义的构造方法，那么系统会自动添加默认的构造方法，默认的构造方法没有参数；如果自定义一个或者多个构造方法，系统不会自动添加默认的构造方法。
2 构造方法重载
构造方法也可以重载，和一般方法重载等技术实现信息的输出。
eg:
public class Person {
public String name;
public String gender;
public int age;
public Person(){ //无参的构造方法
this.name="寒冰";
}
public Person(String name){
this.name=name; //带参数构造方法
}
public void work(){
System.out.println(this.name+"的工作理念，干活挣钱又饭吃");
}
public void work(String contect){
int age =this.age;
System.out.println(this.name+age+"岁的工作理念:"+contect);
}
}
public static void main(String[] args) {
Person guest = new Person("寒冰");
System.out.println("大家号，欢迎"+guest.name+"来到地球村");
Scanner input =new Scanner(System.in);
switch (input.nextInt()){
case 1:
guest.gender="男";
break;
case 2:
guest.gender="女";
break;
default:
System.out.println("操作失误");
return;
}
System.out.println("请输入您的年龄:");
guest.age=input.nextInt(); //为对象的年龄赋值
guest.work(); //调用无参work()方法
System.out.println("请重新输入您的工作理念:");
String contect=input.next();
guest.work(contect); //调用有参work()方法
System.out.println("***********");
}
测试代码
this关键字在成员变量的示例中多次用到了this关键字，this的含义是什么呢?
this关键字是对一个对象的默认引用，每个实例方法内部都有一个this引用变量，指向调用这个方法的对象，其实就是指当前对象的引用，通俗点理解本对象自己
this的四种用法:
一.this.属性名：
表示本对象自己的属性使用this调用成员变量，解决变量和局部变量的同名冲突
eg:
public class Person {
public String name;
public int age;
public double height;
public Person(String n,int a,double h){
name=n;
age=a;
height=h;
}
public void introduce(){
System.out.println("我叫"+name+",今年"+age+"岁");
}
}
public static void main(String[] args) {
Person person = new Person("张三", 20, 178.5);
person.introduce();
}
运行结果：
我叫张三,今年20岁 Process finished with exit code 0
二.This.方法名：
我们 on类增加了一个”打招呼”的方法叫做greet。在introduce方法当中，就可以通过”this.方法名”的方式来调用这个方法，表示调用的是”本对象自己的greet”方法。这是this关键字的第二种用法。当然，在introduce方法中并没有出现其他对象，所以方法名前面的this关键字也可以省略不写。
public void greet(){
System.out.println("hello,大家好");
}
public void introduce(){
this.greet();
System.out.println("我叫"+name+",今年"+age+"岁");
}
运行结果
hello,大家好 我叫张三,今年20岁 s Process finished with exit code 0
三.this.关键字
还有另外一种很重要的用法，那就是在this关键字的后面加上小括号，这样就表示调用了某个类自身的构造方法，为了讲解这种用法我们再来修改一下Person类:
我们给Person类又增加了一个构造方法。这个构造方法只有2个参数，并且只初始化2个属性。为了讲述方便，我们把上面的3个参数的构造方法称之为”构造方法①”，把下面的2个参数的构造方法称之为”构造方法②”。通过观察不难发现，这两个构造方法当中前2行代码是相互重复的，为了避免这种重复性的代码出现，我们可以在”构造方法①”当中调用”构造方法②”。调用的方式如下：
//构造方法1
public Person(String name,int age,double height){
this(name,age); //调用构造方法2
this.height=height;
}
//构造方法2
public Person(String name,int age){
this.name=name;
this.age=age;
}
四.外部类名.this.属性
内部类可以直接访问外部类的属性
public class Outter {
public int a=0; //外部类的属性
class Inner{
public void printA(){
System.out.println(a);//内部类方法调用外部类的属性
}
}
}
测试代码
public static void main(String[] args) {
//先创建外部类
Outter outter = new Outter();
//再创建外部类的内部类
Outter.Inner inner = outter.new Inner();
inner.printA();
}
实际输出
0 Process finished with exit code 0 //表示内部类方法调用外部类的属性
分析：
在这段代码中，定义了外部类Outter，Outter有一个属性a，并且Outter中又定义了内部类，在内部类的printA()方法中调用了外部类的a属性。我们都知道，一个内部类可以直接访问它所在外部类的属性和方法。这个特性在我们的上面这段代码中得到了体现。但是，如果内部类中出现了与外部类同名的属性或方法时，该如何区分调用的到底是哪个属性或方法呢？比如说，在Inner类中也出现了a属性，那么输出语句中的a到底是指哪个a呢？很简单，如果输出语句中直接写a，那么调用的是内部类的a属性。为了强调它是内部类的a属性，我们也可以在a的前面加this关键字。如果我们希望调用的是外部类的a属性，可以用”外部类名.this.a”的方式来调用
public class Outter {
public int a=0; //外部类的属性
class Inner{
public int a=10;//内部类的属性
public void printA(){
System.out.println(a);//调用内部类的a属性，输出10
System.out.println(this.a);//调用内部类的a属性，输出10
System.out.println(Outter.this.a);//调用外部类的a属性，输出0
}
}
}
注意：
因为this是在对象内部指代自身的引用，所以this只能调用实例变量、实例方法和构造方法，不能调用类变量和类方法，也不能调用局部变量。
