Java学习【知识点及代码4.1】

一：
1.1封装：（案例演示，创建学生类年龄可以随意被设置成不符合要求的参数）
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：
    A:提高了代码的复用性
    B:提高安全性。
体现：
    将不需要对外提供的内容都隐藏起来。
做法：
    把属性隐藏，提供公共方法对其访问。

现在我们可以给age赋值，但是赋予负数值居然也通过了。这是不满足实际需求的。
我们应该对不满足需求的数据给与判断。
而判断不能直接针对成员变量做，因为要判断，就必须写在方法中。
所以，我们应该用一个方法给年龄赋值并判断。

package day4.edu_01;

public class Student {
    //成员变量
    String name;
    int age;

    //成员方法
    public void makePlane(){
        System.out.println("学生会做飞机");
    }
    public void study(){
        System.out.println("好好学习天天向上");
    }

    //提供一个检测年龄的方法
    public void checkAge(int a){
        if(a>200||a<0){
        System.out.println("年纪填写不正确");
    }else{
        age = a;
    }
    }
}

package day4.edu_01;

public class Test {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();
        //赋值
        s.age = 209;
        s.name = "李明";
        //使用我们刚刚创建的检测年龄的方法给学生年龄赋值
        s.checkAge(209);
        //打印学生的成员变量
        System.out.println(s.age);
        System.out.println(s.name);
    }
}

虽然我们已经通过一个方法做出了数据不正常的判断，但是我们还是可以通过对象直接访问成员变量。
那么，为了让使用者使用方法来给成员变量赋值，就不能允许它们直接去访问成员变量。
怎么办呢?
    为了解决这种情况，java就提供了一个修饰符关键字：private

private：
    私有的意思。

    可以修饰成员变量和成员方法。

    特点：
        被private修饰的内容，只能在本类中访问。

1.2
封装加入private后的标准代码：
A:把成员变量private修饰
B:针对每一个成员变量给出
getXxx()和setXxx()（注意首字母大写）
注意：这里的xxx其实是成员变量名称。

二：this关键字详解（演示修改局部变量的变量名和成员变量相同的话的效果）

常说：
    见名知意。
局部变量如果有一个变量和成员变量名称一致，那么优先使用的是局部变量。
就近原则。

这样的话，就造成了局部变量隐藏了成员变量。
如何解决呢?
    为了解决这种情况，java就提供了一个代表本类对象的关键字：this

package day4.edu_02;

public class Student {
    //私有化成员变量,被私有化的成员变量只能在本类中使用
    private String name;
    private int age;

    //为name这个成员变量提供访问方式
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }

    //为age提供set/get方法
        public void setAge(int age){
            this.age = age;//s.age = 40;
        }
        public int getAge(){
            return age;
        }

    //成员方法：
        public void eat(){
            System.out.println("饿了要吃饭");
        }

        public void sleep(){
            System.out.println("困了需要睡觉");
        }
}

package day4.edu_02;

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        //给学生对象的成变量赋值
        //使用set/get方法给学生对象进行赋值
        s.setAge(20);
        s.setName("李敏");
        //用get方法进行获取
        System.out.println(s.getAge()+"  "+s.getName());

        System.out.println("------------------------");
        Student s2 = new Student();
        s2.setAge(30);
        s2.setName("马云");
        System.out.println(s2.getAge()+"  "+ s2.getName());
    }
}

三：构造方法
3.1构造方法：

作用：给对象的数据进行初始化
格式特点：
    A:方法名和类名相同。
    public void Student() {}
    B:没有返回值类型。
    修饰符 返回值类型 方法名(...) {...}
    C:没有返回值。
    没有用return带明确的值回来。
    return;

3.2构造方法注意事项:

    A:如果你不提供构造方法，系统会给出默认无参构造方法
    B:如果你提供了构造方法，系统将不再提供默认无参构造方法
    这个时候怎么办呢?
        a:使用自己给的带参构造。
        b:要么自己再提供一个无参构造
        建议：建议永远自己给出无参构造方法。
    C:构造方法也是可以重载的。

