Java面向对象(一)

面向对象

什么是面向对象？面向对象与面向过程的区别是什么？

什么是面向对象？

面向对象，就是数据和数据的操作放到一个整体----对象，通过对象来实现某些操作

面向对象与面向过程的区别是什么？

面向过程是一步一步实现方法，从来实现某些操作。

它们两者自己的区别可以用一个大象放冰箱的例子。

 对于面向过程来说：

第一步：需要打开冰箱

第二步：人推大象进冰箱

第三步：关闭冰箱

对于面向对象来说：

大象作为一个对象（大象有走进冰箱方法）

冰箱作为一个对象（冰箱有打开和关闭方法）

从这里可以看出，每个对象是独立的，都拥有他自己的功能，我们只需要专注于写每个对象的功能，

这样的模型更加适合人类的思维，想实现什么功能，直接生成对象调用对象的方法即可。

类和对象

类和对象的概述：

类：是一中抽象的概念，它是多种事物中的一种共性，比如：人这个类，汽车这个类，它们都只是概念

对象：是一个个独特的个体，它们都拥有自己独特的属性，方法

类与对象的区别：

类是对象的抽象概念，而对象是类的具体实现，所以类本身是不占用内存空间，而对象是一个具体的事物需要占用内存空间。

在开发中，只有先创建类，才可以实现对象。

类语法的定义：

[权限修饰符---public]   class  类名{
        //类中成员  
        //属性----变量
        //行为----方法
}

代码：

public class Car {
    //声明姓名属性
    String name;
    //声明年龄
    int age;

    //行为方法
    public void show(){
        System.out.println("这是一个show()方法");
    }
}

对象语法的定义：

类名   对象 = new 类名();

如何通过对象调用属性或方法：

//这样可以访问属性，也可以给属性赋值
对象名.属性

//调用方法
对象名.方法名(形参列表)

代码展示：

public class Test {
    public static void main(String[] args) {
        Car car=new Car();
        //给属性赋值
        car.name="宝马";
        car.age=2;
        //调用方法
        car.show();
    }
}

封装

面向对象(oop)中三大特点封装、继承、多态

封装是对信息的隐藏，将类中的信息封装起来，只提供部分的方法给外部使用，这样可以提高类的安全性。

举个例子：

public class Test {
    public static void main(String[] args) {
        Car car=new Car();
        //给属性赋值
        car.name="宝马";
        //如果没有封装，外界可以直接赋一些不合理的值如：
        //车龄怎么可能是-2，这个明显不太合理
        car.age=-2;
        //调用方法
        car.show();
    }
}

所以想让外界不能直接调用属性，这时需要使用private关键字。

例子：

Car类

public class Car {
    //声明姓名属性
    private String name;
    //声明年龄
    private int age;

    //行为方法
    public void show(){
        System.out.println("这是一个show()方法");
    }
}

Test类

public class Test {
    public static void main(String[] args) {
        Car car=new Car();
        //给属性赋值
//        car.name="宝马";  此时直接调用会报错
//        car.age=-2;      此时直接调用会报错
        //调用方法
        car.show();
    }
}

但是我们要如何去给这些属性赋值，或如何调用访问这些属性呢？

就需要用到get/set方法的使用。

public class Car {
    //声明姓名属性
    private String name;
    //声明年龄
    private int age;

    //行为方法
    public void show(){
        System.out.println("这是一个show()方法");
    }
    //getName方法获取name属性
    public String getName() {
        return name;
    }
    //setName方法设置name属性
    public void setName(String name) {
        this.name = name;
    }
    //getAge方法获取age属性
    public int getAge() {
        return age;
    }
    //setAge方法设置车龄
    public void setAge(int age) {
        this.age = age;
    }
}

Test类

public class Test {
    public static void main(String[] args) {
        Car car=new Car();
        //给属性赋值
        car.setAge(2);
        car.setName("宝马");
        car.show();
    }
}

访问修饰符

封装的访问修饰符有四种，分别为public、protected、缺省、private

①public：公共的。整个工程项目都能访问。

②protected：受保护的。被本包以及不同包下的子类访问。

③默认：被本包访问。

④private：私有的。本类访问。

它们作用的范围从大到小：public > protected > 缺省 > private

范围如下：

this关键字

每个类都有一个内置类对象-----this

使用场景：

public class Car {
    //声明姓名属性
    private String name;
    //声明年龄
    private int age;
    public void show(){
        System.out.println(name+"的车龄："+age);
    }
    //setName方法设置name属性，但是形参名与属性名一致时
    public void setName(String name) {
        name = name;
    }
    //setAge方法设置车龄，但是形参名与属性名一致时
    public void setAge(int age) {
        age = age;
    }
}

Test类：

public class Test {
    public static void main(String[] args) {
        Car car=new Car();
        //给属性赋值
        car.setAge(2);
        car.setName("宝马");
        car.show();
    }
}

效果展示：

 我明明通过set方法来设置车名和车龄了，为什么会展示默认值呢？

 这里类里面的形参名与属性名一致，对于变量会存在就近原则，第一个name会认为是形参那个name

所以name=name最终并没有将形参内容赋值给属性，此时就需要用到this关键字。

解决方法：

public class Car {
    //声明姓名属性
    private String name;
    //声明年龄
    private int age;
    public void show(){
        System.out.println(name+"的车龄："+age);
    }
    //setName方法设置name属性，但是形参名与属性名一致时
    public void setName(String name) {
        //使用this.属性名这样就可以选中类中的属性就可以进行真正的赋值操作
        this.name = name;
    }
    //setAge方法设置车龄，但是形参名与属性名一致时
    public void setAge(int age) {
        //使用this.属性名这样就可以选中类中的属性就可以进行真正的赋值操作
        this.age = age;
    }
}

