面向对象
什么是类？ 是对现实生活中一类具有共同属性和行为的事物的抽象。特点：1、类是对象的数据类型；2、类是具有相同属性和行为的一组对象的集合。
什么是对象的属性？ 对象具有的各种特征，每个对象的每个属性都拥有特定的值。
什么是对象的行为？ 对象能够执行的操作。
类的定义
类的组成：属性+行为
属性：在类中通过成员变量来体现（类中方法外的变量）
行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）
步骤：① 定义类
② 编写类的成员变量
③ 编写类的成员方法
public class 类名{
//成员变量
变量1的数据类型 变量1;
变量2的数据类型 变量2;
....
// 成员方法
方法1;
方法2;
....
}
对象的使用
创建对象
类名 对象名 = new 类名();
使用对象
对象名.变量名
下面来看一个简单的例子：
（类的定义）demo.java
public class demo {
// 定义类的成员变量
int a;
int b;
// 定义类的成员方法
public int sum_num1(){
return (a+b);
}
public int sum_num2(){
return (a-b);
}
}
hello.java
public class hello {
public static void main(String []args) {
// 创建对象
demo name = new demo();
// 使用对象
name.a=10;
name.b=20;
System.out.println(name.sum_num1());
}
}
运行结果：
成员变量：类中方法外的变量
局部变量：方法中的变量
封装
private 关键字：
① 是一个仅限修饰符
② 可以修饰成员（成员变量和成员方法）
③ 作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问
针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作：
① 提供"get变量名()"方法，用于获取成员变量的值，方法用public修饰；提供"set变量名(参数)"方法，用于设置成员变量的值，方法用public修饰
demo.java
public class demo {
String name;
private int age;
// 提供get/set方法
public void setage(int a){
age=a;
if(a<30){
System.out.println('n');
}else{
System.out.println('y');
}
}
public int getage(){
return age;
}
// 成员方法
public void show(){
System.out.println(name+" "+age);
}
}
hello.java
public class hello {
public static void main(String []args) {
demo n = new demo();
n.name="小明";
n.setage(20);
n.show();
}
}
结果：
n
小明 20
this关键字：
① 修饰的变量用于指代成员变量：方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量；方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量
② 什么时候使用this？解决局部变量隐藏成员变量
demo.java
public class demo {
String name;
private int age;
// 提供get/set方法
public void setage(int age){
this.age=age;
if(age<30){
System.out.println('n');
}else{
System.out.println('y');
}
}
public int getage(){
return age;
}
// 成员方法
public void show(){
System.out.println(name+" "+age);
}
}
hello.java
public class hello {
public static void main(String []args) {
demo n = new demo();
n.name="小明";
n.setage(20);
n.show();
}
}
封装：
1、概述：是面向对象三大特征之一（封装，继承，多态）；是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的
2、原则：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过类提供方法来实现对隐藏信息的操作和访问成员变脸private，提供对应的getname()/setname()方法
3、优点：通过方法来控制成员变量的操作，提高了代码的安全性，把代码用方法进行封装，提高了代码的复用性
构造方法（进行对象初始化）
public class 类名{
修饰符 类名(参数){
}
}
注意：① 构造方法的创建：如果没有定义构造方法，系统将给出一个默认的无参数构造方法；如果定义了构造方法，系统将不再提供默认的构造方法
② 构造方法的重载：如果自定义了带参数构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法
标准类制作：
① 成员变量用private修饰
② 构造方法：提供一个无参构造方法；提供一个带多个参数的构造方法
③ 成员方法：提供每一个成员变量对应的setname()/getname()；提供一个显示对象信息的show()
④ 创建对象并为其成员变量赋值的两种方式
：无参构造方法创建对象后使用setname()赋值；使用带参构造方法直接创建带有属性值的对象
String
java自带，在使用时不需要导包。String类代表字符串，字符串不可变，值在创建后不能被更改，但是可以被共享
构造方法：
① public String[] 创建一个空白字符串对象，不含有任何内容
② public String(char[] chs) 根据字符数组的内容，来创建字符串对象
③ public Sring(byte[] bys) 根据字节数组的内容，来创建字符串对象
④ String a='abc' 直接赋值的方式创建字符串对象，内容就是abc
public class hello {
public static void main(String []args){
//public String[]创建一个空白字符串对象，不含有任何内容
String t = new String();
System.out.println("为："+t);
//public String(char[] chs)` 根据字符数组的内容，来创建字符串对象
char[] cha = {'a','b','c'};
String t2 = new String(cha);
System.out.println("为："+t2);
// public Sring(byte[] bys)` 根据字节数组的内容，来创建字符串对象
byte[] bys = {65,66,67};
String t3 = new String(bys);
System.out.println("为："+t3);
// String a='abc'` 直接赋值的方式创建字符串对象，内容就是abc
String t4 = "yhx";
System.out.println("为："+t4);
}
}
字符串的比较：
使用“==”做比较
基本类型：比较的是数据值是否相同
引用类型：比较的是地址值是否相同
字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫做：equals。public boolean equals(Object anObject) 将字符串与指定对象进行比较，由于我们比较的是字符串对象，所以参数直接传递一个字符串
public class hello {
public static void main(String []args){
// 构造的两个字符串，虽然内容一样，它们的内存地址却是不一样的
char[] cha = {'a','b','c'};
String t1 = new String(cha);
String t2 = new String(cha);
String t3 = "abc";
String t4 = "abc";
// 字符串对象地址是否相同
System.out.println(t1==t2);
System.out.println(t1==t3);
System.out.println(t3==t4);
// 字符串内容是相同的
System.out.println(t1.equals(t2));
System.out.println(t1.equals(t3));
System.out.println(t3.equals(t4));
}
}
false
false
true
true
true
true
String.charAt()方法返回指定索引处的char值。索引的范围是从0到length()-1
public class hello {
public static void main(String []args) {
int[] arr = {1, 2, 3};
String s = array(arr);
System.out.println("s:"+s);
}
public static String array(int[] arr){
String s = "";
s+="[ ";
for(int i=0;i<arr.length;i++){
if(i==arr.length+1){
s+=arr[i];
}else{
s+=arr[i];
s+=",";
}
}
s+=" ]";
return s;
}
String方法：
① public boolean equals() 比较字符串内容
② public char charAt(int index) 返回指定索引处 的char值
③ public int length() 返回此字符串的长度
四、StringBuilder
是一个可变的字符串类，它的内容是可变的，string内容是不可变的
构造方法：
① public StringBuilder() 创建一个空白可变字符串对象，不含有任何内容
② public StringBuilder(String str) 根据字符串的内容，来创建可变字符串的对象
public class hello {
public static void main(String[] args) {
StringBuilder ch = new StringBuilder();
System.out.println("ch:"+ch);
System.out.println(ch.length());
StringBuilder ch1=new StringBuilder("yhx");
System.out.println("ch1:"+ch1);
System.out.println(ch1.length());
}
}
ch:
0
ch1:yhx
3
添加、反转方法：
① public StringBuilder append(任意类型)添加数据，返回对象本身
② public StringBuilder reverse() 返回相反的字符序列
public class hello {
public static void main(String[] args) {
StringBuilder ch = new StringBuilder();
ch.append("hello").append("world").append(",").append("java");
System.out.println(ch);
ch.reverse();
System.out.println(ch);
}
}
helloworld,java
avaj,dlrowolleh
StringBuilder和String相互转换：
① StringBuilder转换为Stringpublic String toString()
② String转换为StringBuilderpublic StringBuilder(String s) 通过构造方法就可以实现把String转换为StringBuilder
public class hello {
public static void main(String[] args) {
StringBuilder ch = new StringBuilder();
ch.append("hello").append("world").append(",").append("java");
String s = ch.toString();
System.out.println(s);
}
}
public class hello {
public static void main(String[] args) {
String ch = "yhx";
StringBuilder s = new StringBuilder(ch);
System.out.println(s);
}
}
还有一种StringBuilder方法：public String toString() 通过toString() 就可以实现把StringBuilder转换为String
ArrayList集合
集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变，我们先来学学集合的其中一种arraylist。
ArrayList<E> 可调整大小的数组实现，E是一种特殊的数据类型，泛型。只需要在出现E的地方我们使用引用数据类型替换即可
ArrayList构造和添加方法：
① public ArrayList() 创建一个空的集合对象
② public boolean add(E e) 将指定的元素追加到此集合的末尾
③ public void add(int index,E element) 在此集合中的指定位置插入指定的元素
import java.util.ArrayList;
public class hello {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<String>();
System.out.println("array:"+array);
ArrayList<String> array1 = new ArrayList<>();
System.out.println(array1.add("yhx"));
System.out.println("array1:"+array1);
ArrayList<String> array2 = new ArrayList<>();
array2.add("hello");
array2.add("world");
System.out.println("array2:"+array2);
ArrayList<String> array3 = new ArrayList<>();
array3.add("hello");
array3.add("world");
array3.add(1,"java");
System.out.println("array3:"+array3);
}
}
array:[]
true
array1:[yhx]
array2:[hello, world]
array3:[hello, java, world]
ArrayList集合常用方法：
① public boolean remove(Object o) 删除指定的元素，返回删除是否成功。
② public E remove(int index) 删除指定索引处的元素，返回被删除的元素
③ public E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
④ public E get(int index) 返回指定索引处的元素
⑤ public int size() 返回集合中的元素个数
import java.util.ArrayList;
public class hello {
public static void main(String[] args) {
ArrayList<String> array2 = new ArrayList<String>();
array2.add("hello");
array2.add("world");
array2.add("java");
// 返回删除是否成功
// System.out.println(array2.remove("world"));
// System.out.println("array2:"+array2);
//返回：true
//array2:[hello, java]
// 删除指定索引处的元素，返回被删除的元素
// System.out.println(array2.remove(2));
// System.out.println("array2:"+array2);
//返回：java
//array2:[hello, world]
//修改指定索引处的元素，返回被修改的元素
// System.out.println(array2.set(1,"python"));
// System.out.println(array2);
//返回：world
//[hello, python, java]
}
}
·size()方法得到集合长度
import java.util.ArrayList;
public class hello {
public static void main(String[] args) {
ArrayList<String> array2 = new ArrayList<String>();
array2.add("hello");
array2.add("world");
array2.add("java");
for(int i=0;i< array2.size();i++){
String s = array2.get(i);
System.out.println(s);
}
}
}
（下面文章将进入继承和多态的介绍）