package day4.edu_03;

public class Student {
    private String name;
    private int age;

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

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

    //写一个无参数的构造方法
    public Student(){
        System.out.println("无参构造");
    }
    //写一个有参数的构造方法
    public Student(String name,int age){
        System.out.println("有参构造");
        //在构造方法中给成员变量进行赋值
        this.name = name;
        this.age = age; 
    }
}

package day4.edu_03;

public class Test {
    public static void main(String[] args) {
        //创建一个学生对象
        Student s1 = new Student();
        //此时调用的是一个类的无参数的构造方法
        //当你没有提供任何的构造方法的时候，系统会给你提供一个默认的无参数的构造方法

        System.out.println("-----------------------");
        Student s2 = new Student("刘丽",20);

        System.out.println("-----------------------");

        System.out.println(s1.getName()+"  "+s1.getName());
        System.out.println(s2.getName()+"  "+s2.getAge());
    }
}

3.3给成员变量赋值：
A:通过setXxx()方法
B:通过带参构造方法
四：成员方法：
去掉static的方法。

根据返回值类型：
    void类型
    非void类型

根据参数列表：
    无参
    带参                  

五：标准代码的写法：

练习：
手机类：
    成员变量：
        brand,price,color
    构造方法：
        无参，带参
    成员方法：
        getXxx()/setXxx()
        show(),call()   

package com.edu_04;
public class Phone {
    //提供私有化的成员变量
    private String brand;
    private int price;
    private String color;

    //为私有化的成员变量提供set/get方法
    public void setBrand(String brand){
        this.brand = brand;
    }
    public String getBrand(){
        return brand;
    }

    public void setPrice(int price){
        this.price = price;
    }
    public int getPrice(){
        return price;
    }

    public void setColor(String color){
        this.color = color;
    }
    public String getColor(){
        return color;
    }

    //提供有参数和无参数的构造方法
    public Phone(){}

    public Phone(String brand,int price,String color){
        this.brand = brand;
        this.price = price;
        this.color = color;
    }


    //提供功能性的方法
    public void call(){
        System.out.println("手机可以打电话");
    }
    public void show(){
        //show方法打印三个成员变量
        System.out.println(brand+"  "+price+"  "+color);
    }
}

package com.edu_04;

public class Test {
    public static void main(String[] args) {
        //创建一个手机对象，使用set方法给对象赋值（无参构造+set方法）
        Phone p = new Phone();
        p.setBrand("华为");
        p.setColor("黑色");
        p.setPrice(2000);
        System.out.println(p.getBrand()+"  "+p.getColor()+"  "+p.getPrice());

        System.out.println("-----------------------------");
        //使用有参构造创建对象并且给对象赋值
        Phone p2 = new Phone("苹果", 5000, "土豪金");
        System.out.println(p2.getBrand()+"  "+p2.getColor()+"  "+p2.getPrice());

        System.out.println("-----------------------------");
        p2.call();
        p2. show();
    }
}

六：练习：

学生类：
    成员变量：
        name,age,address
    构造方法：无参，带参

    成员方法：getXxx()/setXxx()
            show(),study()

package com.edu_05;
public class Student {

    //私有化成员变量
    private String name;
    private int age;
    private String address;

    //为私有化的成员变量提供set/get方法
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }

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

    public void setAddress(String address){
        this.address = address;
    }
    public String getAddress(){
        return address;
    }

    //有参数和无参数的构造方法
    public Student(){}
    public Student(String name,String address,int age){
        this.name = name;
        this.address = address;
        this.age = age;
    }


    //写一个show()和sutdy()
    public void show(){
        System.out.println(name+"  "+age+"  "+address);
    }
    public void study(){
        System.out.println("好好学习天天向上");
    }
}

package com.edu_05;