构造方法

 构造方法是用来创建对象时所调用的方法，用于对象的实例化，对于有参构造方法可以在传入参数的同时对类成员的属性进行赋值。

它与其他普通的方法有所不同。

①方法名要与类名一致
②构造方法不能有返回类型

③如果没有显示的创建构造方法，jvm会自动提供一个无参的构造方法，如果创建构造方法后，jvm将不再提供无参的构造方法。

语法：

//这里的类名为Person
public class Person{

   修饰符   Person(形参列表){
             //代码内容；

   }
}

举个例子：

Person类：

//Person类
public class Person {
    private String name;
    private int age;
    //实现一个无参构造方法，类名要与方法名一致，无返回类型
    public Person(){

    }
    //实现一个有参构造方法
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void show(){
        System.out.println("我叫:"+name+"今年"+age);
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Test测试类：

//Test测试类
public class Test {
    public static void main(String[] args) {
        //通过无参构造方法实例化一个对象
        Person student=new Person();
        student.setName("张三");
        student.setAge(18);
        //并调用show()方法
        student.show();
        //通过有参构造方法实例化一个对象
        Person teacher=new Person("李四",27);
        //并调用show()方法
        teacher.show();
    }
}

效果展示：

 String类

String类作为jdk种自带的一个类，它拥有许许多多的方法，提供程序员使用，这里我们将讲讲一些String类种常用的方法。

在学习使用String类方法之前我们还需要学习如何创建一个String类

方法一：直接给String类赋值

语法: 
String  字符串名  = "字符串"
String str ="qwe123rty";

方法二：使用new关键字实例化String类，并赋值

语法：
String   字符串名  = new   String("字符串");
String    str     = new   String("1quwie3ws");

String类常用的方法

①char charAt(int index)：通过字符串索引值index查找到对应的字符（索引值的0开始）

public class Test {
    public static void main(String[] args) {
        String str="Hello world";
        char c = str.charAt(6);
        System.out.println(c);
    }
}

②boolean contains(String s)：判断s是否包含在字符串中

public class Test {
    public static void main(String[] args) {
        String str="Hello world";
        boolean b = str.contains("worlds");
        System.out.println("是否包含指定字符串:"+b);
    }
}

③boolean endsWith(String suffix)：判断字符串是否以suffix结尾

public class Test {
    public static void main(String[] args) {
        String str="Hello world";
        boolean b = str.endsWith("world");
        System.out.println("判断是否以指定的字符串结尾:"+b);
    }
}

④boolean equals(Object anObject)：判断字符串与anObject的值是否相等

public class Test {
    public static void main(String[] args) {
        String str="Hello world";
        String s="Hello world";
        boolean equals = str.equals(s);
        System.out.println("两个字符串是否相同:"+equals);
    }
}

⑤int indexOf(String str)：查找字符串str第一次出现的索引位置，如果没找到返回-1

public class Test {
    public static void main(String[] args) {
        String str="Hello world";
        int i = str.indexOf("wo");
        System.out.println("第一次出现的位置:"+i);
    }
}

⑥int lastIndexOf(String str)：查找字符串str最后一次出现的索引位置，如果没找到返回-1

public class Test {
    public static void main(String[] args) {
        String str="Hello world";
        int i = str.lastIndexOf("wo");
        System.out.println("最后一次出现的位置:"+i);
    }
}

⑦int length()：获取字符串的长度，注意这是一个方法，不要与数组搞混了。

public class Test {
    public static void main(String[] args) {
        String str="Hello world";
        int a = str.length();
        System.out.println("字符串的长度:"+a);
    }
}

⑧String replace(String oldChar, String newChar)：将newChar替换oldChar，并重新返回一个字符串

public class Test {
    public static void main(String[] args) {
        String str="[Hello world world]";
        String newStr = str.replace("[", "(").replace("]", ")");
        System.out.println(newStr);
    }
}

⑨String[] split(String regex)：按照regex来分割字符串，并保存到数组中返回

public class Test {
    public static void main(String[] args) {
        String str="Hello world world";
        String[] s = str.split(" ");

        for (String s1 : s) {
            System.out.println(s1);
        }
    }
}

⑩boolean startsWith(String prefix)：判断字符串是否以prefix开头

public class Test {
    public static void main(String[] args) {
        String str="Hello world world]";
        boolean b = str.startsWith("Hello");
        System.out.println("是否以指定字符串开头:"+b);
    }
}

⑪String substring(int beginIndex)：在指定位置截取字符串

public class Test {
    public static void main(String[] args) {
        String str="Helloworld world]";
        String substring = str.substring(3);
        System.out.println(substring);
    }
}

⑫String toUpperCase()：将小写字母转成大写字母

public class Test {
    public static void main(String[] args) {
        String str="Helloworld world]";
        String s = str.toUpperCase();
        System.out.println(s);
    }
}

⑬String toLowerCase() :把字符串转化为小写

public class Test {
    public static void main(String[] args) {
        String str="Helloworld world]";
        String s = str.toLowerCase();
        System.out.println(s);
    }
}

⑭String trim()：将字符串的前后空格删除

public class Test {
    public static void main(String[] args) {
        String str="      Helloworld    world]     ";
        String trim = str.trim();
        System.out.println(trim);
    }
}