java的简述2

面向对象
什么是类？ 是对现实生活中一类具有共同属性和行为的事物的抽象。特点：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);
        }
    }
}

（下面文章将进入继承和多态的介绍）