public class Test {
    public static void main(String[] args) {
        //使用无参构造+set方法创建对象并且给成员变量赋值
        Student s = new Student();
        s.setName("郭德纲");
        s.setAddress("北京");
        s.setAge(45);
        System.out.println(s.getName()+"  "+s.getAge()+"  "+s.getAddress());

        System.out.println("---------------------------------");
        //使用有参构造创建对象
        Student s2 = new Student("林志玲", "台湾", 42);
        System.out.println(s2.getName()+"  "+s2.getAge()+"  "+s2.getAddress());

        System.out.println("-------------------------");
        s2.show();
        s2.study(); 
    }
}

七：对象练习：
7.1 定义一个类MyMath,提供基本的加减乘除功能，然后进行测试。
add(int a,int b)
sub(int a,int b)
mul(int a,int b)
div(int a,int b)

package com.edu_06;
public class MyMath {

    //加法
    public int add(int a,int b){
        return a+b;
    }

    //减法
    public int sub(int a,int b){
        return a-b;
    }

    //乘法
    public int mul(int a,int b){
        return a*b;
    }

    //除法
    public int div(int a,int b){
        return a/b;
    }
}

package com.edu_06;

public class MyMathTest {
    public static void main(String[] args) {
        //创建MyMath对象
        MyMath my = new MyMath();

        //调用这个对象的加减乘除的功能
        System.out.println(my.add(10, 20));
        System.out.println(my.sub(20, 10));
        System.out.println(my.mul(10, 20));
        System.out.println(my.div(20, 10));

    }
}

7.2定义一个长方形类,定义求周长和面积的方法，然后定义一个测试了Test2，进行测试。
周长：2*(长+宽)
面积：长*宽

package com.edu_07;
public class Rectangle {

    //提供一个求周长的方法
    public int zhouChang(int width,int height){
        return 2*(width+height);
    }

    //求面积的方法
    public int getArear(int width,int height){
        return width*height;
    }
}

package com.edu_07;

public class Test {
    public static void main(String[] args) {
        //创建对象
        Rectangle r = new Rectangle();
        int zhouChang = r.zhouChang(10, 20);
        System.out.println(zhouChang);
        int arear = r.getArear(10, 20);
        System.out.println(arear);
    }
}

变量的定义：
范围越小越好。
但是，如果这个变量和类有描述关系，就应该定义为成员变量。

八：static关键字
8.1为了体现共用的数据，java就提供了一个关键字：static。

static:
作用：可以修饰成员变量和成员方法

特点：
    A:随着类的加载而加载
    B:优先于对象存在
    C:被类的所有对象共享
    也是我们判断该不该使用静态修饰一个数据的依据。
        举例：
            饮水机：static
            水杯：特有的内容。
    D:可以通过类名调用
        静态变量：类变量
        非静态变量：实例变量，对象变量

        非静态的：创建对象访问
        静态的：可以通过类名，也可以通过对象访问。

package com.edu_08;
public class Student {
    String name;
    int age;
    static String className = "java001";//静态的成员变量，是被所有对象所共享的东西

    //创建几个构造方法
    public Student(){}

    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    public Student(String name,int age,String className){
        this.name = name;
        this.age = age;
        this.className = className;
    }

    //创建一个静态的成员方法
    public static void show(){
        System.out.println("student的静态show方法");
    }
}

package com.edu_08;

public class Test {
    public static void main(String[] args) {
        //使用无参数的构造方法创建一个对象
        Student s = new Student();
        s.name = "庾澄庆";
        s.age = 50;
        System.out.println(s.name+"  "+s.age+"  "+s.className);//庾澄庆  50  java001

        System.out.println("-----------------------------");
        //使用带有两个参数的构造方法创建两个对象
        Student s2 = new Student("周杰伦", 37);
        Student s3 = new Student("那英", 50);
        System.out.println(s2.name+"  "+s2.age+"  "+s2.className);//周杰伦  37  java001
        System.out.println(s3.name+"  "+s3.age+"  "+s3.className);//那英  50  java001

        System.out.println("-------------------------------");
        //使用三个参数的构造方法创建一个对象
        Student s4 = new Student("汪老师", 50, "java002");
        System.out.println(s4.name+"  "+s4.age+"  "+s4.className);//汪老师  50  java002
        System.out.println(s2.name+"  "+s2.age+"  "+s2.className);//周杰伦  37  java002
        System.out.println(s3.name+"  "+s3.age+"  "+s3.className);//那英  50  java002

        System.out.println("---------------------------------");
        //通过类名直接调用静态的成员变量和静态的成员方法
        System.out.println(Student.className);
        Student.show();
    }
}

