面向对象
什么是面向对象？面向对象与面向过程的区别是什么？
什么是面向对象？
面向对象，就是数据和数据的操作放到一个整体----对象，通过对象来实现某些操作
面向对象与面向过程的区别是什么？
面向过程是一步一步实现方法，从来实现某些操作。
它们两者自己的区别可以用一个大象放冰箱的例子。
对于面向过程来说：
第一步：需要打开冰箱
第二步：人推大象进冰箱
第三步：关闭冰箱
对于面向对象来说：
大象作为一个对象（大象有走进冰箱方法）
冰箱作为一个对象（冰箱有打开和关闭方法）
从这里可以看出，每个对象是独立的，都拥有他自己的功能，我们只需要专注于写每个对象的功能，
这样的模型更加适合人类的思维，想实现什么功能，直接生成对象调用对象的方法即可。
类和对象
类和对象的概述：
类：是一中抽象的概念，它是多种事物中的一种共性，比如：人这个类，汽车这个类，它们都只是概念
对象：是一个个独特的个体，它们都拥有自己独特的属性，方法
类与对象的区别：
类是对象的抽象概念，而对象是类的具体实现，所以类本身是不占用内存空间，而对象是一个具体的事物需要占用内存空间。
在开发中，只有先创建类，才可以实现对象。
类语法的定义：
[权限修饰符---public] class 类名{
//类中成员
//属性----变量
//行为----方法
}
代码：
1 public class Car {
2 //声明姓名属性
3 String name;
4 //声明年龄
5 int age;
6
7 //行为方法
8 public void show(){
9 System.out.println("这是一个show()方法");
10 }
11 }
对象语法的定义：
类名 对象 = new 类名();
如何通过对象调用属性或方法：
//这样可以访问属性，也可以给属性赋值 对象名.属性 //调用方法 对象名.方法名(形参列表)
代码展示：
1 public class Test {
2 public static void main(String[] args) {
3 Car car=new Car();
4 //给属性赋值
5 car.name="宝马";
6 car.age=2;
7 //调用方法
8 car.show();
9 }
10 }
封装
面向对象(oop)中三大特点封装、继承、多态
封装是对信息的隐藏，将类中的信息封装起来，只提供部分的方法给外部使用，这样可以提高类的安全性。
举个例子：
1 public class Test {
2 public static void main(String[] args) {
3 Car car=new Car();
4 //给属性赋值
5 car.name="宝马";
6 //如果没有封装，外界可以直接赋一些不合理的值如：
7 //车龄怎么可能是-2，这个明显不太合理
8 car.age=-2;
9 //调用方法
10 car.show();
11 }
12 }
所以想让外界不能直接调用属性，这时需要使用private关键字。
例子：
Car类
1 public class Car {
2 //声明姓名属性
3 private String name;
4 //声明年龄
5 private int age;
6
7 //行为方法
8 public void show(){
9 System.out.println("这是一个show()方法");
10 }
11 }
Test类
1 public class Test {
2 public static void main(String[] args) {
3 Car car=new Car();
4 //给属性赋值
5 // car.name="宝马"; 此时直接调用会报错
6 // car.age=-2; 此时直接调用会报错
7 //调用方法
8 car.show();
9 }
10 }
但是我们要如何去给这些属性赋值，或如何调用访问这些属性呢？
就需要用到get/set方法的使用。
1 public class Car {
2 //声明姓名属性
3 private String name;
4 //声明年龄
5 private int age;
6
7 //行为方法
8 public void show(){
9 System.out.println("这是一个show()方法");
10 }
11 //getName方法获取name属性
12 public String getName() {
13 return name;
14 }
15 //setName方法设置name属性
16 public void setName(String name) {
17 this.name = name;
18 }
19 //getAge方法获取age属性
20 public int getAge() {
21 return age;
22 }
23 //setAge方法设置车龄
24 public void setAge(int age) {
25 this.age = age;
26 }
27 }
Test类
1 public class Test {
2 public static void main(String[] args) {
3 Car car=new Car();
4 //给属性赋值
5 car.setAge(2);
6 car.setName("宝马");
7 car.show();
8 }
9 }
this关键字
每个类都有一个内置类对象-----this
使用场景：
1 public class Car {
2 //声明姓名属性
3 private String name;
4 //声明年龄
5 private int age;
6 public void show(){
7 System.out.println(name+"的车龄："+age);
8 }
9 //setName方法设置name属性，但是形参名与属性名一致时
10 public void setName(String name) {
11 name = name;
12 }
13 //setAge方法设置车龄，但是形参名与属性名一致时
14 public void setAge(int age) {
15 age = age;
16 }
17 }
Test类：
1 public class Test {
2 public static void main(String[] args) {
3 Car car=new Car();
4 //给属性赋值
5 car.setAge(2);
6 car.setName("宝马");
7 car.show();
8 }
9 }
效果展示：
我明明通过set方法来设置车名和车龄了，为什么会展示默认值呢？
这里类里面的形参名与属性名一致，对于变量会存在就近原则，第一个name会认为是形参那个name
所以name=name最终并没有将形参内容赋值给属性，此时就需要用到this关键字。
解决方法：
1 public class Car {
2 //声明姓名属性
3 private String name;
4 //声明年龄
5 private int age;
6 public void show(){
7 System.out.println(name+"的车龄："+age);
8 }
9 //setName方法设置name属性，但是形参名与属性名一致时
10 public void setName(String name) {
11 //使用this.属性名这样就可以选中类中的属性就可以进行真正的赋值操作
12 this.name = name;
13 }
14 //setAge方法设置车龄，但是形参名与属性名一致时
15 public void setAge(int age) {
16 //使用this.属性名这样就可以选中类中的属性就可以进行真正的赋值操作
17 this.age = age;
18 }
19 }
构造方法
构造方法是用来创建对象时所调用的方法，用于对象的实例化，对于有参构造方法可以在传入参数的同时对类成员的属性进行赋值。
它与其他普通的方法有所不同。
①方法名要与类名一致
②构造方法不能有返回类型
③如果没有显示的创建构造方法，jvm会自动提供一个无参的构造方法，如果创建构造方法后，jvm将不再提供无参的构造方法。
语法：
//这里的类名为Person
public class Person{
修饰符 Person(形参列表){
//代码内容；
}
}
举个例子：
Person类：
1 //Person类
2 public class Person {
3 private String name;
4 private int age;
5 //实现一个无参构造方法，类名要与方法名一致，无返回类型
6 public Person(){
7
8 }
9 //实现一个有参构造方法
10 public Person(String name,int age){
11 this.name=name;
12 this.age=age;
13 }
14 public void show(){
15 System.out.println("我叫:"+name+"今年"+age);
16 }
17 public String getName() {
18 return name;
19 }
20
21 public void setName(String name) {
22 this.name = name;
23 }
24
25 public int getAge() {
26 return age;
27 }
28
29 public void setAge(int age) {
30 this.age = age;
31 }
32 }
Test测试类：
1 //Test测试类
2 public class Test {
3 public static void main(String[] args) {
4 //通过无参构造方法实例化一个对象
5 Person student=new Person();
6 student.setName("张三");
7 student.setAge(18);
8 //并调用show()方法
9 student.show();
10 //通过有参构造方法实例化一个对象
11 Person teacher=new Person("李四",27);
12 //并调用show()方法
13 teacher.show();
14 }
15 }
效果展示：
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开始）
1 public class Test {
2 public static void main(String[] args) {
3 String str="Hello world";
4 char c = str.charAt(6);
5 System.out.println(c);
6 }
7 }
②boolean contains(String s)：判断s是否包含在字符串中
1 public class Test {
2 public static void main(String[] args) {
3 String str="Hello world";
4 boolean b = str.contains("worlds");
5 System.out.println("是否包含指定字符串:"+b);
6 }
7 }
③boolean endsWith(String suffix)：判断字符串是否以suffix结尾
1 public class Test {
2 public static void main(String[] args) {
3 String str="Hello world";
4 boolean b = str.endsWith("world");
5 System.out.println("判断是否以指定的字符串结尾:"+b);
6 }
7 }
④boolean equals(Object anObject)：判断字符串与anObject的值是否相等
1 public class Test {
2 public static void main(String[] args) {
3 String str="Hello world";
4 String s="Hello world";
5 boolean equals = str.equals(s);
6 System.out.println("两个字符串是否相同:"+equals);
7 }
8 }
⑤int indexOf(String str)：查找字符串str第一次出现的索引位置，如果没找到返回-1
1 public class Test {
2 public static void main(String[] args) {
3 String str="Hello world";
4 int i = str.indexOf("wo");
5 System.out.println("第一次出现的位置:"+i);
6 }
7 }
⑥int lastIndexOf(String str)：查找字符串str最后一次出现的索引位置，如果没找到返回-1
1 public class Test {
2 public static void main(String[] args) {
3 String str="Hello world";
4 int i = str.lastIndexOf("wo");
5 System.out.println("最后一次出现的位置:"+i);
6 }
7 }
⑦int length()：获取字符串的长度，注意这是一个方法，不要与数组搞混了。
1 public class Test {
2 public static void main(String[] args) {
3 String str="Hello world";
4 int a = str.length();
5 System.out.println("字符串的长度:"+a);
6 }
7 }
⑧String replace(String oldChar, String newChar)：将newChar替换oldChar，并重新返回一个字符串
1 public class Test {
2 public static void main(String[] args) {
3 String str="[Hello world world]";
4 String newStr = str.replace("[", "(").replace("]", ")");
5 System.out.println(newStr);
6 }
7 }
⑨String[] split(String regex)：按照regex来分割字符串，并保存到数组中返回
1 public class Test {
2 public static void main(String[] args) {
3 String str="Hello world world";
4 String[] s = str.split(" ");
5
6 for (String s1 : s) {
7 System.out.println(s1);
8 }
9 }
10 }
⑩boolean startsWith(String prefix)：判断字符串是否以prefix开头
1 public class Test {
2 public static void main(String[] args) {
3 String str="Hello world world]";
4 boolean b = str.startsWith("Hello");
5 System.out.println("是否以指定字符串开头:"+b);
6 }
7 }
⑪String substring(int beginIndex)：在指定位置截取字符串
1 public class Test {
2 public static void main(String[] args) {
3 String str="Helloworld world]";
4 String substring = str.substring(3);
5 System.out.println(substring);
6 }
7 }
⑫String toUpperCase()：将小写字母转成大写字母
1 public class Test {
2 public static void main(String[] args) {
3 String str="Helloworld world]";
4 String s = str.toUpperCase();
5 System.out.println(s);
6 }
7 }
⑬String toLowerCase() :把字符串转化为小写
1 public class Test {
2 public static void main(String[] args) {
3 String str="Helloworld world]";
4 String s = str.toLowerCase();
5 System.out.println(s);
6 }
7 }
⑭String trim()：将字符串的前后空格删除
1 public class Test {
2 public static void main(String[] args) {
3 String str=" Helloworld world] ";
4 String trim = str.trim();
5 System.out.println(trim);
6 }
7 }
标签：Java,String,void,基础,面向对象,str,age,public,name From： https://www.cnblogs.com/gzyhrc/p/17801307.html