java面向对象

java面向对象编程

• Java类及类的成员

• 面向对象的三大特征

• 其它关键字

1.类的写法（属性(变量)、行为(方法)）

public class Person{
    //属性（成员变量），类的成员可以先声明，不用初始化
    String name;//String的默认值是null
    int age;//int的默认值是0
    //行为、方法，也叫函数
    public void showName(){//方法的名称如果是多个单词，首单词的首字母小写，其他单词的首字母大写，这种方法叫做驼峰法
        System.out.println("姓名:"+name);
    }
    public int getAge(){//如果是一个有返回值的方法，方法体的最后一行一定是返回相应的数据
        return age;
    }
}
​
public class Animal{
    String name;
    int eye;
    int legs;
    public void eat(String food){//food 是形参，可以有多个，用逗号分隔
        System.out.println("此种动物的食物是："+food);
    }
    public void move(String moveType){
        System.out.println("此种动物的移动方式是："+moveType);
    }
}

2.类的创建和使用

//实例化Person类，也就是创建Person对象
public static void main(String[] args){
    Person person = new person();//声明一个Person类型的变量
    //new person()就是实例化Person类
    person.name = "张三";//String类型，给person对象的name类赋值
    person.showName();
    person.age = 21;//person对象的age类赋值
    System.out.println(person.getAge());
}
​
//实例化Animal类
public static void main(String[] args){
    Animal ani = new Animal();//实例化Animal对象
    ani.eat("老鼠");//String类型对应双引号
    ani.move("飞");
}

3.类的属性

• 语法格式：

  • 修饰符(public、private) 类型 属性名=初值；（private int x;）

  • 修饰符说明：

    • private：该属性只能在当前自己的类中使用，同一个包中的其他类无法访问

    • public：该属性可以被该类以外的方法访问

• 属性（变量）：

  • 成员变量 写在类中的变量是实例变量

    • 实例变量（不以static修饰）

    • 类变量（以static修饰）//static：静态的

    //实例变量
    public String name = "zhangsan";
    private int age;//实例变量就是在类实例化成对象后才能使用
    ​
    //类变量
    public static String sex = "男";
    //类变量不需要类实例化成对象就可以使用，可以直接通过【类名.属性】的方式直接调用

  • 局部变量 写在方法中的变量是局部变量

    • 形参

    • 方法局部变量

    • 代码块局部变量

4.类的方法

同一个类中方法之间可以互相调用，但方法内不能再创建新的方法。

public void eat(String food,int need){//参数可以有多个，中间用逗号分隔
    System.out.println("此种动物的食物是："+food);
}

5.关于对象

//匿名对象。只使用一次
Student stu = new Student();
stu.showInfo();
//上述改成匿名对象是： new Student().showInfo();

6.方法的重载（overload）

重载的概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

//同一个类中，以下三种同名的方法并不冲突，以为它们的参数个数或者参数的类型不同
public int add(int x, int y){
    return x+y;
}
​
public double add(int x, double y){
    return x+y;
}
​
public int add(int x, int y, int z){
    return x+y;
}
​
//以下情况会造成冲突
public int add(int m, int n){
    return x+y;
}

7.方法的可变个数的参数

//方法类
public class person2 {
    /**
     * 用数组的方式来传递可变个数的参数
     * 如果没有参数，要定义一个空数组或者null    p2.printInfo(null);
     * @param a
     */
    public void printInfo(String[] a) {
        for(int i=0;i<a.length;i++) {
            System.out.println(a[i]);
        }
    }
​
    /**
     * 用Java特有的...的方式来传递可变个数的参数，这种参数与数组的使用方式相同
     * ...的方式如果没有参数可以不填    p2.printInfo();
     * 如果一个方法有多个形参，可变的参数（...这种参数）一定要放在所有参数的最后
     * public void printInfo1(int s, String... a)   这种对
     * public void printInfo1(String... a, int s)   这种错
     */
    public void printInfo1(String... a) {
        for(int i=0;i<a.length;i++) {
            System.out.println(a[i]);
        }
    }
}
​
//测试类
public class test2 {
    public static void main(String[] args) {
    person2 p2 = new person2();
    String[] a = new String[] {"zhangsan","11"};
    p2.printInfo(a);
​
    //String... 的方式
    p2.printInfo1("zhangsan","11");//可以直接传递 
    String[] a1 = new String[] {"zhangsan","11"};
    p2.printInfo1(a1);//也可以类似数组的方式传递
    }
}

8.方法的参数传递

方法只有被调用才有意义。

Java中方法的参数传递方式只有一种：值传递。

堆中存放的是引用对象的实体，栈中存放的是引用对象的地址。

基本数据类型在参数的传递过程中就是把实参的值复制值到形参上。