8.2（写一个静态成员变量和静态成员方法进行演示）

static关键字注意事项
    A:在静态方法中是没有this关键字的
        原因：静态的内容随着类的加载而加载，this是随着对象的创建而存在，所以，static中不能有this。
    B:静态方法只能访问静态的成员变量和静态的成员方法
        静态方法只能访问静态的成员。          

package com.edu_09;
class  Demo{
    static int num = 20;
    int num2 = 30;

    //创建几个成员方法
    public void show(){
        System.out.println("demo中的普通的show方法");
    }


    public static void show2(){
        System.out.println("demo的静态的show2方法");
    }

    public static void show3(){
        System.out.println("demo的静态的show3方法");
        //在show3方法中调用show方法
        //show();//静态的方法中只能调用静态的方法
        show2();
        //System.out.println(num2);//静态的方法中无法访问非静态的成员变量
        System.out.println(num);
        /**
         * 注意：以上只需要大家记住一点
         * 静态只能访问静态
         */

    }

}


public class StaticDemo {
    public static void main(String[] args) {
        //创建Demo对象，调用他的静态的show3()
        Demo d = new Demo();
        d.show3();

        System.out.println("--------------------");
        Demo.show3();       
    }
}

九：API帮助文档使用简单讲解+java中的常用的一些包的讲解

十：String类讲解

char[] chs = {'a','b','c'};
(1) 是由多个字符组成的一串数据。(字符序列)
    其实字符串可以看成是一个字符数组。

(2)构造方法：
    public String():无参构造方法
    public String(byte[] bytes):把字节数组转换为字符串
    public String(char[] value):把字符数组转换为字符串
    public String(char[] value,int offset,int count):把字符数组的一部分转换为字符串
    public String(String original):把一个字符串转换为字符串

（需要利用到的一个成员方法）成员方法：
    public int length()：返回此字符串的长度

(3)String的特点及面试题
    A：
    String类的数据特点：
    字符串是常量；它们的值在创建之后不能更改
    面试题：根据以上结论请问输出的s的值是多少
    String s = "hello";
    s += "world";
    System.out.println(s); 

    结论：
    字符串的内容不能发生改变，但是字符串引用的指向是可以改变的。

    B:String s = new String("hello")和String s = "hello"的区别（画图讲解）
        前者创建了1个或者2个对象
        后缀创建了0个或者1个对象
    C:面试题(看程序写结果)
        A:new和直接赋值的区别
            String s1 = new String("hello");
            String s2 = new String("hello");
            System.out.println(s1==s2);
            System.out.println(s1.equals(s2));

            String s3 = new String("hello");
            String s4 = "hello";
            System.out.println(s3==s4);
            System.out.println(s3.equals(s4));

            String s5 = "hello";
            String s6 = "hello";
            System.out.println(s5==s6);
            System.out.println(s5.equals(s6));

    D：面试题：
    String s1 = "hello";
    String s2 = "world";
    String s3 = "helloworld";
    System.out.println(s3 == s1 + s2); 
    System.out.println(s3.equals(s1 + s2)); 

    System.out.println(s3 == "hello" + "world"); 
    System.out.println(s3.equals("hello" + "world")); 

    结论：
    看程序写结果
    变量相加，先开空间，在加。
    常量相加，先加，找是否有这样的数据空间，如果没有才开空间。

