后端入门---面向对象基本理解（第一部分）

一、面向对象

EG:举个例子，造一辆小汽车

1.画图纸

（1）定义车的属性：颜色，速度，几座，牌子。
（2）定义车的行为：跑。

2.拿着图纸生产汽车

1.面向对象
2.类：图纸
（1）面向对象的属性：这一类事物具有相同的属性。
（2）面向对象的动作：这一类事物具有相同的行为。
3.对象：类的具体化，具体某一样东西。
4.传参
public class Car {
   String color;
   int speed;
   int seat;
public void fly(String color){
    System.out.println(color+"\t颜色的车跑得快");
}
    public static void main(String[] args) {
        Car c=new Car();
        c.speed=100;
        c.color="red";
        c.fly("黑色");

    }
}
5.this关键字,指的就是当前类的对象。
public class Car {
   String color;
   int speed;
   int seat;
   public void run(){
       System.out.println("车能跑");
       System.out.println(this);
       System.out.println(this.color);
   }
public void fly(String color){
    System.out.println(color+"\t颜色的车跑得快");
}
    public static void main(String[] args) {
        Car c=new Car();
        c.speed=100;
        c.color="red";
        System.out.println(c.color);
        c.run();
        c.fly("黑色");

    }
}

3.构造方法

1.创建对象时自动调用的无参构造方法。
2.形式：public xxx（）{} 作用：初始化对象
3.与类名一致
public class Car {
    String color;
    int speed;
    int seat;
    public  void  run(){
        System.out.println(this.color+"颜色的车在跑");
        System.out.println(this.speed+"速度的车在跑");
        System.out.println(this.seat+"座位的车在跑");
    }
    public Car(String color,int speed,int seat){  //构造方法。
      this.color=color;
      this.speed=speed;
      this.seat=seat;
    }
    public static void main(String[] args) {
        Car c=new Car("红色",120,10);
        Car c1=new Car("绿色",180,15);
        c.run();
        c1.run();

    }
}
4.构造方法也可以进行重载
public class sportCar {
    String name;  //这里的name=this.name;
    int speed;
    String color;
    int seat;
    String country;
    public sportCar(String name,int speed,String color,String country){
        this.name=name;
        this.speed=speed;
        this.color=color;
        this.country=country;
    }
    public sportCar(String name,int speed,String country){
        this.name=name;
        this.speed=speed;
        this.country=country;
    }

    public static void main(String[] args) {
        sportCar car1=new sportCar("阿斯顿马丁",110,"黑色","英国");
        sportCar car2=new sportCar("兰博基尼",200,"意大利");

    }
}
5.构造方法一样，参数不同，这就叫重载。同名不同参。
6.比如两个方法中有大量重叠的参数，可以简写。
public class sportCar {
    String name;
    int speed;
    String color;
    int seat;
    String country;
    public sportCar(String name,int speed,String color,String country){
        this(name,speed,country);//简写，省略大量ctrl c ctrl v。
        this.color=color;
    }
    public sportCar(String name,int speed,String country){
        this.name=name;
        this.speed=speed;
        this.country=country;
    }

    public static void main(String[] args) {
        sportCar car1=new sportCar("阿斯顿马丁",110,"黑色","英国");
        sportCar car2=new sportCar("兰博基尼",200,"意大利");

    }
}
7.EG:注意new对象时候，Hero()，构造方法此时不能为空，必须有参，因为上面已经定义，此时状态不是默认状态。
public class Hero {
    String name;
    String skill_w;
    String skill_a;
    String skill_d;
    String skill_s;

    //构造方法,两个，同名不同参数
    public Hero(String name){
        this.name=name;
    }
    public Hero(String name,String skill_a,String skill_d,String skill_s,String skill_w){
        this(name);
        this.skill_a=skill_a;
        this.skill_d=skill_d;
        this.skill_s=skill_s;
        this.skill_w=skill_w;
    }
//方法
    public void fight(){
        System.out.println(this.name+"英雄的移动技巧");
    }
    public static void main(String[] args) {
        Hero h1=new Hero("亚索","左移","右移","后退","前进");
     h1.fight();
    }
}
8.蜘蛛侠和灭霸例子

