1.什么是面向对象
众所周知java是面向对象的编程语言,那么什么是面向对象呢,大家经常把面向对象和面向过程混淆,下面就说个例子,一秒就会!
例如小明有一些脏衣服需要去洗干净,这是就相当于一个命令把衣服洗干净
A:面向过程:小明需要自己独立完成,打水、放洗衣液、搓衣服等等一些列操作直至衣服洗干净
B:面向对象:小明不需要自己独立完成,但是他需要把衣服送到具有洗衣服功能的地方,例如洗衣房,你需要办一张会员卡,然后对工作人员说:我不管你用什么办法,总之给我洗干净就行
2.面向对象格式
首先需要一个类,这里面不写main方法,这里面会有三部分组成
A:类变量B:类方法C:构造函数
假如现在有一个学生类
- A:类变量,又称作成员变量,它是用来描述这个类的属性,、一个学生肯定有姓名、学号、年龄、性别等一些列属性!所以这些成为成员变量
- B:类方法:类方法就是这个类他有什么功能,他能干一些什么,例如一个学生他能算数、考试、吃饭等一系列技能
- C:构造函数:构造函数就是给这个类找个实体,现在只知道这是一个学生类,这个学生类具体是谁啊,目前不知道,现在就需要一个构造函数来完成定义一个实体,注意构造函数他主要有两种,一种是无参构造另一种有参构造构造函数可以有多个或者一个没有,接下来就说一下这两个的区别
无参构造:无参构造来定义一个实体时,只是指明有一个学生,但是学生的信息没有说!当在学生类中没有写构造函数,java会自动为这个类提供一个无参构造,用于创建对象(实体)
有参构造:有参构造定义的一个学生,他还指定了一个这个学生的一些信息,比如这个学生叫什么,今年多大了,下面通过代码来说明一下描述
学生类:
public class Student {
//成员变量
String name;//学生姓名
String sex;//学生性别
int age;//学生年龄
/**
* 成员方法
* 格式: 修饰值关键字 返回值类型 方法名(参数){}
* 修饰关键字:public(所有地方都可以用) protected(同一个项目可以用) 不写(同一个包) private(同一个类)
*返回值类型:就是完成这个方法,返回的结果
*参数:这里的参数指的是形式参数
*
*/
public void eat() {
System.out.println("我会吃饭");
}
public int add(int a,int b) {
return a+b;
}
//构造函数,记住这个格式即可
//有参构造
public Student(String name, String sex, int age) {
super();
this.name = name;
this.sex = sex;
this.age = age;
}
//无参构造
public Student() {
}
}
测试类:
因为在学生类中我们没有写main函数,没有办法运行,需要写一个测试类
public class TestStudent {
public static void main(String[] args) {
//创建对象,对象是怎么来的,new出来
//这就是一个学生,用stu1表示,但这个学生没有指定任何信息就称为无参构造
Student stu1=new Student();
//因为stu1是个学生,所以他能够完成Student类中的功能,实体对象.方法名();即可调用
stu1.eat();
//这就是一个学生,用stu2表示,但这个学生指定了他的姓名、性别、年龄我们称为有参构造
Student stu2=new Student("zhangsan","nan",18);
}
}
注意:一个类中可以没有构造函数,也可以有多个构造函数
3.方法重载
方法的重载这个也比较重要,方法重载指的是在一个类中两个方法方法的名字相同,但传递的参数不同,代码如下
public class Test {
public void shouMe(String name,int age) {
System.out.println("我的名字"+"name"+"我今年"+age);
}public void shouMe(String name ,String sex,int age) {
System.out.println("我的名字"+name+"我的性别"+sex+"我的年龄"+age);
}
public static void main(String[] args) {
Test t1=new Test();
t1.shouMe("zhangsan", 14);
t1.shouMe("lisi", "nan", 15);
/**
* 打印结果
* 我的名字name我今年14
*我的名字lisi我的性别nan我的年龄15
*/
}
}
4.this的使用
当一个类中的成员变量与方法的形参重名里,在方法中要使用成员变量的值需要用this.成员变量
public class Stu{
String name="张三";
public static void main(String[] args) {
Stu s1=new Stu();
s1.test("李四");
}
public void test(String name){
//这里的name为形参
System.out.println(name);//结果为李四
System.out.println(this.name);//结果为张三
}
}
5.静态static
静态是比较常用的一个关键字,静态经常修饰变量,方法,静态代码块
用static修饰的有两个特性A:静态B:共享
B:共享:用static修饰的变量和方法,表示他不是一个对象独有的,他是所有对象公用的,用static修饰的变量和方法,不需要创建对象就可以直接类名.方法名/变量名即可调用
public class Stu{
String name="张三";
public static void main(String[] args) {
Stu.test("李四");//因为test方法是静态的,所有可以直接用,不建立对象,变量也是如此
}
public static void test(String name){
//这里的name为形参
System.out.println(name);//结果为李四
System.out.println(this.name);//结果为张三
}
}
静态代码块是类加载便执行的部分,他是第一个执行的,但是他只执行一次,当再次访问这个类时,static代码块不会执行,接下来说明一下静态代码块、构造函数,构造代码块执行顺序
public class sta {
/**
*
* 静态代码块在类加载的时候运行,只要加载class文件,静态代码块就会执行,且只执行一次
* 一个类中静态代码块最先执行且只运行一次,构造代码块会在new对象时执行且在构造方法之前运行
*
* @param args
*/
String name;
int age;
{
//构造代码块
System.out.println("我是构造代码块");
}
static {
//静态代码块
System.out.println("我是静态代码块");
}
public sta() {
//无惨构造函数
System.out.println("我是无惨构造");
}
public sta(String name, int age) {
//有参构造函数
System.out.println("我是有参构造");
this.name = name;
this.age = age;
}
public static void main(String[] args) {
sta s=new sta();
sta s2=new sta("xzc", 21);
}
}
结果
我是静态代码块
我是构造代码块
我是无惨构造
我是构造代码块
我是有参构造
所以执行顺序静态代码块>构造代码块>构造函数
当我们学了继承后就会发现,所有执行顺序都是父类执行完了在执行子类
6.封装
封装是java特性之一,是将java的属性进行私有化,在外界不能随意更改他的属性,要想修改通过特有的方法(set/get方法)快捷键:Alt+shife+s选择Set\Get方法
public class Person2 {
private String name;
private int age;
private String sex;
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 String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
public class Test2 {
public static void main(String[] args) {
Person2 p=new Person2();
p.setAge(10);
p.setName("张三");
p.setSex("女");
System.out.println(p.getName()+p.getAge()+p.getSex());
结果:
张三10女
}
}
7.继承
继承是java特征之一,使用extends关键字,继承需要注意的点
- 一个子类只有一个直接父类
- final关键字修饰的类不能被继承
- 子类是父类的完善与扩展
- 子类是继承父类非私有的属性和行为
- 继承不能环形继承例如A是B的父类,B是C的父类,C是A的父类这就会报错
比如这里有一个有一个动物类,小狗、小猫都属于animal所以他属于一个父类,小狗、小猫就能使用拥有父类非私有的属性和行为,一定注意是非私有
public class Animal {
String name="旺财";//这相当于父类给每一个子类的名字都是旺财
String sex;
int age;
private int num;
public void eat() {
System.out.println("一日三餐!");
}
}
还有一个狗类和熊类继承动物类
public class Dog extends Animal {
String name="八公";//Dog自己给自己取的名字
//小狗的新特性,会算数
public int add(int a,int b) {
return a+b;
}
public void showMe(String name) {
System.out.println("我在方法的名字叫"+name);
System.out.println("我自己的名字"+this.name);//this指子类
System.out.println("我父亲给我的名字"+super.name);//super指父类
}
}
public class Bear extends Animal {
public void eat() {
System.out.println("我喜欢吃任何东西");//与父类传来的方法相同,这叫做方法的重写
}
}
测试类
public class Test {
public static void main(String[] args) {
Dog dog=new Dog();
dog.showMe("边牧");
dog.num;//报错,因为父类的num是私有的
Bear b=new Bear();
b.eat();
}
}
结果:
我在方法的名字叫边牧
我自己的名字八公
我父亲给我的名字旺财
我喜欢吃任何东西
7.上溯
例如以上有个动物类,一个狗类
Animal a=new Dog();//Dog也属于动物类,这样就是上溯,相当于强制转换
//这里a只能使用Animal中定义过得方法和属性,a不能使用Dog自己新增的
//并且如果子类重写了父类的方法,则走重写后的
8.多态
多态是用在继承关系中的,这个也利用到了上述的上溯,多态使用的地方
A:方法的参数 B:方法返回值
例如有一个动物类,Dog类、Cat类、Bear类
public class Animal {
String name;
int age;
public void eat() {
System.out.println("Animal的eat方法");
}
}
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗爱吃骨头");
}
}
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫爱吃鱼");
}
}
public class Bear extends Animal {
@Override
public void eat() {
System.out.println("熊什么都爱吃");
}
}
最后再来一个测试类
public class TestAnimal {
public static void run(Animal a) {
a.eat();
}
public static void main(String[] args) {
TestAnimal.run(new Dog());
结果:狗爱吃骨头
TestAnimal.run(new Cat());
结果:猫爱吃鱼
TestAnimal.run(new Bear());
结果:熊什么都爱吃
}
}
在run方法里,需要传递一个Animal的对象,因为上述猫狗熊都继承了Animal类,所以猫狗熊都是属于Animal的一种,这就是多态