尚硅谷_Java零基础教程（面向对象上）--学习笔记（十一）

package com.itguigu.java;
/*
 * 面向对象的特征一：封装与隐藏
 * 一、问题的引入：
 * 	当我们创建一个类的对象以及，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到
 * 	属性的数据类型和存储范围的制约，除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值
 * 	加入额外的制约条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。同时，我们需要
 * 	避免用户再使用"对象.属性"的方式对属性进行赋值，则需要将属性声明为私有的(private)。
 * -->此时，针对于属性就体现了封装性。
 * 
 * 二、封装性的体现
 * 	我们将类的属性私有化(private)，同时，提供公共(public)的方法来获取(getXxx)和设置(setXxx)此属性的值。
 *
 *	拓展：封装性的体现：1、如上。2、不对外暴露的私有方法。3、单例模式。等等
 *
 *三、封装性的体现，需要权限修饰符来配合。
 *	1.Java规定的4种权限（从小到大）：private,缺省,protected,public
 *	2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类。
 *	3.具体的：4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类。
 *			修饰类的话，只能使用：缺省、public。
 *
 *总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及内部结构在被调用的时候的可见性的大小。
 */
public class AnimalTest {
	public static void main(String[] args) {
		Animal a = new Animal();
		a.name = "大黄";
		//a.age = 1;
		//a.legs = 4;
		
		a.show();
		
		//a.legs = -4;
		a.setLegs(10);
		a.show();
		
		System.out.println(a.getLegs());
	}
}

class Animal{
	String name;
	private int age;
	private int legs; //腿的个数
	
	public void setLegs(int l) {
		if(l>=0 && l%2==0) {
			legs = l;
		}else {
			legs = 0;
		}
	}
	
	public int getLegs() {
		return legs;
	}
	
	public void eat() {
		System.out.println("动物进食");
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int a) {
		age = a;
	}
	
	public void show() {
		System.out.println(name + "," + age + "," + legs);
	}
}

package com.itguigu.exer;

public class Person {
	private int age;
	
	public void setAge(int a) {
		if(a<0 || a>130) {
			System.out.println("传入的数据非法");
		}else {
			age = a;
		}
	}
	
	public int getAge() {
		return age;
	}
}
package com.itguigu.exer;

public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.setAge(12);
		System.out.println(p1.getAge());
	}
}

package com.itguigu.java;
/*
 * 类的结构之三：构造器（或构造方法，constructor）的使用
 * 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("Tom");
		System.out.println(p1.name);
	}
}

class Person{
	//属性
	String name;
	int age;
	//构造器
	public Person() {
		System.out.println("Person()...");
	}
	
	public Person(String n) {
		name = n;
	}
	
	public Person(String n, int a) {
		name = n;
		age = a;
	}
	
	//方法
	public void eat() {
		System.out.println("人吃饭");
	}
	
	public void study() {
		System.out.println("人可以学习");
	}
}

package com.itguigu.exer;

public class Triangle {
	private double base;
	private double height;
	
	public Triangle() {
		
	}
	
	public Triangle(double b, double h) {
		base = b;
		height = h;
	}
	
	public void setBase(double b) {
		base = b;
	}
	
	public double getBase() {
		return base;
	}
	
	public void setHeight(double h) {
		height = h;
	}
	
	public double getHeight() {
		return height;
	}
}
package com.itguigu.exer;

public class TriangleTest {
	public static void main(String[] args) {
		Triangle t1 = new Triangle();
		t1.setBase(2.0);
		t1.setHeight(2.4);
		System.out.println(t1.getBase() + "," + t1.getHeight());
		
		Triangle t2 = new Triangle(5.1, 5.2);
		System.out.println(t1.getBase() + "," + t1.getHeight());
	}
}

package com.itguigu.java;
/*
 * 总结属性赋值的先后顺序
 * 1、默认初始化值
 * 2、显式初始化
 * 3、构造器中初始化
 * 
 * 4、通过“对象.方法”或"对象.属性"的方式赋值
 * 
 * 以上操作的先后顺序：1->2->3->4
 */
