面向对象-java

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

//造车：1. 画图纸.1. 定义车的属性信息: color, speed, seat2.定义车的动作:跑.2.拿着图纸找工厂生产车面向对象的世界里类:就是图纸属性:这一类事物拥有的共同属性动作：这一类事物共同能执行的功能对象: 使用类创建的具体某一个东西I对象能干什么？完全取决于类是如何定义的写代码类要使用class来定义属性:成员变量来描述.直接写在类中的变量.动作: 成员方法.不写static就是成员方法创建对象:类 引用 = new 类();//创建对象public class Car {     //创建类的属性     String color; //颜色     int speed; //速度     int seat; //座位     //int seat1 =  5; //座位   也可以直接赋值       //成员方法     public void run(){         System.out.println("车跑起来");     }     public static void main(String[] args) {         //程序入口         int a =1  方法里的局部变量         //创建对象         Car c = new Car();         c.color = "红色";         //c.aa =10;   这里调用者  不可以加属性  跟python 不一样 python  创建对象之后  加了属性  相当于 在这个创建对象的内存空间里可以生成这个属性         c.run();         System.out.println(c.color);       Car c2  =new Car();       c2.color = "绿色"       c2.fly(color:"黑色")     } }//thispublic void run(){    //this  是调用方法的本身,比如 是c对象调用了该方法 那么就执行c里面的方法      System.out.println(this.color);    System.out.println("车跑起来");}public void fly(String color){    //  此时访问的是也是成员变量, 变量的查找顺序;先找自己方法内,如果自己没有 就去this 里去找    //System.out.println(color+"车飞起来");   System.out.println(this.color+"颜色的车会飞,飞在+color+颜色的云彩里")}构造方法:     public class Car {     //创建类的属性     String color; //颜色     int speed; //速度     int seat; //座位     //int seat1 =  5; //座位   也可以直接赋值// java 会自动的赠送给每一个类一个无参数的构造方法// 如果你自己定义了构造方法, java就不再赠送你了//在创建对象的时候,自动调用方法 public Car(String color; int speed){       //设置属性信息       this.color = color;       this.speed =speed;   }     //成员方法     public void run(){         System.out.println(this.color+"颜色的车在跑");              }     public static void main(String[] args) {         //程序入口         //创建对象         Car c = new Car(color: "绿色", speed: 120);          //c.color = "红色1";         //c.aa =10;         c.run();        Car c = new Car(color: "红色", speed: 100);           //c.color = "红色1";         //c.aa =10;         c.run();} }构造方法重载:  public class Car {     //创建类的属性     String color; //颜色     int speed; //速度     int seat; //座位     //int seat1 =  5; //座位   也可以直接赋值// java 会自动的赠送给每一个类一个无参数的构造方法// 如果你自己定义了构造方法, java就不再赠送你了//在创建对象的时候,自动调用方法 public class daxia(){       String name;       String waihao;       int age;       String bangPai;   }     //我们需要构造两个方法     public DaXin(String name, int age, String banPai){         this.name =name;        this.age =age;        this.bangPai =bangPai;              }//  构造方法也是方法 也可以进行重载//可以让我们有更多的方式去创建对象   public DaXin(String name, int age, String banPai,String waihao){         this(name ,age ,bangPai); //this 还可以调用当前类中的其他的构造方法        this.waihao =waihao;              }public static void main(String[] args) {      //余不群      DaXin dx1 =new DaXia(name:"岳不群",age: 18, bangPai: "华三派");      DaXin dx2 =new DaXia(name:"武松",age: 182, bangPai: "光明派")} }public class Test01 {     String name;     static String country = "大清"; //它是共享的. 存在一个内存中   只要修改了它的值  那么其他方法 使用时  都是共享一个数据的     String address;       public Test01(String name, String address){         this.name = name;         this.address =address;         }     public static void main(String[] args) {         Test01 p1 = new Test01("赵四","八大胡同");         Test01 p2 = new Test01("赵五", "曹阳们");         //大清亡了         p1.country = "民国";         System.out.println(p1.country);         System.out.println(p2.country);     } }//使用p1.country = "民国", 不推荐这样使用静态变量推荐使用类名去访问静态的内容特点:  1: 数据共享 2: 属于类的,并不属于对象 3,优先于对象产生的 通用构造器,静态构造器创建对象的过程  1: 静态构造器  2: 通用构造器 3.构造方法 .> 创建对象由于创建对象的过程是在静态内容加载完成之后,在静态方法喝静态块里 不能使用this

static 静态方法:

 

 

　

 包和导包:

   包  ,其实本质上就是文件夹 

  在代码中需要些package 包名;

 导包:

    import 包+类     快捷键Alt+Enter

 

 

不需要导包:

   1: 在自己包里 比如同一个文件夹下

   2: java.lang 包下的所有内容都不需要导包

      String

      system.out println()

 

