JAVa学习

JAVA学习笔记

API的使用

类
局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。
创建对象
使用关键字 new 来创建一个新的对象
方法的定义
public static void show（）{方法体 }
方法调用
show（）；在这里插入代码片
String类构造方法

public class StringDemo01 {
    public static void main(String [] args){
        //public String();创建一个空白字符串对象，不含任何内容
        String s1 = new String();
        System.out.println("s1:" + s1);

        //public String (char[] chs);
        char[] chs = {'a', 'b', 'c'};
        String s2 = new String(chs);
        System.out.println("s2:" + s2);

        //public String(byte[] bys);
        byte[] bys = {97, 98, 99};
        String s3 = new String(bys);
        System.out.println("s3:" + s3);

        //String="abc";
        String s4 = "abc";
        System.out.println("s4:" + s4);
    }
}

封装

private

定义成员变量： private 类型 变量名；
提供setXxx()/getXxx()方法： ## 标题
> public void setAge(int a){方法体； };pulic int getAge(){ return age;};**

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

    //提供get/set方法
  //  public void setAge(int a){
    //    age = a;

   // }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
 //   public void setName(String n){
  //      name = n;
   // }
    public void setName(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void show(){System.out.println(name + "," + age);
    }
}

public class StudentDemoha {

public static void main(String[] args) {
    //创建对象
    Student s = new Student();

    //给成员变量赋值
    //s.name = "胡明轩";
    // s.age = 30;
    //使用set方法给成员赋值
    s.setName("詹姆斯");
    s.setAge(30);
    //调用show方法
    s.show();
    //使用get方法获取成员变量的值
    System.out.println(s.getName() + "---" + s.getAge());
}

}

构造方法

每个类都有构造方法，构造方法的名称必须与类同名，一个类可以有多个构造方法

public class Stu {
    private int age;
    private String name;
    //构造方法
//    public Stu(){
//        System.out.println("无参构造方法");
//    }
    public Stu(){};
    public Stu(String name){
        this.name = name;
    }
    public Stu(int age){
        this.age = age;
    }
    public void show() {
        System.out.println(name + "," + age);
    }
    public Stu (String name, int age){
        this.name = name;
        this.age = age;
    }

}

public class StuDemo {
    public static void main(String []  args){
        //创建对象
        Stu s = new Stu();
        s.show();

        Stu s2 = new Stu("胡明轩");
        s2.show();

        Stu s3 = new Stu(20);
        s3.show();

        Stu s4 = new Stu("胡明轩",20);
        s4.show();

    }
}

标准类

/*
    成员变量
        使用private修饰
    构造方法
        提供一个无参构造方法
     成员方法
        提供每一个成员变量对应的setXxx()/getXxx()方法
        提供一个显示对象信息的show()

 */

public class Stu11 {
    //成员变量
    private  String name;
    public int age;
    //构造方法
    public Stu11(){}
    public Stu11(String name,int age){
        this.name = name;
        this.age = 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 void show(){
        System.out.println(name + "," + age);
    }
}

/*
    创建对象并为其成员变量赋值的两种方法
        1、无参构造方法创建对象后使用setXxx()赋值
        2、使用带参数构造方法直接创建带有属性值的对象
 */
public class Stu11Demo {
    public static void main(String [] args){
        //无参构造方法创建对象后使用setXxx()赋值
        Stu11 s = new Stu11();
        s.setName("胡明轩");
        s.setAge(20);
        s.show();

        //使用带参数构造方法直接创建带有属性值的对象
        Stu11 s2 = new Stu11("胡明轩",20);
        s2.show();
    }


}

构造方法和成员方法的区别

1.构造方法

 构造方法作用概述

       给对象的数据进行初始化

 构造方法格式

       方法名与类名相同

       没有返回值类型，连void都没有

       没有具体的返回值

 构造方法注意事项

       如果你不提供构造方法，系统会给出默认构造方法

       如果你提供了构造方法，系统将不再提供

       构造方法也是可以重载的

注意：定义类的时候，建议自己添加无参的构造方法。

2.成员方法

 成员方法作用概述

       表示对象所具有的功能（和行为）。

 成员方法格式

       有返回类型，可以为void类型，也可以是基本数据类型或引用类型。

       成员方法名可以和类名相同，也可以不同。

3.构造方法和成员方法的区别

 A:格式区别
       构造方法和类名相同，并且没有返回类型，也没有返回值。
       普通成员方法可以任意起名，必须有返回类型，可以没有返回值。
 B:作用区别
        构造方法用于创建对象，并进行初始化值。
        普通成员方法是用于完成特定功能的。

 C:调用区别
        构造方法是在创建对象时被调用的，一个对象建立，只调用一次相应构造函数
        普通成员方法是由创建好的对象调用，可以调用多次

继承

super 关键字的用法和this用法相似
this：代表本类对象的引用
super：代表父类对象的引用

继承格式
public class 子类名 extends 父类名 { }

//例子
//测试类
public class demo {
    public demo() {
    }
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

public class Fu {
    public int age = 18;
    public Fu() {
    }
}

public class Zi extends Fu {
    public int heigth = 180;
    public int age = 20;
    
    public Zi() {
    }
    public void show() {
        int age = 30;
        System.out.println(age);
        System.out.println(this.age);
        System.out.println(this.heigth);
        System.out.println(super.age);//父类的对象
    }
}
//输出30 20 180 18

继承中构造方法的访问特点
子中的构造方法都会默认先访问父中的无参构造方法

public class Demo {
    public static void main(String[] args){
    //创建对象
        Zi3 z = new Zi3();
        Zi3 z2 = new Zi3(20);
    }
}

public class Fui {
    public Fui(){
        System.out.println("F中无参数构造方法被调用");
    }
    public Fui(int age){
        System.out.println("Fu中带参数方法被调用");
    }
}

public class Zi3 extends Fui{
    public Zi3(){
//        super();
//        super（20）;//super（20）访问父中的带参构造方法
        System.out.println("Zi中无参数方法被调用");
    }
    public Zi3(int age){
//        super();
//        super(20);//super（20）访问父中的带参构造方法
        System.out.println("Zi中带参数方法内调用");
    }
}

继承中成员方法的访问特点
通过子类对象访问一个方法
子类成员范围找->父类成员范围中找

public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Zi_5 z = new Zi_5();
        z.method();
        z.show();
    }
}

public class Fu_5 {
    public void show(){
        System.out.println("Fu中的方法被调用");
    }
}

public class Zi_5 extends Fu_5{
    public void method(){
        System.out.println("Zi中method方法被调用");
    }
    public void show(){
        super.show();//访问父类
        System.out.println("Zi中的方法被调用");
    }
}
//输出三个