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

0405

一、面向对象

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

【信息由网络或者个人提供，如有涉及版权请联系COOY资源网邮箱处理】

© 版权声明
部分内容为互联网分享，若有侵权请联系站长删除。
THE END
HTML
喜欢就支持一下吧
点赞5 分享
Tribal conflict（钟意）的头像COOY全球资源网-软件资源-干货分享-知识求知COOY全球资源网
ts学习（6）COOY全球资源网-软件资源-干货分享-知识求知COOY全球资源网
ts学习（6）
ts学习（6）
23天前 51
Spring AOP 基本概念COOY全球资源网-软件资源-干货分享-知识求知COOY全球资源网
Spring AOP 基本概念
Spring AOP 基本概念
12天前 50
iOS Terminating app due to uncaught exception ‘NSGenericException’, reason: ‘*** CollectionCOOY全球资源网-软件资源-干货分享-知识求知COOY全球资源网
iOS Terminating app due to uncaught exception ‘NSGenericException’, reason: ‘*** Collection
iOS Terminating app due to uncaught exception ‘NSGenericEx...
16天前 50
SpringBoot 集成 RedisCOOY全球资源网-软件资源-干货分享-知识求知COOY全球资源网
SpringBoot 集成 Redis
SpringBoot 集成 Redis
12天前 50
当我们在命令行敲下 hadoop jar xxx.jar，它的整个执行流程COOY全球资源网-软件资源-干货分享-知识求知COOY全球资源网
当我们在命令行敲下 hadoop jar xxx.jar，它的整个执行流程
当我们在命令行敲下 hadoop jar xxx.jar，它的整个执行流程
16天前 50
html5和css3进阶（浮动）—-02COOY全球资源网-软件资源-干货分享-知识求知COOY全球资源网
html5和css3进阶（浮动）—-02
html5和css3进阶（浮动）—-02
18天前 49
相关推荐
评论 抢沙发

请登录后发表评论

    暂无评论内容