访问权限:

 1: public  公共的   所有人可以访问 

 2: default  包访问权限   在自己包内可以随意访问.

 3: private 私有的  只有 自己类里面  可以访问

 

getter 和 setter

成员变量一般试用private来声明,保护成员变量不被胡乱的赋值

所以  :

    setter :  主要是给成员变量赋值  做一定的保护    比如  规定的是age 没有-1  可以在setter  里面进行个判断  然后  给到  类里面的  变量   this.age  =  age

    getter :  从成员变量中获取数据

    每次写太麻烦    快捷方式  空白位置.>右键>genrate>getter and setter > 全选 > ok      

 

 

继承

继承:  子类可以自动拥有父类中除了私有内容外的其他所有内容.

当出现x 是一种 y 的时候  x 就可以继承y

黑熊怪是一种妖怪.

    public class 类 extends 父类{

   //   这里可以直接调用父类的方法跟属性     //私有的除外

}    

备注:   简化代码的开发   子类对父类进行了扩展

super()

1 :当子类继承父类之后   可以通过super.xxx  直接调用父类里面得属性 

2: 子类调用父类的时候   可以给super(传参),这里注意  java  默认是  当子类创建了对象 时  会先执行构造方法,然后  会先执行父类 也就是super  所以如果想给父类super传参的话  需要写在子类构造方法的最上面一行 

 

 方法的重写

  重写  子类对父类中提供的方法进行重新定义

  语法  子类和父类中的方法的声明完成一致   比如  写的方法   都一样  

  重写 又被称为方法的覆盖   就是 先找子类自己的定义方法   如果也想执行父类的方法  直接super().方法名即可

 

 多态

   多态 同一个对象拥有多种形态

   作用  把不同的数据类型进行统一  让程序具有超强的可扩展性   比如  猫 狗  统一为动物

小知识点:

  1: 把子类的对象赋值给父类的变量  >  向上转型

       缺点  屏蔽掉子类中特有的方法

2: 把父类的变量转化回子类的变量 >向下转型

   向下转型有可能有风险  java要求 必须写强制类型转换  

   (转换之后的数据类型)变量   其实 就是比如  Cat  c = (Cat)变量

 

final

final  定义的变量  一般为不可变变量   也相当于常量

1:被final 修饰的变量  不可改变   被final 修饰的方法 不可被重写  被final修饰的类 不可继承

 

 

 

抽象:

现实中不存在的东西

在java中:只声明.不实现

抽象方法,使用abstract 来修饰,不可以有方法体,直接用分号结束即可! 不用后面来个{}

抽象类:如果一个类中有抽象方法,这个类必须是一个抽象类

特点:

  1:抽象类不可以创建对象

   2: 抽象类的子类 必须重写父类中的抽象方法 否则 子类必须也是抽象类

  通过抽象类可以强制的要求子类中必须有哪些方法

 小知识点:抽象类中可以有正常的方法

 

接口

 

接口  特殊的抽象类 

 

 其实  接口  相当与  比如 你写个接口   里面定义了一些功能  然后交给抽象类,那么抽象类可以实现部分的功能,然后剩下的功能 可以让子类去完成  ....

 

 

 

成员变量的初始值

成员变量 默认是要先定义再复值得  ,比如  int  age  =10;  但是  如果创建对象,比如

在另一个类中  定义  int  age;  那么这时打印  会有默认值   一般都是0  与null 

Object

其实类上面 都会默认继承Object类   也就是基类 ,然后object 里面封装了一些可以直接使用的功能

 

1:   equals 和 ==

== 判断左右两端的数据是否一致==

equals:object 类提供的一个方法,用来判断两个对象是否相等

equals 可以自己重写   比如  写个类 类里写个equals  那么此时调用equals 是调用自己写的

==  判断两个值的内存地址 是否一致   

如果使用字符串进行判断   需要使用 equlas   这里是根据值的内容  去做比较的 

 

 

 

 

2:toString

toString()  对一个对象的字符串的表示形式

java 官方推荐你重写这个方法,默认的那个太丑了    

其实toString 就是比如 你返回的是个内存地址对象  但是想返回对象的值,可以return toString  相当于  python  Django 里面的return  __str__ 方法

 

instnceod关键字

判断  xxx对象是否时xxx类型的

 

 内存分析

 

 异常处理 

1:

-try .. catch

try{

     尝试执行的代码

}catch(Exception e){

   处理异常的代码

}finally{

   最终的.   //一般是收尾工作

}

 

2: throws 和 throw

throws 告诉外面,我要扔一个异常,所以调用者要捕捉该异常,

throw 真正的向抛出一个异常,就是自己的程序  如果觉得有异常 还是自己处理比较好

 

 3: 自定义异常

  直接继承Exception或者RuntimeException来实现自定义异常