众所周知java是面向对象的编程语言，那么什么是面向对象呢，大家经常把面向对象和面向过程混淆，下面就说个例子，一秒就会！
例如小明有一些脏衣服需要去洗干净，这是就相当于一个命令把衣服洗干净
A:面向过程:小明需要自己独立完成，打水、放洗衣液、搓衣服等等一些列操作直至衣服洗干净
B:面向对象:小明不需要自己独立完成，但是他需要把衣服送到具有洗衣服功能的地方，例如洗衣房，你需要办一张会员卡，然后对工作人员说：我不管你用什么办法，总之给我洗干净就行
首先需要一个类，这里面不写main方法，这里面会有三部分组成
A:类变量B:类方法C:构造函数
假如现在有一个学生类
- A：类变量，又称作成员变量，它是用来描述这个类的属性，、一个学生肯定有姓名、学号、年龄、性别等一些列属性！所以这些成为成员变量
- B:类方法：类方法就是这个类他有什么功能，他能干一些什么，例如一个学生他能算数、考试、吃饭等一系列技能
- C:构造函数：构造函数就是给这个类找个实体，现在只知道这是一个学生类，这个学生类具体是谁啊，目前不知道，现在就需要一个构造函数来完成定义一个实体，注意构造函数他主要有两种，一种是无参构造另一种有参构造构造函数可以有多个或者一个没有，接下来就说一下这两个的区别
无参构造：无参构造来定义一个实体时，只是指明有一个学生，但是学生的信息没有说！当在学生类中没有写构造函数，java会自动为这个类提供一个无参构造，用于创建对象（实体）
有参构造:有参构造定义的一个学生，他还指定了一个这个学生的一些信息，比如这个学生叫什么，今年多大了，下面通过代码来说明一下描述
学生类：
public class Student {
//成员变量
String name;//学生姓名
String sex;//学生性别
int age;//学生年龄
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);
}
}
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 {
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);
}
}
结果
我是静态代码块
我是构造代码块
我是无惨构造
我是构造代码块
我是有参构造
所以执行顺序静态代码块>构造代码块>构造函数
当我们学了继承后就会发现，所有执行顺序都是父类执行完了在执行子类
封装是java特性之一，是将java的属性进行私有化，在外界不能随意更改他的属性，要想修改通过特有的方法(set/get方法)快捷键:Alt+shife+s选择SetGet方法
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自己新增的 //并且如果子类重写了父类的方法，则走重写后的
