java学习次日

时间 2019-12-06

标签 java 学习次日栏目 Java 繁體版

原文原文链接

java学习次日
第一课java

面向对象1
面向对象思考问题时，以具体的事物为单位，考虑它的属性(特征)及动做(行为)数据库

类与对象
         类   --> 是对一类事物的描述，是抽象的、概念上的定义
         好比人类就是一个抽象的类,由于只是概念上的,而不是实例到哪个人

         对象 --> 是实际存在的该类事物的每一个个体也称实例
         好比张三属于人类,而后又具体到哪个人这就成实例化也就是对象dom

// public --> 访问修饰符，类(外部类)的修饰符有：public 跟默认的
// class --> 类关键字，表示这个是类
// ClassKnow 类名：一、必须符合命名规则，命名习惯
public class ClassKnow
{函数

//成员变量(属性)工具

//【访问修饰符】【其余修饰符(final static)】数据类型变量名【=变量值】
//注意点：变量值，若是没有赋值，那就是默认值(视数据类型而定)学习

//访问修饰符有 public private protected 默认的this

public int a = 1;spa

//静态成员变量 static 修饰
public static int classStatic = 2;对象

//成员方法
//【访问修饰符】【其余修饰符(final static)】返回值方法名(参数列表) 【throw Exception】
//注意：必定要方法体
public int method(String xx, int bb){
  //知识点：
  //普通的成员方法能够调用普通的方法
  //普通的成员方法中可使用普通的成员变量
  // this   ---> 表示 ClassKnow new以后的对象
  // this表明当前对象
  //方法里面能够声明 /定义局部变量

  return 0;
}递归

//静态成员方法
public static void main(String[] args){
  //知识点：
  //static 方法只能调用 static 方法或者 static 成员变量
  //不然报错：错误: 没法从静态上下文中引用非静态方法 method(String,int)
  //method("", 111);

  //错误: 没法从静态上下文中引用非静态变量 classIntAttr
  System.out.println(classIntAttr);

}

}

对象的产生和使用

