面向对像的概念和语法
面向对象
面向对象的概念
具体参考视频： 林粒粒的视频
如何创建一个类和怎么使用
简单理解类和对象
类：相当于一个模板，比如人类，人类可以有名字，可以吃饭，睡觉
对象：类进行实例化，例如一个人类名字为张三，年龄18，会吃饭等等
如何创建一个类
语法：
public class 类名{
//成员变量
//成员方法
}
例如：定义一个名字为Person的类
package com.xs.demo01;//类所在位置，（这个类所在的那个包里面）
/**
* @Classname : Person
* @Description : TODO 人类
* @Author : [email protected]
*/
public class Person {
//成员变量（属性）
public String name;//姓名
public int age; //年龄
public String sex;//性别
//成员方法（功能）
public void eat(){
System.out.println("人类的基本功能：吃饭");
}
}
如何使用上面的类
new：通过关键字new,把类实例化
例子：
/**
* @Classname : Persontest
* @Description : TODO 测试类
* @Author : [email protected]
*/
public class Persontest {
public static void main(String[] args) {
Person person = new Person();//把Person类进行实例化
//对类里面的成员变量进行赋值,实例化的对象名字（person）.成员变量名字（name）
person.name = "小肆";
person.age = 17;
person.sex = "boy";
System.out.println(person.name + "," + person.age + "," + person.sex);
//调用类里面的成员方法, 实例化对象名字（person）.成员方法（eat）
person.eat();
}
}
类里面的成员变量赋值和成员方法的使用，都在注释里面
运行结果：
成员变量和局部变量
成员变量：成员变量是在类以内的变量,类内都可以进行访问
局部变量：个人理解就是定义一个方法，方法内的变量就是局部变量
成员变量和局部变量名字冲突时，局部变量的优先级会更高，局部变量会屏蔽掉成员变量，但是不会修改成员变量的值
例子：定义了一个名字Person的类
package com.xs.demo01;//类所在位置，（这个类所在的那个包里面）
/**
* @Classname : Person
* @Description : TODO 人类
* @Author : [email protected]
*/
public class Person {
//定义成员变量age,赋值为18
public int age = 18;
//成员方法
public void eat(){
int a = 0; //定义一个局部变量a
int age = 0;//定义一个局部变量age，和成员变量age名字相同
System.out.println("局部变量age = " + age);
}
//成员方法
public void sleep(){
// System.out.println(a);
System.out.println("成员变量age = " + age);
}
}
不同包里面调用上面的Person类，需要进行导包
例如：
Person类在那个包里面
package com.xs.demo01;//Prson类在那个包里面
导包方式：
import com.xs.demo01包的位置，Person是包里具体要用到那个类的类名
import com.xs.demo01.Person;
package com.xs.demo02;
//使用其他包的类，导包
import com.xs.demo01.Person;
/**
* @Classname : Persontest2
* @Description : TODO 测试类，测试局部变量和成员变量
* @Author : [email protected]
*/
public class Persontest2 {
public static void main(String[] args) {
Person person = new Person();
//调用person里面的成员方法
person.eat();
person.sleep();
}
}
局部变量作用域是方法内有效，方法外面无法进行访问
运行结果：
成员方法和静态方法
成员方法：个人理解为类内的方法就是成员方法
例如：
public void eat(){
System.out.prinln("吃饭");
}
静态方法：带有static修饰符的方法是静态方法，需要通过类名，进行调用，不能通过实例化对象进行调用
例如：
public static void sleep(){
System.out.println("睡觉");
}
代码：
两种方法具体调用方式
package com.xs.demo01;//类所在位置，（这个类所在的那个包里面）
/**
* @Classname : Person
* @Description : TODO 人类
* @Author : [email protected]
*/
public class Person {
//定义了一个成员方法eat
public void eat(){
System.out.println("我是一个成员方法，可以通过实例化的对象名字进行调用");
}
//定义了一个静态方法，名字为sleep
public static void sleep(){
System.out.println("我是一个静态方法，通过类名.方法名进行调用");
}
}
调用上面的类
/**
* @Classname : Persontest
* @Description : TODO 测试类
* @Author : [email protected]
*/
public class Persontest {
public static void main(String[] args) {
//实例化对象
Person p = new Person();//实例化对象，名字为p
//调用成员方法
p.eat();
System.out.println("==================");
//调用静态方法
Person.sleep();
}
}
运行结果：
对象之间的赋值
简单理解：对象之间的赋值就像是给当前对象重新起了一个名字，两个名字代表的是一个空间，都可以使用里面的成员变量和方法
例子： 有个人名字叫张三，工资3000，年龄22，但是有一天他入赘后改了个名字李四，李四和张三都是一个人，别人问李四，你工资多少，今年多大，李四回答：工资3000，22岁
代码：
定义了一个名字为 A的类
package com.xs.demo02;
/**
* @Classname : A
* @Description : TODO A类
* @Author : [email protected]
*/
public class A {
//定义两个成员变量
public int data = 10;
public int data2 = 20;
}
调用上面的A类
/**
* @Classname : B
* @Description : TODO B类 - 测试类
* @Author : [email protected]
*/
public class B {
public static void main(String[] args) {
//对象之间的赋值
A a = new A();//实例化对象A，名字为a
System.out.println(a.data);
System.out.println(a.data2);
System.out.println("=================");
A b = a;//实例化的对象名字起一个别的名字，名字为b
b.data = 100;
b.data2 = 200;
//通过另一个名字b输出A类里面的data和data2
System.out.println(b.data);
System.out.println(b.data2);
System.out.println("===================");
//再次通过a访问A类里面的data和data2
System.out.println(a.data);
System.out.println(a.data2);
}
}
运行结果：
方法中对象的使用
对象作为方法的实际参数进行传递
定义一个Person类
/**
* @Classname : Person
* @Description : TODO 人类
* @Author : [email protected]
*/
public class Person {
//人类的两个属性
public String name;//姓名
public int age;//年龄
//人类的基本功能
public void eat(){
System.out.println(name + age +"会吃");
}
}
调用上面的Person类
/**
* @Classname : test
* @Description : TODO - 测试类
* @Author : [email protected]
*/
public class test {
public static void main(String[] args) {
//实例化对象
Person p = new Person();
p.name = "小肆";
p.age = 17;
p.eat();
System.out.println("=======================");
//把对象p作为show方法的实际参数的进行传递
show(p);
//调用Person里面的eat方法
p.eat();
}
/**
* 输出 Person 类里面的信息
* @param person 对象p的形式参数
*/
public static void show(Person person){
//修改Person里面的成员属性的值
person.name = "张三";
person.age = 20;
}
}
- 把对象p作为方法show的实际参数进行传递，方法show的形参和对象p代表的是一个空间
- 对象作为实参传递的传递的是对象名字，形式参数的写法是 类名 和 重新命名的对象名字，具体参考show方法的形式参数
运行结果：
对象作为方法的返回值
简单理解：在方法里面实例化一个对象，作为返回值进行返回
例子：
定义一个名字为人类的对象
/**
* @Classname : Person
* @Description : TODO 人类
* @Author : [email protected]
*/
public class Person {
//定义两个成员属性
public String name; //姓名
public int age; // 年龄
/**
*一个成员方法
* 输出xx会吃
*/
public void eat(){
System.out.println(age + "岁的" + name + "会吃");
}
}
调用上面的类
/**
* @Classname : test
* @Description : TODO 对象作为返回值
* @Author : [email protected]
*/
public class test {
public static void main(String[] args) {
/**
* 定义一个可以返回一个Person类对像的方法，名字为 getperson
* 定义一个Person类的对象，名字为person接受方法getperson的返回值
*/
Person person = getperson("小肆",17);
//通过person调用方法eat
person.eat();
}
/**
* 返回一个Person类的对象的方法
* @param name 姓名
* @param age 年龄
* @return Person类对象
*/
private static Person getperson(String name, int age) {
Person person = new Person();
person.name = name;
person.age = age;
return person;
}
}
方法作为返回值，需要同类型的方法进行接受，过程相当于是给对象之间赋值的过程，给对象重新起名
运行结果：
this关键字的用法
this 一般用于外部传入的参数或当前方法的局部变量，与类中成员变量名冲突时，解决冲突问题。成员方法同变量。
通过 this. 的方式调用的内容都是当前类的成员（属性或方法）
- 用法：
this.成员变量名 或 this.成员方法名()
定义一个名字为Person类
/**
* @Classname : Person
* @Description : TODO 人类
* @Author : [email protected]
*/
public class Person {
//定义两个成员属性
public String name; //姓名
public int age; // 年龄
/**
* 输出xx会吃
*/
public void eat(){
System.out.println(age + "岁的" + name + "会吃");
}
/**
* 调用Person类中的eat方法
*/
public void showeat(){
this.eat();
}
/**
* 输出成员变量和局部变量的值
*/
public void show(String name,int age){
// System.out.println("局部变量name = " + name);
// System.out.println("局部变量 age" + age);
// System.out.println("==================");
// System.out.println("this.name = " + this.name);
// System.out.println("this.age = " + this.age);
/**
* 通过形参给类中成员方法进行赋值
*/
this.name = name;
this.age = age;
System.out.println("this.name = " + this.name);
System.out.println("this.age = " + this.age);
}
}
调用上面类
/**
* @Classname : test2
* @Description : TODO 测试类 this的用法
* @Author : [email protected]
*/
public class test2 {
public static void main(String[] args) {
Person person = new Person();
/**对Person类里面的成语变量进行赋值
* person.name = "小三";
* person.age = 20;
**/
//调用Person类里面的show方法,传递两个实参
person.show("小肆",18);
//调用Person类中showeat方法
person.showeat();
}
}
两个运行结果：
- 注释掉代码打开的运行结果：this.修饰的变量和方法是类中的成员变量和方法，当局部变量和成员变量名字冲突时候，带有this.修饰词不会被覆盖
2.this.关键字，一般用于形式参数给类中成员变量进行赋值
运行结果：
