首页 > 编程语言 >面向对象-java

面向对象-java

时间:2023-01-12 14:45:23浏览次数:39  
标签:java String color 子类 面向对象 int 父类 public

//
造车: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:"黑色") } }



//this
public 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: "光明派")
}
}


static 静态方法:

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

 

 


 

 

 包和导包:

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

  在代码中需要些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来实现自定义异常

标签:java,String,color,子类,面向对象,int,父类,public
From: https://www.cnblogs.com/ZhiXiaoBbai/p/17030454.html

相关文章