public class test{
    public static void swap(int i){//static 类型，可直接调用属性名.方法
        i = 6;
        System.out.println("swap方法里，i的值是" + i);
    }
    public static void main(String[] args){
        int a = 0;
        swap(a);//static
        System.out.println("main方法里，变量a的值是" + a);
    }
}
//输出结果：i的值为6，变量a的值是0

//方法类
public clss DataSwap{
    int a;
}
//测试类
public class test{
    public static void swap(DataSwap ds1){
        ds1.a = 6;
        System.out.println("在swap方法中，ds1.a的值是：" + ds1.a);
    }
    public static void main(String[] args){
        DataSwap ds = new DataSwap();
        System.out.println("调用swap方法之前，ds.a的值是：" + ds.a);
        swap(ds);
        System.out.println("调用swap方法之后，ds.a的值是：" + ds.a);
    }
}
//输出结果：调用swap方法之前，ds.a的值是：0
//        在swap方法中，ds1.a的值是：6
//        调用swap方法之后，ds.a的值是：6

方法的参数传递小结：

• 如果方法的形参是基本数据类型，那么实参（实际的数据）向形参传递参数时，就是直接传递值，把实参的值赋值给形参。

• 如果方法的形参是对象（String等数据类型），那么实参（实际的对象）向形参传递参数时，也是把值传递给形参，且这个值是实参在栈中的值，也就是引用对象在堆内存中的地址。

• 基本数据类型都是保存在栈内存中，引用对象在栈内存中保存的引用对象的地址，所以说方法的参数传递就是值的传递。

9.包package和引用import

java中的包package等同于文件夹的概念，包和文件夹一样可以有多级，也就是包下可以有包和文件，用“ . ”来指明包的层次。

当系统报错“无法区分在哪个包下的类方法”时，用import指出，具体表示为：

import 包名.类名;//同一个包下的类import可以省略，默认使用该包中的类名所包含的类方法

10.封装和隐藏

//方法类
public class Person3 {
//  public int age;
    private int age;//对变量age进行封装，也就是设限，避免出现不符合逻辑的情况
    public void printAge() {
        System.out.println("年龄是："+age);
    }
    public void setAge(int a) {
        if(a<=150 && a>=0) {
            age = a;//不要忘记将值赋给age
        }else {
            System.out.println("输入的年龄不在0到150之间");
        }
    }
}
//测试类
public class Test3 {
    public static void main(String[] args) {
    Person3 p = new Person3();
//  p.age = -100;//如果不设置private对变量进行封装，就会出现-100的年龄系统没有报错
    p.setAge(12);
    p.printAge();
    }
}

11.访问权限修饰符

修饰符	类内部	同一个包	子类	任何地方
private	yes
没有修饰符	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes(即使不在一个包下都能用)

注：

对于class的权限修饰只可以用public和default(缺省，就是不修饰)

• public类可以在任意地方被访问

• default只可以被同一个包内部的类访问

在同一个Java文件中可以写多个class，但是只有一个class能被public修饰，其他的class是缺省的

12.类的构造方法

new对象实际上就是调用类的构造方法

//方法类
public class person{
    public person(){
        //该方法可以设置初始属性
        //该方法类默认存在这样一个方法
    }
    ...
    public person(int m,int n){//也可以设置带参数的
        x = m;
        y = n;
    }
    int x; int y;
}
//测试类
public class test{
    person p = new person();//new对象实际上就是调用类的构造方法
}

13.this关键字

public class person{
    public person(int age, String name){
        this.age = age;//前面的this.age指的是person.age，后面的name指的是形参age
        this.name = name;//前面的this.name指的是person.name，后面的name指的是形参name
    }
    int age;
    String name;
    
    public void setName(String name){
        this.name = name;//将形参的name赋值给person.name，（等号赋值是右边赋值给左边）
        
        
        
    public person(){
        
    }   
    public person(int age){
        this();//等同于调用public person()
        this.name = name;
    }
    public person(int age,String name){
        this(1);//等同于调用public person(int age)
        this.age = age;
        this.name = name;
    }
    }
}
//使用this()必须放在构造器的首行
//使用this调用本类中其他构造器，保证至少有一个构造器是不用this的（不能出现构造器自己调用自己）

14.JavaBean（实体类）

//方法类
//一个javabean应有私有的属性、属性对应的get和set方法
public class person{
    private String name;
    private int sex;
    private int age;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    public void setSex(int sex){
        this.sex = sex;
    }
    public int getSex(){
        return this.sex;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getName(){
        return this.name;
    }
}
//测试类
public class test{
    public static void main(String[] args){
    person p = new person();
    p.setName("张三");
    p.setSex(0);
    p.setAge(21);
    
    System.out.println(p.getName());
    System.out.println(p.getSex());
    System.out.println(p.getAge());
    }
}

编写完private属性之后，鼠标右键source，选择Generate Getters and Setters自动生成get和set方法