标签：事物 思想 软件开发 而且 vat 函数 自动调用 wan 添加
目录
面向对象是一种软件开发方法，这种方法可以将现实中的事物抽象出来，让我们的编程模型化。
面向过程也是一种软件开发方法，它需要我们通过具体的，流程化的方式去解决问题
打个比方，我们现在要吃个饭。
再举个程序的例子吧
C语言就是一个典型的面向过程的语言，我们在写程序的时候，会在main函数中写上我们的主程序，可能会调用其他的函数，甚至是其他文件的函数。
#include <stdio.h>
//使用C语言生成正方形
int main(){
printRect(3);
}
void printRect(int size){
for(int i = 0;i<size;i++){
for(int j = 0;j<size;j++){
printf("*");
}
printf("\n");
}
}Java使用的是面向对象编程，所以我们所有的编程都围绕着类来进行。我们不能直接调用方法，而是应该先创建实例，然后再调用实例的方法。
public class Test(){
public static void main(String[] args){
RectUtil rectUtil = new RectUtil();
rectUtil.printRect();
}
}
==============下面是另一个类======================
//一个与矩形有关的工具类
public class RectUtil(){
//有一个生成矩形的方法
public void printRect(int size){
for(int i = 0;i<size;i++){
for(int j = 0;j<size;j++){
printf("*");
}
printf("\n");
}
}
}生活中的封装指的是将东西包裹起来
在程序设计中，我们可以将类封装起来，只提供需要的方法接口，而不需要提供具体的实现细节。
封装有四个修饰符
| 范围/修饰符 | 类的内部 | 包的内部 | 任何位置 | 适用 | 备注 |
|---|---|---|---|---|---|
| public | √ | √ | √ | 修饰类，成员属性，成员方法，内部类 | |
| protected | √ | √ | 修饰成员属性，成员方法，内部类 | 不能修饰类 | |
| 默认不写 | √ | √ | 修饰类，成员属性，成员方法，内部类 | ||
| private | √ | 修饰成员属性，成员方法，内部类 | 私有方法不能被继承 |
封装的原则
封装的结果是存在，但是不可见
同名的不同方法
将子类对象赋值给父类变量，调用的方法为子类的方法。由此，同个类型的对象在执行同一个方法时，可以表现出多种行为特征
此时，如果你想调用父类的方法，可以使用super关键字。
父类中声明为static、final的方法不能被覆盖，而且声明为final的类的所有方法不允许被覆盖。
方法的重载
test(int i){}
test(String str){}
test(int i,String str){}
当我调用test(1)时，会自动的调用到第一个方法，而调用test("1")时，会自动调用到第二个方法。public abstract class AStudent{
private String id;
private String name;
private String dept;
public void study(){
System.out.println("我在学习！");
}
}
public class GoodStudent extends AStudent{
public void study(){
super().study();
System.out.println("敲代码，进大厂！");
}
}
public class BadStudent extends AStudent{
public void study(){
System.out.println("什么时候可以下课，我要去食堂抢位置了！");
}
}接口使用interface关键字来声明
public interface Teacher [extends 这里可以继承其他接口，但是我不做示范]{
public void teaching([这里可以写变量，但是我不做示范]);
}
public class TeacherImpl implements Teacher{
//如果你实现了接口，那么类中必须有接口里所有的方法的实现
public void teaching(){
[代码内容]
}
}public class test{
//构造方法与类名同名，不用定义返回值，我们可以认为返回值为这个类。
public test(){
}
//有参的构造方法
public test(int i){
}
}由多态的性质，我们可以知道，构造方法可以有很多个，因为它本身也是一个方法，符合多态的特性。
跟普通方法不同的是，它是在类被实例化的时候调用的。
我们可以将其应用在，需要给多个属性赋值的时候。
//如果没有构造方法
Student student = new Student();
student.id = "123456";
student.name = "小明";
//如果有构造方法
Student student = new Student("123456","小明");
student = new Student();//如果没有写无参的构造方法，此时这样写会报错尝试使用面向对象的思想进行编程，讲述一个小故事
例如：
恋爱的狮子与农夫
? 狮子爱上了农夫的女儿，请求农夫把女儿嫁给他。农夫既不忍心把女儿许配给野兽，又不敢拒绝，就想出一个办法
当狮子来催促的时候，农夫对他说：“我愿意把女儿嫁给你，可是我的女儿害怕你的尖牙和利爪，而且我也担心这些会伤害到她。如果你能剪掉你的利爪，并且磨平你的牙齿，我就立刻让女儿与你成婚。”
狮子高兴得不得了，说道：“只要能娶到她，什么条件我都答应，我马上按照你的意思去做！”
狮子回去后剪掉了自己尖利的爪子，在磨石上磨平了尖锐的牙齿。他打扮一新，到农夫家里迎娶新娘。可是到了农夫家门口，却发现农夫手提木棒，朝自己走来，看样子来者不善。狮子警惕地摆好了架势。
果然农夫一阵乱棒像雨点一样敲击下来，但是狮子却无力还击，因为他的爪子和牙齿全然没有任何威力。
最后狮子落荒而逃，更糟糕的是，没有了尖牙、利爪，狮子再也无法捕捉到猎物，最后饿得奄奄一息。
package domain;
/**
* @author Jennyism
* @date 2020/1/27 0027 21:47
*/
public abstract class Role {
private String name;
public void say(String words) {
System.out.println(getName() + ":" + words);
}
public void think(String feel) {
System.out.println(getName() + "觉得" + feel);
}
public void attack(Role role) {
System.out.println(getName() + "对" + role.getName() + "发起攻击");
}
public void doSomething(String some) {
System.out.println(getName() + some);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package domain;
/**
* @author Jennyism
* @date 2020/1/27 0027 21:52
*/
public class Lion extends Role {
private boolean claw;
private boolean canineTeeth;
public Lion(String roleName) {
setName(roleName);
System.out.println("我是一只狮子，我的名字叫" + getName() + "，我爱上了农夫的女儿");
}
public void wantMarry(Role role) {
System.out.println(getName() + "想娶" + role.getName());
}
public boolean hasClaw() {
return claw;
}
public void setClaw(boolean claw) {
if (!claw){
System.out.println(getName()+"剪掉了自己尖利的爪子！");
}
this.claw = claw;
}
public boolean hasCanineTeeth() {
return canineTeeth;
}
public void setCanineTeeth(boolean canineTeeth) {
if (!claw){
System.out.println(getName()+"在磨石上磨平了尖锐的牙齿。");
}
this.canineTeeth = canineTeeth;
}
}
package domain;
/**
* @author Jennyism
* @date 2020/1/27 0027 22:01
*/
public class Farmer extends Role {
public Farmer(String roleName){
setName(roleName);
System.out.println("我是农夫，我的名字叫"+getName()+"，狮子要娶我的女儿，可我不敢拒绝。");
System.out.println("于是我想到了一个办法。");
}
}
package domain;
/**
* @author Jennyism
* @date 2020/1/27 0027 22:06
*/
public class Daughter extends Role {
public Daughter(String roleName){
setName(roleName);
}
}
package client;
import domain.Daughter;
import domain.Farmer;
import domain.Lion;
import domain.Role;
/**
* @author Administrator
*/
public class MyFirstClient {
public static void main(String[] args) {
//狮子有自己的方法，需要赋值到Lion类
Lion lion = new Lion("Lion Steve");
//女儿没有再添加新的方法，可以直接赋值给Role类
Role daughter = new Daughter("Daughter Fuck");
lion.wantMarry(daughter);
lion.say("农夫，你能把你的女儿嫁给我吗。");
Role farmer = new Farmer("Farmer Fuck");
System.out.println("=============第一段结束==========");
lion.say("农夫，你要怎样才能把女儿嫁给我！");
farmer.say("我愿意把女儿嫁给你，可是我的女儿害怕你的尖牙和利爪，而且我也担心这些会伤害到她。如果你能剪掉你的利爪，并且磨平你的牙齿，我就立刻让女儿与你成婚。");
lion.think("高兴极了");
lion.say("只要能娶到她，什么条件我都答应，我马上按照你的意思去做！");
System.out.println("=============第二段结束==========");
lion.setClaw(false);
lion.setCanineTeeth(false);
lion.doSomething("打扮一新，前去迎娶新娘");
farmer.doSomething("提着木棒走来！");
farmer.attack(lion);
lion.attack(farmer);
lion.doSomething("落败逃走，没有了尖牙、利爪，狮子再也无法捕捉到猎物，最后饿得奄奄一息。");
System.out.println("=============全剧终==========");
}
}
标签：事物 思想 软件开发 而且 vat 函数 自动调用 wan 添加
原文地址：https://www.cnblogs.com/Jennyism/p/javase-07.html