(4)String类的成员方法
    A:判断功能
      boolean equals(Object obj):比较两个字符串的内容是否相同,严格区分大小写。(用户名,密码)
      boolean equalsIgnoreCase(String str):比较两个字符串的内容是否相同,忽略大小写。(验证码)
      boolean contains(String str):判断字符串中是否包含一个子串。
      boolean startsWith(String str):判断是否以指定的字符串开头
      boolean endsWith(String str):判断是否以指定的字符串结尾
      boolean isEmpty():判断字符串的内容是否为空
      问题：内容为空和对象为空是一个意思吗?
      答：不是

    B:获取功能
      String类的获取功能：
      int length():返回字符串的长度。其实就是字符的个数。
      char charAt(int index):返回字符串中指定索引处的字符。
      int indexOf(int ch):返回指定的字符在字符串中第一次出现的索引。
            明明说的是字符，为什么是int呢?
            原因是int类型还可以接收char类型。
            97,'a'是一样的效果。
            但是如果参数是char类型，你就不能写97了。
      int indexOf(String str):返回指定的字符串在字符串中第一次出现的索引。
      String substring(int start):截取从start开始到末尾的字符串。
      String substring(int start,int end):截取从start开始到end结束的字符串。

    C:转换功能
      byte[] getBytes():把字符串转换为字节数组
      char[] toCharArray():把字符串转换为字符数组
      static String valueOf(char[] chs):把字符数组转换为字符串
      static String valueOf(int i):把int类型的数据转换为字符串
            valueOf():可以把任意类型的数据转换为字符串。
      String toLowerCase():把字符串转成小写
      String toUpperCase():把字符串转成大写
      String concat(String str):拼接字符串,前面我们使用过+进行字符串的拼接，不够专业。


    D:其他功能
      A:替换功能
            String replace(char old,char new)
            String replace(String old,String new)
      B:去除字符串两端空格   
            String trim()

十一：StringBuffer和StringBuilder

 * StringBuffer:
 * 线程安全的可变字符序列。
 * 
 * String和StringBuffer的区别?
 * A:String的内容不可变
 * B:StringBuffer的内容可变
 * 
 * StringBuffer和StringBuilder的区别?
 * A:StringBuffer 线程安全，效率低
 * B:StringBuilder 线程不安全，效率高
 * 
 * 线程安全：(同步)，效率低
 * 线程不安全：(不同步)，效率高
 * 
 * 构造方法：
 *      StringBuffer():构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
 *      StringBuffer(int capacity):构造一个其中不带字符的字符串缓冲区，其初始容量为 capacity个字符。
 *      StringBuffer(String str):构造一个其中带字符的字符串缓冲区，其初始容量为??? 个字符。
 * 
 * 成员方法：
 *      public int length():返回长度（字符数）。实际值
 *      public int capacity():返回当前容量。 理论值 
 * 添加功能：添加元素，并返回本身的对象。
 *      A:public StringBuffer append(String str):追加数据,在末尾添加
 *      B:public StringBuffer insert(int offset,String str):插入数据,在指定位置添加    
 * 删除功能：
 *      public StringBuffer deleteCharAt(int index):删除指定索引处的字符
 *      public StringBuffer delete(int start,int end):删除从start开始到end结束的数据，包左不包右
 * 替换功能：
 *      public StringBuffer replace(int start,int end,String str):用str替换从start到end的数据
 * 
 * 反转功能：
 *      public StringBuffer reverse()
 * 截取功能:返回值类型是String类型，本身没有发生改变
 *      public String substring(int start)
 *      public String substring(int start,int end) 
 * 相互转换：
 * 
 * String   --  StringBuffer
 *      String s = "hello";
        // 方式1
        StringBuffer sb1 = new StringBuffer(s);
        // 方式2
        StringBuffer sb2 = new StringBuffer();
        sb2.append(s);
 * 
 * StringBuffer  --  String
 *      StringBuffer sb = new StringBuffer("world");
        //方式1
        String s1 = sb.substring(0);
        //方式2
        String s2 = sb.toString();
        //方式3
        String s3 = new String(sb);