JAVA复习3（类与对象）

JAVA复习3（类与对象）

面向对象语言三大特性

封装性、继承、多态

类

类的声明

class Stdent{
	类体
}

类的命名规则一般为单个单词或则几个单词的复合，一般每个单词首字母大写（驼峰命名法）

类体

声明变量

class Stdent{
	String name;//名字
	int age;//年龄
}

声明方法

class Stdent{
	void tell{
		System.out.println("大家好！");
	}
}

变量

成员变量

类中声明变量部分声明的变量称之为成员变量或域变量

成员变量的类型可以是java中的任何一种数据类型，包括基本数据类型和引用数据类型

成员变量有默认值

成员变量的有效范围在整个类中都有效，与再类中书写的前后位置无关

package com.company;/**
 * @Author FuGwaaa
 * @Date 2021/2/24 11:52
 * @Version 1.0
 */
class Stdent{
    Stdent(String name,int age){
        this.name = name;
        this.age = age;
    }
    Stdent(){

    }
    void tell(){
        System.out.println("大家好！我是"+age+"岁的"+name);
    }
    String name;//名字
    int age;//年龄
}
public class demo13 {
    public static void main(String[] args) {
        Stdent stdent = new Stdent("张三",18);
        stdent.tell();
    }
}

运行结果：

大家好！我是18岁的张三

局部变量

在方法体中声明的变量和方法的参数称作局部变量

如果局部变量的名字与成员变量名字相同，在方法内就隐藏了成员变量，如果在方法中想使用成员变量则要用到this关键字

局部变量没有默认值

需要注意的问题

在类中不能操作变量，变量只能在方法中进行操作

public class Demo14 {
    int a;
    int b;
    a=12;//赋值失败，只能在方法中出现，会出现编译错误
    b=1;
}

构造方法

• 在创建对象时使用它的构造方法
• 构造方法的名字与类名完全相同
• 没有返回值类型
• 一个类中可以有多个构造方法，但要保证参数不同
• 如果类中没有构造方法时，系统会默认只有一个无参的构造方法，且方法内没有语句
• 如果有构造方法时，系统则不默认提供无参的构造方法

class Point{
	int x,y;
	//无参构造方法
	Piont(){
	}
	//有参构造方法
	Piont(int x,int y){
        this.x = x;
        this.y = y;
	}
	//有返回值不是构造方法,一般方法首字母小写
	int Point(){
		return 12;
	}
}

对象

声明对象

Stdent stdent;

实例化对象

stdent = new Stdent();

操作对象

当一个实例化对象产生之后，可以按照如下的方式进行类的操作：
对象.属性：表示调用类之中的属性；
对象.方法()：表示调用类之中的方法。

内存空间中对象的实例化及操作

我们从内存的角度分析。首先，给出两种内存空间的概念：
（1）堆内存：保存对象的属性内容。堆内存需要用new关键字来分配空间。
（2）栈内存：保存的是堆内存的地址。

任何情况下，只要看见关键字new，都表示要分配新的堆内存空间，一旦堆内存空间分配了，里面就会有类中定义的属性，并且属性内容都是其对应数据类型的默认值。

如图：

注意：：图中有个小错误，此处给字符串类型的变量赋值时应该为双引号"",而不是单引号’’;

如果没有进行实例化对象直接开始操作，则会报空指针异常NullPointerException

package com.company;

/**
 * @Author FuGwaaa
 * @Date 2021/2/22 16:14
 * @Version 1.0
 */
class Student{
    float height;//身高
    String gender;//性别
    String name;//名字
    String getName(){
        return name;
    }
}
public class Demo12 {
    public static void main(String[] args) {
        Student student = null;
        //student = new Student();不实例化时
        student.gender="男";
        student.gender="张三";
        student.getName();
    }
}

运行结果

Exception in thread "main" java.lang.NullPointerException
	at com.company.demo12.main(demo12.java:20)

此时student地址只想的是一个null，空的对象引用类的方法，造成了空指针异常。