新建超人类SuperMan.java，对象类为蜘蛛侠

public class SuperMan {
    String name;
    int blood;
    int attack;
    //构造方法
 public SuperMan(String name,int blood, int attack){
     this.name=name;
     this.blood=blood;
     this.attack=attack;
 }
    public void fight(Monster ms){
        System.out.println(this.name+"暴揍"+ms.name);
        ms.blood-=this.attack;
        System.out.println("灭霸能量"+ms.blood);
    }

}

再建怪兽类Monster.java，对象为灭霸

public class Monster {
    String name;
    int blood;
    int attack;
    public Monster(String name,int blood, int attack){
        this.name=name;
        this.blood=blood;
        this.attack=attack;
    }
    public void fighted(SuperMan sp){
        System.out.println(this.name+"在揍"+sp.name);
        sp.blood-=this.attack;
        System.out.println("蜘蛛侠能量"+sp.blood);
    }
}

最后新建对战场所Client.java

public class Client {
    public static void main(String[] args) {
        SuperMan sp=new SuperMan("蜘蛛侠",1000,20);
        Monster ms=new Monster("灭霸",500,30);
        sp.fight(ms);
        System.out.println("/*************************************分割/");
        ms.fighted(sp);
    }
}

4.static对象.

1.被static修饰的成员变量叫做静态变量，也叫做类变量，说明这个变量是属于这个类的，而不是属于是对象。
public class Student {
    String name;
    String sex;
    int age;
    public Student(String name,String sex,int age){
        this.name=name;
        this.sex=sex;
        this.age=age;

    }

    public static void main(String[] args) {
        Student s1=new Student("张三","男",25);

        Student s2=new Student("李四","女",22);

        s1.age=30;
        s2.age=20;
        System.out.println(s1.age);
        System.out.println("/*******************************/");
        System.out.println(s2.age);

    }
}
2.特点

1.数据共享。

2.属于类，不属于对象。

3.先于对象产生。

注:在静态方法和静态块里面不能使用this。

在静态方法里可以调用静态东西，不能调用动态。

5.包跟导包

1.在idea中，新建com.xxx.xxx然后新建类。
2.两个类，在TestPerson.java中创建Person对象，然后alt+enter导入进来。
3.包的本质就是文件夹，import+包+类。
4.在自己包里面不需要导包。
5.java.lang下所有内容都不需要导包

6.访问权限

public：所有人都可用。
default：包访问权限，只有自己包内可用。
private：私有的。

注：变量前面加public表示对外开放，不加则表示默认protected，则只对同包开放。

package com.itppf.entity;//包的声明

public class Person {
    public String pub="public";
    protected String pro="protected";
    private String pri="private";
        public static void main(String[] args) {
          Person p1=new Person();
            System.out.println(p1.pub);
            System.out.println(p1.pro);
            System.out.println(p1.pri);

    }
}
1.同一个类下面都可以访问。
新建类Person1.java，所以就有。

私有方法private就会报错。

其余三个都可以打印出来default，public，protected。

新建包com.itppf.dao。

只有公共方法public可以，其余的都报错。

7.get/set方法

1.由于某些情况下，我们需要保护个人信息，需要使用到private访问权限，而必要的参数拿不过去，因此需要将它赋值给set（）方法。

具体

this.xxx=xxx;

2.然后使用get方法返回值进行拿取。

举个例子.

新建一个学生类，Student.java

package com.itppf.entity;

public class Student {
     int id;
     String name;
     String sex;
     String address;
    //成员方法
    public void base(){
        System.out.println(this.name+"的基本信息");
    }
    }

在这个方法中定义了学生的基本信息。

然后在新建主函数窗口，StudentTest.java

