Java培训学习 --面向对象

我系大坤坤呐

已于 2022-07-17 22:53:51 修改

阅读量334

点赞数

文章标签： java

于 2022-07-14 00:08:49 首次发布

本文链接：https://blog.csdn.net/weixin_63108463/article/details/125770914

版权

概念知识

2.特殊值

0 0.0 -0.0 -无穷大无穷大 NaN

int i=0；

double a1=-0.0; //不管是 0、0.0 -0.0 双等号比较就是比较数值大小

double a2=+0.0;

a1=1/0.0； //结果为Infinity

a1=1/-0.0； //结果为-Infinity

a1=0/0.0 //结果为NaN

3.取整

Math.ceil 向上取整得到的是double类型

Math.floor 向下取整得到的结果是double类型

Math.round 四舍五入取整如果传入double 返回long类型

如果传入float 返回值为int

加0.5向下取整

4.可变参数

约束1：数量可变类型不能变

约束2：一个方法中最多只有一个可变参数，并且可变参数必须放在参数列表最后

static void method( int ...a){                    //定义一个方法
}

static void method(  int ...a，int i){           //语法错误
}

可变参数的使用：

static void method (double...i){
  System.out.println(i.length);
    System.out.println(i[0]);
}

2.面向对象

1.类：用来描述具有相同特征（属性）和相同行为（方法）的对象

Java中用 class关键字来描述类；

2.定义类：就是定义类中的成员，成员变量和成员方法。

成员变量：和之前变量的一样，成员变量位于类中，任何方法之外。

成员方法：把static关键字去除掉，没有加就是每个对象所具有的行为。

对象：

对象Object是构成系统的一个基本单位；

创建对象：

类名对象名= new 类名（）；

使用对象：

对象名.成员变量

调用成员方法：

对象名，方法名（参数列表）；

先定义类，才能实例化对象

在本类中可以直接调用本类中声明的属性

2.变量的作用域

全局变量（成员变量）：

定义在方法的外部，类的内部，使用范围是整个类中
不需要初始化
存储在堆内存中，（对象存在时才存在）

局部变量（方法中的变量）：

定义在方法的内部或者某一个语句块的内部，适用范围限于方法内或语句块中
必须初始化
存储在堆内存中

3.this变量

存在就近原则

在方法中调用类中属性name，就要用到this标注使用的属性变量

class Person{
   String name;
   String sex;
   int age;

void eat(){

String name="aaa"; //方法中也声明一个name

System.out.println(this.name+"正在吃饭"); //this标注使用的属性变量

}
}

成员方法：

语法

访问修饰符返回值类型方法名称（参数列表）{

方法体

}

访问权限修饰符：public protected dafault private
返回值类型由返回值决定
成员变量可以直接在成员方法中使用，但是main方法中如果调用成员变量和方法必须通过对象.属性名\方法名给（参数列表）的形式来调用
成员方法之间的调用，直接写方法名（参数列表）即可

1.public 公共的

public修饰类的时候注意点：

1.在类文件中只能有一个public类，并且这个类必须和文件名一致.

2.main方法必须写在public类中.

2.private 私有的

只能在自身类中访问到

3 default 本包下的

在类当中是不可以写 default 默认也不可可以写

本包下的类默认可以访问本包下所有的类。

default 的访问范围是本包下的出了包就访问不到

引入包.import. 包名.类名

为什么要引入包：

本类下默认使用本包下的所有的类。

经常使用包下的类

import. 包名。*

如果一个类中要使用两个重名的类型，需要使用类的全名来标注；

例：com.easy1.Easy1 ee=new com.easy.Easy1();

所有的类默认引入Java.lang包

Java.lang包声明了最常用最基础的东西，不需要我们引入

4.protected 受保护的

不在本包下，并且没有继承关系，就访问不到

本包下除了private 都可以访问

不同包下 default 访问不到

2.3面向对象的特征

封装：属性私有化并且提供公共的访问方法

private int size=0;//封装起来
   private int [] value=new int[16];//封装起来
   //提供一种方法来读取数据
   public int size(){
       return this.size;
   }

并不是所有的封装都需要 getter/setter

继承：

程序中的继承性是指子类拥有父类的全部特征和行为，这是类之间的一种关系

继承的特点：

继承要有一定的层次结构，还有具有一定的可传递性

子类继承了父类的所有方法和属性，但不包括私有属性和构造方法

子类也可以有自己的属性和方法

Java只支持单继承，也就是说一个子类只能有一个父亲，父类可以有多个子类

继承可见减少代码重复，提高了复用性和维护性
继承让类于类之间产生了关系，类的耦合型增加了，父类发生变化子类也会跟着变化。

//子类继承父类（）

public static void main(String[] args){

B b=new B();

System.out.println(b.surname);

b.test();//子类继承父类，子类就具有了父类中定义好可继承的属性和方法

}

class A{

String surname;

void test(){}

}

class B extends A{

}

继承中的构造方法：

格式：

访问修饰符方法名称（参数列表）{

方法体

}//构造方法没有返回值类型，构造方法名和类名必须一致。

创建有继承关系的子类对象时，会执行父类中默认的构造方法，然后执行子类中相关的构造方法。

作用：初始化对象

每个类，系统会自动提供一个无参构造方法

public class Dkk {
String name;


public Demo(String name){

this.name=name;

 }//构造方法

public static void main(String[] args){
Demo demo=new Demo();//这时就会报错，一旦定义了构造方法，
                      //系统默认的构造方法就会不存在

}

}

super关键字：

表示当前类的父类的调用
只能出现在有继承关系的子类中
super两种用法：

1. super.属性名、super.方法名（参数列表）

表示父类的属性和方法，和子类中属性或方法重名时使用

2.super（参数列表）

子类继承父类子类在执行构造方法的时候第一行默认是调用

父类的构造方法（系统自带）父类没有无参构造方法，子类必须定义构造方法

即子类的第一行必须调用父类的无参构造方法

Son(){

super("");

}

方法的重载：方法名一样，参数列表不一样

在一个类中方法名一样即为重载（不管返回值是否一致）
public String test（ int a，double b）{ return"";}
public void test（ int a）{ return"";}

只能通过参数列表来区分：参数类型、参数数量、参数顺序

方法的重写

定义：子类对父类中继承过来的方法进行重新定义

当父类中的方法无法满足子类的需求，子类可以对该方法进行重写
必须和父类的方法名，返回值，参数列表完全相同，并且访问修饰符的范围不能变小

@Override对是否重写进行注解

多态：

把父类对象指向子类对象的引用，就是把子类对象当作父类对象来使用
他可以调用父类中所有的成员属性和方法，（但不能在调用子类自己的属性和方法）
如果子类中有重写了父类的方法，那么执行这个方法时一定执行子类的重写方法

向上转型

多态本身就是子类类型像父类类型向上转型的过程
将子类对象转换为父类对象就是向上转型（自动转换）

父类类型对象名=new 子类类型（）；

可以使用更高级的指针指向子类的对象；
向上转型的对象可以调用父类中所有的普通方法和成员变量，但是只能调用子类中重写的方法

public void test（）{

Son s=new Son();

//向上转型

Parent p=new Son();

p=new Son2();//Parent的另一个子类

}

public void demo（Parent p）{

p.test();//向上转型调用父类中的方法

}

public static void main(String[] args){

Parent p=new Parent();

demo(p);

}