对象引用传递

package com.company;

/**
 * @Author FuGwaaa
 * @Date 2021/2/22 16:14
 * @Version 1.0
 */
class Student{
    String name;//名字
    int age;//年龄
    Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    Student(){

    }
    void say(){
        System.out.println("我是"+name+age+"岁了");
    }
}
public class Demo12 {
    public static void main(String[] args) {
        Student s1 = null;
        s1 = new Student("张三",18);
        Student s2 = s1;
        s2.name = "李四";
        s2.say();
        s1.say();

    }
}

运行结果

我是李四18岁了
我是李四18岁了

如图

还有一种情况

package com.company;

/**
 * @Author FuGwaaa
 * @Date 2021/2/22 16:14
 * @Version 1.0
 */
class Student{
    String name;//名字
    int age;//年龄
    Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    Student(){

    }
    void say(){
        System.out.println("我是"+name+age+"岁了");
    }
}
public class Demo12 {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
        s1.name= "张三";
        s1.age = 18;
        s2.name = "李四";
        s2.age = 22;
        s2 = s1;
        s2.name = "王五";
        s2.say();
        s1.say();
    }
}

运行结果

我是王五18岁了
我是王五18岁了

如图

垃圾：指的是在程序开发之中没有任何对象所指向的一块堆内存空间，这块空间就成为垃圾，所有的垃圾将等待GC（垃圾收集器）不定期的进行回收与空间的释放。

可变参数

不确定参数的个数时用...来表示可变参数

package com.company;

/**
 * @Author FuGwaaa
 * @Date 2021/2/24 16:32
 * @Version 1.0
 */
public class Demo14 {
    public int getSum(int ... x){
        int sum = 0;
        for (int i : x) {
            sum += i;
        }
        return sum;
    }
}

实例成员与类成员

实例变量和类变量的区别

1. 不同对象的实力变量不同
2. 所有对象共享类变量
3. 通过类名直接访问类变量
4. static为类变量的关键字，放在变量类型前

实例方法和类方法

1. 对象调用实例方法
2. 类名调用类方法
3. static放在返回值类型前为类方法

类方法的设计原则：如果一个方法不需要操作类中的任何实例变量，则可以设计为static类方法

方法重载

重载（Overload）属于多态中的一种，另一种是重写（Override）

定义：一个类中可以有多个方法名字相同，但是这些方法的参数必须不同。

例子如下：

Circle.java

public class Circle {
    double radius,area;
    void setRadius(double r){
        radius = r;
    }
    double getArea(){
        area = 3.14*radius*radius;
        return area;
    }
}

TiXing.java

public class TiXing {
    double above,bottom,height;
    TiXing(double a,double b,double h){
        above = a;
        bottom = b;
        height = h;
    }
    double getArea(){
        return (above+bottom)*height/2;
    }
}

Student.java

public class S {
    double ComputerArea(Circle circle){
        double area = circle.getArea();
        return area;
    }
    double ComputerArea(TiXing tiXing){
        double area = tiXing.getArea();
        return area;
    }
}

this关键字

在构造方法中使用this

this出现在构造方法中时，代表使用该构造方法创建的对象。

在实例方法中使用this

this出现在实例方法中时，代表正在调用该方法的实例对象。

类方法中不能出现this

因为类方法通过类名调用，此时可能还没有创建任何对象。

访问权限

1. private: Java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。被其修饰的属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。
2. default：即不加任何访问修饰符，通常称为“默认访问权限“或者“包访问权限”。该模式下，只允许在同一个包中进行访问。
3. protected: 介于public 和 private 之间的一种访问修饰符，一般称之为“保护访问权限”。被其修饰的属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。
4. public： Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包访问。

权限	类内	同包	不同包子类	不同包非子类
private	√	×	×	×
default	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

类在不同的包中也可以访问。
4. public： Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包访问。

权限	类内	同包	不同包子类	不同包非子类
private	√	×	×	×
default	√	√	×	×
protected	√	√	√	×
public	√	√	√	√