public class UserTest {
	public static void main(String[] args) {
		User u = new User();
		
		System.out.println(u.age);
		
		User u1 = new User(2);
		
		u1.setAge(3);
		
		System.out.println(u1.age);	
	}
}

class User{
	String name;
	int age=1;
	
	public User() {
		
	}
	
	public User(int a) {
		age = a;
	}
	
	public void setAge(int a) {
		age = a;
	}
}

package com.itguigu.java;
/*
 * JavaBean是一种Java语言写成的可重用组件。
 * 所谓javaBean，是指符合如下标准的Java类：
 * 1、类是公共的。
 * 2、有一个无参的公共构造器。
 * 3、有属性，且有对应的get、set方法。
 * 
 * 默认构造器的权限修饰符和类的权限一样
 */
public class Customer {
	private int id;
	private String name;
	
	public Customer() {
		
	}
	
	public void setId(int i) {
		id  = i;
	}
	
	public int getId() {
		return id;
	}
	
	public void setName(String n) {
		name = n;
	}
	
	public String getName() {
		return name;
	}
}

package com.itguigu.java1;
/*
 * this关键字的使用
 * 1、this可以用来修饰、调用：属性、方法、构造器。
 * 
 * 2、this修饰属性和方法。
 * 	this理解为当前对象，或当前正在创建的对象
 * 	在类的方法中，我们可以使用“this.属性”,"this.方法"的方式，调用当前对象的属性和方法。但是，通常情况下，我们都选择省略"this."
 * 	特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
 *
 *3、this调用构造器
 * （1）我们在类的构造器中，可以显式的使用"this(形参列表)"方法，调用本类中指定的其他构造器。
 * （2）构造器中不能通过"this(形参列表)"方式调用自己。
 * （3）如果一个类中有n个构造器，最多有n-1个构造器使用"this(形参列表)。
 * （4）规定："this(形参列表)"必须声明在当前构造器的首行。
 * （5）构造器内部：最多只能声明一个"this(形参列表)"用来调用其他构造器。
 */
public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.setAge(1);
		System.out.println(p1.getAge());
	}
}

class Person{
	private String name;
	private int age;
	
	public Person() {
		
	}
	
	public Person(String name) {
		this();
		this.name = name;
	}
	
	public Person(int age) {
		this();
		this.age = age;
	}
	
	public Person(String name, int age) {
		this(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;
	}
}

package com.itguigu.exer;

public class boy {
	private String name;
	private int age;
	
	public boy() {
		
	}
	
	public boy(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public void marry(girl girl) {
		System.out.println(girl.getName());
	}
	
	public void shout() {
		if(this.age>=22) {
			System.out.println("你可以去合法等级结婚类！");
		}else {
			System.out.println("先多谈谈恋爱");
		}
	}
}

package com.itguigu.exer;

public class girl {
	private String name;
	private int age;
	
	public girl() {
		
	}
	
	public girl(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public void marry(boy boy) {
		System.out.println(boy.getName());
		boy.marry(this);
	}
	
	public int compare(girl girl) {
		if(this.age > girl.age) {
			return 1;
		}else if(this.age < girl.age) {
			return -1;
		}else {
			return 0;
		}
	}
}

package com.itguigu.exer;

public class Account {
	private int id;
	private double balance;
	private double annualInterestRate;
	