构造方法(函数) 构造方法的名字和类名相同，而且没有返回值
也不要加void
构造方法(函数）

做用：在建立对象时(new时)自动调用构造方法而且
初始化对象

利用关键字 new 调用类的构造方法(函数)就能够建立该类的一个对象

两种构造方法
参数构造方法

默认(隐藏，隐式)构造方法 --> 指不带参数的构造方法

this 关键字
能够看做是一个变量，它的值就是当前对象的引用

对象的内存图

一、在栈声明一个对象
二、在堆建立一个该类的对象,里面有属性,方法
三、把建立的该类的对象的内存地址赋值给该类的一个对象

字符串的引用

例子解释
public class PassValue {
public void change(int x){
        x = 100;
    }

public void change(Student student1){
  student1.name = "langfeiyes";
    }

public void change(String str){
  str = str + "1510";
  //System.out.println(str);
    }

public String change2(String str){
  return str + "1510";
    }

public static void main(String[] args) {
  PassValue passValue = new PassValue();
  int x = 10;
  //基本类型当参数赋值给方法，在方法内部改变这个参数时候
  //原先的基本类型没有变化
  passValue.change(x);
  System.out.println(x);


  //引用类型赋值(String 引用类型除外)
  //引用类型当参数赋值给方法时，在方法内部改变这个参数(属性或者其余东西)
  //原先的引用类型对应(属性或者其余东西)，将发生改变。
  Student student = new Student("隔壁老王");
  passValue.change(student);
  System.out.println(student.name);


  //String 引用类型传值
  //字符串类型当参数赋值给方法是，在方法内部改变这个参数
  //原先的字符串类型没有发生改变
  //缘由：字符串池存在，当字符串发生改变时，会新生产一个字符串对象
  String string = "zhangsan";
  passValue.change(string);
  System.out.println(string);


  //实际开发中问题：
  //若是想对字符串进行加工，同样要返回加工后的字符串
  String string1 = "李四";
  string1 = passValue.change2(string1);
  System.out.println(string1); //另外操做


  //判断一个对象是否相等使用 == 比较的是内存地址
  Student student2 = new Student();
  Student student3 = new Student();
  //经过new出来的对象，都会从新分配内存地址，同类对象赋值是不会改变内存堆栈
  Student student4 = student3;
  //false
  System.out.println("student2 == student3?" + (student2 == student3));
  //true
  System.out.println("student4 == student3?" + (student4 == student3));

  //首先去字符串池里面去找，若是发现有字符跟它内容相等，则直接赋值
  //不然，新建一个字符串对象
  String str1 = "zhansan";
  String str2 = "zhansan";


  String str3 = new String("zhansan");

  //true
  System.out.println("str1 == str2?" + (str1 == str2));

  //false 经过new出来的对象，都会从新分配内存地址，同类对象赋值是不会改变内存堆栈
  System.out.println("str1 == str3?" + (str1 == str3));


}

static 的引用

例子解释

public class StaticAtr {
//知识点1；静态成员变量，它有专属的数据区，
// 类加载进内存的时候，静态属性也同时加载到专属的数据区
//知识点2：静态成员变量，是惟一的，它属于类的，访问方法   类名.静态属性,
// 因此静态成员变量称为，类变量类属性
static String staticAtr = "静态成员变量";

//非静态属性
String noStaticAtr = "非静态成员变量";

//静态方法
//知识点1：静态成员方法，它有专属的方法区，类加载进内存的时候，
// 静态方法也同时加载到专属的方法区
//知识点2：静态成员变量，是惟一的，它属于类的，访问方法   类名.静态方法,
// 因此静态成员方法称为，类方法
public static void info(){
  System.out.println("静态方法：StaticAtr.info()");
}

//静态方法调用非静态属性
public static void method(){
  //在静态方法里面没法使用this这个关键字
  //Cannot use this in a static context

  //在静态方法里面没法调用非静态属性
  //缘由：非静态属性，它属于对象，只有new 对象，给它进行赋值，这样调用时候，才具备实际意义
  //而，静态方法是能够经过类名.静态方法进行访问，即便没有new这个对象也是能够访问
  //Cannot make a static reference to the non-static field noStaticAtr
  //System.out.println("非静态的属性：" + noStaticAtr);

  System.out.println("StaticAtr.method");
  //静态方法不可访问非静态方法,可是，反过来，非静态方法能够访问静态方法
  //noStaticMethod();
}

public void noStaticMethod(){
  method();
}

public static void main(String[] args) {
  StaticAtr staticAtr1 = new StaticAtr();
  StaticAtr staticAtr2 = new StaticAtr();

  staticAtr1.noStaticAtr = "zhangsan"; //修改非静态属性
  System.out.println(staticAtr1.noStaticAtr); //对象一

  System.out.println(staticAtr2.noStaticAtr); //对象二
  System.out.println("----修改静态属性-------------------");

  staticAtr1.staticAtr = "改变了静态属性";
  System.out.println(staticAtr1.staticAtr);   //对象1
  System.out.println(staticAtr2.staticAtr); //对象二




  System.out.println(StaticAtr.staticAtr);   //类名.静态属性


  System.out.println("对象对用静态方法-------------------");

  //The static method info() from the type StaticAtr
  //should be accessed in a static way
  staticAtr1.info();
  StaticAtr.info();

}

}

构造方法和this的使用

/*
一、构造方法的名字和类名相同，而且没有返回值，而且不要加void。
二、分类：自定义的默认的(无参的) 自定义跟默认2者只能存其一
三、构造方法的做用在于构造并初始化对象。
四、构造方法的重载关注参数列表    具体跟方法的重载一致
五、this.属性/方法   表示调用当前属性或方法
    this(xxxx);   构造函数的调用，注意点：this(xxx) 必须是第一行
*/

public class UserTwo
{
String username;
String password;
int age;

//构造方法的名字和类名相同，而且没有返回值，而且不要加void。
//构造方法的做用在于构造并初始化对象。
//[访问修饰符] 注意：没有[static final]修饰符
//注意：若是类中自定义的构造方法，java会自动给你默认添加一个无参数的构造方法
//若是你类中定义一个或一个以上的构造方法[构造器](不论是否带参数)，java一概不提供
//默认的构造方法
//UserTwo(){
//}

//不是构造方法，这是普通成员方法
//void UserTwo(String username){
//}

UserTwo(){ //无参构造函数
  //this(""); 注意：this 调用构造器时，要注意避免递归构造器调用，进而陷入死循环
  System.out.println("无参构造函数");
}

//构造方法的重载
UserTwo(String username){ //有1个参数构造函数
  //this();
  System.out.println("有1个参数构造函数");
}

//并初始化对象
UserTwo(String username, String password){
  System.out.println("有2个参数构造函数");
  //this表示当前对象
  this.username = username;
  this.password = password;

}

UserTwo(String username, String password, int age){
  //this();

  //this的第二个用法，
  //注意：一、错误: 对this的调用必须是构造器中的第一个语句
  this(username, password);
  this.age = age;

System.out.println("有3个参数构造函数");
}

/*
  为啥要有带参数的构造方法：
  一、为了初始化对象一些属性
  二、建立方便，减小量

  构造方法使用技巧：
  一、若是属性很是多，把必要，使用频率高的属性当作构造方法的属性
  二、this调用构造函数
*/
public static void main(String[] args){
  //实例化对象时候，其本质，就是调用构造方法
  //调用构造方法，跟调用普通方法同样
  //关注：参数列表
  //UserTwo user = new UserTwo(""); //调用有参构造方法

  UserTwo user = new UserTwo();
  user.username = "yaoming";
  user.password = "123";

  //等价
  //UserTwo user = new UserTwo("yaoming", "123");

System.out.println("username:" + user.username);
System.out.println("password:" + user.password);

  System.out.println("-----------------------");
  //
  UserTwo user3 = new UserTwo("lisi", "123", 19);
  System.out.println("username:" + user3.username);
  System.out.println("password:" + user3.password);
  System.out.println("age:" + user3.age);
}
}

包的知识点：

一、包基本上隐藏了类并避免了名称上的冲突。
二、实际项目中，能够经过分包进行业务区分
三、 jar若是使用默认包，没法引用

分包技巧

实际开发中，必定要遵照项目已经制定好的分包规则
一、根据业务进去区分好比：登陆 login 聊天chat
二、根据类的功能区分好比：实体 domain 工具包 util

包的命名
域名的反写 www.sun.com
com.sun
这样命名的缘由：类名称上的冲突

要导入某个包中的全部类能够用
包名.*

//静态代码非静态代码public class StaticBlock { public static int staticField; //静态成员属性 public int noStaticField; //非静态成员属性 //静态代码块 //静态代码块，在类加载的时候，开始执行，执行惟一的一次 //静态代码块先于构造函数执行 //注意：使用静态static关键修饰的方法或属性或代码块都是按声明的顺序加载入内存 //因此，在调用过程当中必定要注意顺序。非静态，没有这个限制 //运用场景： // 一、数据库的操做 // 二、程序运行参数的加载、环境初始化 // 类进行操做的时候，必须知足必定的条件，并且， // 这个条件一但设置好了就不须要进行修改 static{ //Cannot make a static reference to the non-static field noStaticField //静态代码块中，不能访问非静态属性，能够访问静态属性，或者静态方法 //System.out.println(noStaticField); System.out.println("执行了StaticBlock 静态代码块"); System.out.println("静态属性："+staticField); } //类加载后其余模块执行顺序 //static 代码块执行 -- > 非静态代码块 ---- > 构造函数 // 每次 new 对象的时候都执行，缘由：非静态代码块是属于对象 //非静态代码块(全局代码块) { System.out.println("执行了StaticBlock 非静态代码块"); } StaticBlock(){ this.noStaticField = 10; System.out.println("StaticBlock 类的构造方法。。。。"); } public static void main(String[] args) { //局部代码块 //里面定义的变量只能在里面使用，超出范围后，报错 //真实开发中，不建议这么使用 { int a = 0; } //a cannot be resolved to a variable //System.out.println(a); int a = 2; System.out.println(a); StaticBlock block = new StaticBlock(); StaticBlock block2 = new StaticBlock(); } }