package com.itppf.entity;
public class StudentTest {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.name="张三";
        s1.base();
    }
}

然后输出“张三的基本信息”。

当我们使用private修饰时，会不识别id，name等属性。

package com.itppf.entity;

public class Student {
    private int id;
    private String name;
    private String sex;
    private String address;
    //成员方法
    public void base(){
        System.out.println(this.name+"的基本信息");
    }
    }

因此这个时候我们就需要方法。



private后的name根本拿不到，必须要set传入参数后，根据get方法返回值去拿取。

完整的get/set方法学生例子。

package com.itppf.entity;

public class Student {
    private int id;
    private String name;
    private String sex;
    private String address;
    //set方法，由于上面定义的方法全是私有的，不能够在其他类使用，而我们在某些情况下要保护这些信息，因此使用set/get方法去拿取。
    public void setId(int id){
        this.id=id;  //id是传递进来的值，而this.id则是成员变量（int id）。
    }
    public int getId(){
       return this.id;
    }

    public void setName(String name){
        this.name=name;
    }

    public String getName(){
        return this.name;
    }


    public void setSex(String sex){
        this.sex=sex;
    }
    public String getSex(){
        return this.sex;

    }


    public void setAddress(String address) {
        this.address=address;
    }

    public  String getAddress(){
        return this.address;
    }
}


package com.itppf.entity;
public class StudentTest {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setId(1);
        s1.setName("李四");
        s1.setSex("男");
        s1.setAddress("中国甘肃");
        System.out.println(s1.getId());
        System.out.println(s1.getName());
        System.out.println(s1.getSex());
        System.out.println(s1.getAddress());
        System.out.println("该生学号为:"+s1.getId()+";\n姓名为:"+s1.getName()+";\n性别为:"+s1.getSex()+";\n籍贯为:"+s1.getAddress());

    }
}

输出：


8.继承

1.子类可以继承父类中除了private以外的其他内容。
2.形式：public class 类 extends 父类。
3.作用：简化代码的开发。

Father.java

package com.itppf.dao;

public class Father {
    private void hobby(){
        System.out.println("父亲喜欢搓麻将");
    }
    public void temper(){
        System.out.println("父亲的脾气好");
    }
}

Son.java

package com.itppf.dao;

public class Son extends Father{
}

package com.itppf.dao;

public class ExtendsTest {
    public static void main(String[] args) {
        Son s1=new Son();
        s1.temper();
    }
}

但是，private修饰的方法不能够被调用。比如上面的hobby()方法。


在实战中，比如登录的实现，有member.java、admin.java、然后再新建user.java。member和admin继承user共有的方法。

继承：子类对父类进行了扩展。

举个例子

package com.itppf.dao;

public class Father {
    public void temper(){
        System.out.println("父亲的脾气好");
    }
}

在子类继承父类的基础上进行了扩展，hobby（）方法。

package com.itppf.dao;

public class Son extends Father{
    public void hobby(){
        System.out.println("我喜欢打篮球");
    }
}

package com.itppf.dao;

public class ExtendsTest {
    public static void main(String[] args) {
        Son s1=new Son();
        s1.temper();
        s1.hobby();
    }
}

9.super关键字

1.super表示父类中的内容。
2.举个例子
3.新建类Animal作为父类。
public String name="动物";package com.itppf.dao;

public class Animal {
    public String name="动物";
}

然后实例化对象Tiger

package com.itppf.dao;

public class Tiger extends Animal{
    public void eat(){
        System.out.println(this.name+"吃草");
    }
    public static void main(String[] args) {
        Tiger tiger1=new Tiger();
        tiger1.eat();
    }
}

打印也没有问题

但是。。。。

如果在Tiger（子类）中添加变量String name=“奶牛”

package com.itppf.dao;

public class Tiger extends Animal{
public String name="奶牛";
    public void eat(){
        System.out.println(this.name+"吃草");
    }
    public static void main(String[] args) {
        Tiger tiger1=new Tiger();
        tiger1.eat();
    }
}

