package com.atguigu.java1;
/*
* 类的结构之三:构造器(构造方法、constructor)
* construct:建设、建造。construction:CCB. constructor:建设者。
*
* 一、构造器的作用:
* 1.创建对象
* 2.初始化对象的属性
*
* 二、说明:
* 1.如果没有显式的定义类的构造器的话,则系统默认提供一个空参的构造器。
* 2.定义构造器的格式: 权限修饰符 类名 (形参列表)
* 3.构造器的重载:一个类中定义多个构造器,彼此之间构成重载。
* 4.一旦我们显式的定义了类的构造器,系统就不再提供默认的空参构造器。
* 5.在一个类中,至少会有一个构造器。
*/
public class PersonTest {
public static void main(String[] args) {
//创建类的对象:new + 构造器
Person p = new Person();
p.eat();
Person p1 = new Person("杰瑞");
System.out.println(p1.name);
}
}
class Person{
//属性
String name;
int age;
//构造器
public Person(){
System.out.println("Person...");
}
public Person(String s){
name = s;
}
public Person(String s , int i){
name = s;
age = i;
}
//方法
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}
package com.atguigu.java1;
/*
* 总结:属性赋值的先后顺序
*
* ①默认初始化值
* ②显式初始化值
* ③构造器当中赋值
* ④通过”对象.方法“ 或者 ”对象 . 属性“的方式进行赋值
*
* 以上操作的先后顺序: 1 > 2 > 3 > 4
*/
public class User {
public static void main(String[] args) {
Use u1 = new Use();
System.out.println();
}
}
class Use {
String name;// 默认初始化
int age = 1;// 显式初始化赋值
public Use() {
}
public Use(String n) {// 构造器中赋值
name = n;
}
}
package com.atguigu.java1;
/*
* JavaBean是一种Java语言写成的可重用组件。
* 所谓的JavaBean,是指符合如下标准的Java类:
* 1.类是公共的;
* 2.有一个无参的公共的构造器;
* 3.有属性,有对应的set、get方法;
*/
//1.公共的类
public class Customer {
private int age;
private String name;
// 2.公共的空参构造器
public Customer() {
}
// 3.提供属性,并有公共的set、get方法
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
public void setName(String s) {
name = s;
}
public int getName() {
return age;
}
}
package com.atguigu.java;
/*
* 面向对象的特征一:封装与隐藏
* 一、问题的引入:
* 当我们创建一个类的对象,我们可以通过”对象.属性“的方式,对对象的属性进行赋值。
* 这里,赋值操作要受到属性的数值类型和存储范围的制约。但是除此之外,没有其他的制约条件。
* 但是,在实际问题中,我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现,
* 我们只能通过方法进行限制条件的添加。(比如:setLegs(int i))
* 同时,我们需要避免用户再使用”对象.属性“的方式进行赋值。则需要将属性声明为私有的(private)
* ---->此时针对于属性就体现了封装性。
*
* 二、封装性的体现:
* 我们将类的属性xxx私有化(private),同时,
* 提供公共的(public)方法来获取(getXxx)和设置(setXxx)属性
*
* 拓展:封装性的体现: ① 如上 ② 不对外暴露的私有的方法。③单例模式...
*
* 三、封装性的体现,需要权限修饰符来配合。
* 1.Java规定的四种权限,(从小到大)private、缺省、protected、public
* 2.4种权限可以用来修饰类及类的内部结构:属性、方法、构造器、内部类
* 3.具体的,4种权限可以用来修饰类的内部结构:属性、方法、构造器、内部类
* 修饰类的话只能使用 缺省、public
*
* 总结一下封装性:Java提供了四种权限修饰符来修饰类及类的内部结构,
* 体现在调用类以及类的内部结构时可见性的大小。
*
*
*
*
*/
public class AnimalTest {
public static void main(String[] args) {
Animal a = new Animal();
a.setName("老虎");
System.out.println(a.getName());
a.setAge(88);
System.out.println(a.getAge());
a.setLegs(8);
System.out.println(a.getLegs());
a.show();
}
}
class Animal {
private String name;
private int age;
private int legs;// 加上权限修饰符,定义为私有属性
public void setLegs(int i) {
if (i >= 0 && i % 2 == 0) {
legs = i;
} else {
legs = 0;
// 抛出一个异常(暂时没有讲后续再完善)
}
}
public String getLegs() {
return "腿的条数:" + legs;
}
public void setAge(int i) {
if (0 <= i && i <= 100) {
age = i;
} else {
age = -1;
}
}
public String getAge() {
return "年龄:" + age;
}
public void setName(String s) {
if (0 < s.length() && s.length() < 5) {
name = s;
} else {
name = "0";
}
}
public String getName() {
return "名字:" + name;
}
public void eat() {
System.out.println("动物进食");
}
public void show() {
System.out.println("name:" + name + "\t" + "age:" + age + "\t" + "legs:" + legs);
}
}
package com.atguigu.java2;
/*
* this关键字的使用
* 1.this可以用来修饰、调用:属性、方法、构造器
*
* 2.this修饰属性和方法:
* 把this理解为:当前对象。
*
* 2.1 在类的方法中,我们可以使用 "this.属性" 、" this.方法" 的方式,调用当前对象的属性和方法。
* 但是,通常情况下,我们都选择省略"this."特殊情况下:如果方法的形参和类的属性重名时,我们必须显式的
* 使用”this.变量“的方式,表明此变量是属性,而不是形参。
*
* 2.2 在类的构造器中,我们可以使用 "this.属性" 、" this.方法" 的方式,调用当前正在创建的对象的属性和方法。
* 但是,通常情况下,我们都选择省略"this."特殊情况下:如果方法的形参和类的属性重名时,我们必须显式的
* 使用”this.变量“的方式,表明此变量是属性,而不是形参。
*
* 3.this调用构造器
* ①我们在类的构造器中,可以显式的使用”this(形参列表)“方式,调用本类指定的其他构造器。
* ②构造器中不能通过”this(形参列表)“来自己调自己。
* ③如果一个类中有n个构造器,则最多只有n - 1个构造器使用this(形参)。
* ④规定:this(形参列表)必须放在构造器的首行。
* ⑤构造器内部,最多只能声明一个this(形参列表),来调用其他构造器。
*
*/
public class PersonTest {
public static void main(String[] args) {
Person p = new Person("ahhaha", 89);
System.out.println(p.getName());
System.out.println(p.getAge());
}
}
class Person {
// 属性
private String name;
private int age;
// 构造器
public Person() {
}
public Person(String name) {
this.name = name;
}
public Person(int age) {
this.age = age;
}
public Person(String name, int age) {
// this.age = age;
// this(name);
this(age);
this.name = name;
}
// 方法
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return this.age;
}
public void eat() {
System.out.println("人吃饭");
this.study();
}
public void study() {
System.out.println("人学习");
}
}
package com.atguigu.java2;
import java.util.*;
import com.atguigu.exer2.Account;
/*
* 一、package关键字的使用
* 1.为了更好的实现项目中类的管理,提供包的概念
* 2.使用package声明类、接口所属的包,声明在源文件的首行
* 3.包,属于标识符,遵循标识符的命名规则、和命名规范(xxxyyyzzz)、见名知意
* 4.每”.“就代表一层文件目录。
*
* 补充:同一个包下,不能命名同名的接口、类
* 不同的包下可以命名同名的类、接口
*
* 二、import关键字的使用
* import的作用:导入:
* 1.在源文件中,显式的使用import结构导入指定包下的:类或者接口。
* 2.声明在包的声明和类的声明之间
* 3.如果需要导入多个结构,并列导入即可
* 4.可以使用"xxx.*"的方式可以导入xxx包下的所有结构
* 5.如果使用的类或者接口是Java.lang包下定义的,则可以省略import结构
* 6.如果使用的类或者接口是本包下定义的则也可以省略import结构
* 7.如果在源文件中,使用了不同包下的同名的类,则必须至少有一个类需要以全类名的方式进行显示
* 8.使用"xxx.*"的方式可以调用xxx包下的所有结构,但是如果使用的是xxx子包下的结构,则仍需要显式导包。
*
* 9.import static :导入指定类或接口中的静态结构:属性或者方法
*/
public class PackageImportTest {
public static void main(String[] args) {
java.lang.String s = "hello";
Account account = new Account(1000, 88282,0.98);
//全类名的方式显示
com.atguigu.exer4.Account account1 = new com.atguigu.exer4.Account(10.1);
Date date = new Date();
System.out.println(date);
java.sql.Date date1 = new java.sql.Date(349875347529L);
System.out.println(date1);
}
}