Java面向对象1

Java面向对象1

OOP——面向对象

面向对象概念

面向过程：由上至下，顺序执行，线性思维，先考虑第一步做什么，第二步做什么…

属性+方法=类

分类思维：物以类聚，同一类别

问题复杂后，如建设楼：总设计师——负责地基的部门、负责钢筋的部分、负责粉刷的部门，每个内部还是面向过程

类似多人协作，整个系统需要多个部分完成（框架），而每个部分都由面向过程具体实现

本质：以类的方式组织代码，以对象的组织（封装）数据

抽象：如学生管理系统，把多个学生的共同点剥离抽取，抽出像的部分，即学号、性别、年龄等特性。

三大特性：

封装：将数据封装好，对外部提供接口，外部通过接口访问

继承：父类与子类，A类继承B类的所有东西

多态：同一个事物，执行相同的方法，可能有不同的形态

先有对象后有类：如一批人（对象）都在教书，则有了教师类；先有实际的，再有抽象的。

类是对象的模板

如Person类，创建不同的实际对象：人A，人B等，通过new关键字产生对象，按Person类为模板生成对象。

方法

静态方法：有static

动态方法：无static

方法的定义

package OOP;
//Demo1类
public class Demo1 {
    //main方法
    public static void main(String[] args) {

    }
    //public为公共的，所有人都可以访问
    
    /*
    修饰符   返回值类型  方法名(..){
        方法体
        return 返回值;
    }
     */
    
    public String sayHello(){
        return "Hello world";//return以为着方法的结束
    }
    public void hello(){
        return;
    }
    public int max(int a,int b){
        return a>b?a:b;//如果a>b，则返回a，否则返回b
    }
}

return意味着方法至此结束

方法名：注意规范，驼峰原则。

参数列表：（参数类型 参数名, …）

异常：

public void readFile(String File) throws IOException
{
    
}

方法的调用

调用静态方法：类名 . 方法名

Demo类中：say为静态方法

Demo.say();

调用非静态方法：需要先将此类实例化，创建实例对象

实例对象 . 方法名

Demo类中hi为非静态方法

Demo demo = new Demo();

demo.hi();

package OOP;
//学生类
public class Student {
    
    //静态方法
    public static void say(){
        System.out.println("学生说话了");
    }
    
    //非静态方法
    public void hi(){
        System.out.println("打招呼");
    }
}

package OOP;

public class Demo2 {
    public static void main(String[] args) {
        Student.say();//直接调用静态方法
        Student student = new Student();//创建实例对象
        student.hi();//通过实例对象调用非静态方法
    }
}
//输出：
学生说话了
打招呼

类的特殊情况：

public void a(){
    b();//可以这样写
}
public void b(){
    
}
=======================================
public static void a(){
    b();//可以这样写
}
public static void b(){
    
}
=======================================
public static void a(){
    b();//不可以这样写，会调用失败
}
public void b(){
    
}
//因为static的静态方法与类共同存在，定义了大的类后方法即加载完毕，而没有static的非静态方法与实际对象共同存在，需要定义实际对象后才可以加载。因此static的a方法比b存在的早，不可调用当前还未存在的b

即：静态方法只能调用静态方法，非静态方法可以调用静态方法

因静态方法存在的比非静态方法早

值传递与引用传递

package OOP;

public class Demo3 {
    public static void main(String[] args) {
        int f = Demo3.add(1,2);//1、2为实参
        System.out.println(f);
    }
    public static int add(int a,int b){
        return a+b;//a、b为形参
    }
}

值传递：

package OOP;

public class Demo3 {
    public static void main(String[] args) {
        int a =1;
        System.out.println(a);
        Demo3.change(a);
        System.out.println(a);
    }
    public static void change(int a){
        a = 5;//改变的是形参的值，对外面实参没影响，因为没有return，这里改成b来描述更容易理解
        return;
    }
}//输出为
1
1      //而非5

方法中未return值的话，型参的值只在方法中被改变，但并不影响main方法中对应实参的值。java为值传递

方法对实际对象的属性的引用，类似于指针，会改变值，为引用传递

package OOP;

public class Demo4 {
    public static void main(String[] args) {
        int a = 1;
        Person person = new Person();
        System.out.println(person.name);//null
        Demo4.change(person);
        System.out.println(person.name);//szc
    }
    
    public static void change(Person person){
        //这里的person是一个实际对象，person指向Person person = new Person();即：这是一个具体的人，可以改变其属性
        //方法对对象属性的引用，类似于指针，会改变值，为引用传递
        person.name = "szc";
    }
}


//定义了一个Person类
class Person{
    String name;//有一个属性，name
}


输出：
null
szc