则运行



说明这个是有顺序的，类似于就近原则，先找自己类，再找父类。

因此我们要用到super关键字，super表示父类。



看上面的这个例子。

package com.itppf.dao;


public class Animal {
    public String name="动物";
    public Animal(){
        System.out.println("父类的构造方法");

    }
}





package com.itppf.dao;

public class Tiger extends Animal{
    public  String name="奶牛";
    public Tiger(){
        System.out.println("子类的构造方法");
    }
    public void eat(){
        System.out.println(this.name+"吃草");
        System.out.println(super.name+"吃草");
    }
    public static void main(String[] args) {
        Tiger tiger1=new Tiger();
        tiger1.eat();
    }
}

你会发现，先调用父类的构造方法，然后调用子类的构造方法。



其实这里默认了super(),如果添加上，super（），结果依然一样。

package com.itppf.dao;

public class Tiger extends Animal{
    public  String name="奶牛";
    public Tiger(){
        super();                                       //调用父类的构造方法
        System.out.println("子类的构造方法");
    }
    public void eat(){
        System.out.println(this.name+"吃草");
        System.out.println(super.name+"吃草");
    }
    public static void main(String[] args) {
        Tiger tiger1=new Tiger();
        tiger1.eat();
    }
}

但是注意super(),必须放在第一行，否则会报错。


参数的传递

1.super可以获取到父类中的内容。

2.如果父类中无参，可以不写。如果有参数，必须要写上。

package com.itppf.dao;


public class Animal {
    public String name="动物";
    public Animal(String name){
        System.out.println("父类的构造方法");
        this.name=name;
    }
}


package com.itppf.dao;

public class Tiger extends Animal{
    public  String name="奶牛";
    public Tiger(){
        super("老虎");         //name=“老虎”，然后传到this.name,从而修改了动物。
        System.out.println("子类的构造方法");
    }
    public void eat(){
        System.out.println(super.name);
        System.out.println(this.name);

    }
    public static void main(String[] args) {
        Tiger tiger1=new Tiger();
        tiger1.eat();

    }
}

super和this区别父类和子类中重名的内容。

10.方法的重写

1.重写：子类对父类中的方法进行重新的定义。
2.语法：子类和父类中方法的声明完全一致。
3.重写又称为方法的覆盖。
4.“构造方法不能重写!!!,构造方法也不能被继承!!! 构造方法可以重载!! public Demo(){ } public Demo(int a){ } 这个是构造方法的重载!!!”

举个例子

package com.itppf.dao;

public class Phone {
    public void name(){

        System.out.println("我是所有手机的总称！");
    }
}


package com.itppf.dao;

public class Vivo extends Phone{
    @Override
    public void name() {
        super.name();             //super可以调用父类中被重写了的内容。
        System.out.println("不！重写之后，我是vivo");
    }

    public static void main(String[] args) {
        Vivo v1=new Vivo();
        v1.name();
    }
}
以上就是我跟这IT老男孩学习的面向对象的笔记，大多是我自己感悟，有的也不一定正确，希望大家批评指正。我觉得经过学习后基本了解了面向对象，以后需要学习的还有很多，数据结构以及数组，对接口，继承，封装，多态的深入了解，以及java的二十三种设计模式，加油吧。

笔记和代码已放到github上面：
笔记：https://github.com/FSDWNS/theory-doc.git
代码：https://github.com/FSDWNS/Java-web.git

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 194,088评论 5赞 459
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 81,715评论 2赞 371
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 141,361评论 0赞 319
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,099评论 1赞 263
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 60,987评论 4赞 355
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,063评论 1赞 272
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,486评论 3赞 381
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,175评论 0赞 253
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,440评论 1赞 290
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,518评论 2赞 309
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,305评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,190评论 3赞 312
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,550评论 3赞 298
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 28,880评论 0赞 17
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,152评论 1赞 250
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,451评论 2赞 341
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,637评论 2赞 335