	public Account(int id, double balance, double annualInterestRate) {
		this.id = id;
		this.balance = balance;
		this.annualInterestRate = annualInterestRate;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public double getBalance() {
		return balance;
	}

	public void setBalance(double balance) {
		this.balance = balance;
	}

	public double getAnnualInterestRate() {
		return annualInterestRate;
	}

	public void setAnnualInterestRate(double annualInterestRate) {
		this.annualInterestRate = annualInterestRate;
	}
	
	public void withdraw(double amount) {
		if(balance < amount) {
			System.out.println("余额不足");
			return;
		}
		
		balance -= amount;
		System.out.println("成功取出" + amount);
	}
	
	public void deposit(double amount) {
		if(amount > 0) {
			balance += amount;
			System.out.println("成功存：" + amount);
		}
	}
	
}

package com.itguigu.exer;

public class Customer {
	private String firstName;
	private String lastName;
	private Account account;
	
	public Customer(String firstName, String lastName) {
		this.firstName = firstName;
		this.lastName = lastName;
	}

	public Account getAccount() {
		return account;
	}

	public void setAccount(Account account) {
		this.account = account;
	}

	public String getFirstName() {
		return firstName;
	}

	public String getLastName() {
		return lastName;
	}
}

package com.itguigu.exer1;

public class Account {
	private double balance;
	
	public Account(double init_balance) {
		this.balance = init_balance;
	}
	
	public double getBalance() {
		return this.balance;
	}
	
	public void deposit(double amt) {
		if(amt > 0) {
			balance += amt;
			System.out.println("存钱成功");
		}
	}
	
	public void withdraw(double amt) {
		if(balance >= amt) {
			balance -= amt;
			System.out.println("取钱成功");
		}else {
			System.out.println("余额不足");
		}
	}
}

package com.itguigu.exer1;

public class Customer {
	private String firstName;
	private String lastName;
	private Account account;
	
	public Customer(String firstName, String lastName) {
		this.firstName = firstName;
		this.lastName = lastName;
	}

	public Account getAccount() {
		return account;
	}

	public void setAccount(Account account) {
		this.account = account;
	}

	public String getFirstName() {
		return firstName;
	}

	public String getLastName() {
		return lastName;
	}
	
	
}

package com.itguigu.exer1;

public class Bank {
	 private Customer[] customers;
	 private int numberOfCustomers;
	 
	 public Bank() {
		 customers = new Customer[10];
	 }
	 
	 public void addCustomer(String f, String l) {
		 Customer cust = new Customer(f, l);
		 customers[numberOfCustomers++] = cust;
	 }
	 
	 public int getNumberOfCustomers() {
		 return this.numberOfCustomers;
	 }
	 
	 public Customer getCustomer(int index) {
		 if(index >=0 && index < numberOfCustomers) {
			 return customers[index];
		 }else {
			 return null;
		 }
	 }
}

package com.itguigu.java1;

import java.util.Arrays;

/*
 * 一、Package关键字的使用
 * 1、为了更好的实现项目中类的管理，提供类包的概念。
 * 2、使用package声明类或接口所属的包，声明在源文件的首行。
 * 3、包，属于标识符，遵循标识符的命名规则和规范。
 * 4、每"."一次，就代表一层文件目录。
 * 
 * 补充：同一个包下，不能命名同名的接口、类。
 * 		不同的包下，可以命名同名的接口、类。
 * 
 * 二、import关键字的使用
 * 1、import：导入，在源文件中显式的使用import结构导入指定包下的类、接口
 * 2、声明在包的声明和类的声明之间。
 * 3、如果要导入多个结构，并列写即可。
 * 4、可以使用"xxx.*"的方式表示可以导入xxx包下的所有结构。
 * 5、如果使用的类或接口是java.lang包下定义的，可以省略import结构。
 * 6、如果使用的类或接口是本包下定义的，则也可以省略。
 * 7、如果在源文件中，使用类不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
 * 8、如果使用"xxx.*"方式表明可以调用xxx包下的所有结构，但是如果使用的是xxx子包下的结构
 * 则仍需要导入。
 * 9、import static: 导入指定类或接口中的静态结构：属性或方法。
 */
public class PackageImportTest {
	public static void main(String[] args) {
		System.out.println(Arrays.toString(new int[] {1,2,3}));
	}
}