尚硅谷java零基础入门从221p开始的笔记
尚硅谷java零基础入门从221p开始的笔记
221*** 面向对象上四种权限修饰的理解
封装性的体现需要权限修饰符来配合
1.java规定的四种权限（从小到大排列）
private，缺省，protected，public
public类可以在任意地方被访问
private类内部
缺省 类内部 同一个包
protected 类内部 同一个包 不同包的子类
四种权限可以修饰类及类的内部结构：属性，方法，构造器，内部类
修饰类的话只能使用：缺省，public
222 四种权限修饰的测试
public class Order {
private int orderPrivate;
int orderDefault;
public int orderPublic;
private void methodPrivate(){
orderPrivate=1;
orderDefault=2;
orderPubilc=3;
}
void methodDefault(){
orderPrivate=1;
orderDefault=2;
orderPubilc=3;
}
public void methodPublic(){
orderPrivate=1;
orderDefault=2;
orderPubilc=3;
}
}
public class OrderTest {
public static void main(String[] args) {
Order order=new Order;
order.orderDefault=1;
order.orderPublic=2;
//私有的结构不能调用
order.orderPrivate=3;
order.methodDefault();
order.methodPublic();
}
总结封装性
java提供了四种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构再被调用时的可见性的大小
223 封装性练习基本使用
/*
1.创建程序,在其中定义两个类：Person 和 PersonTest 类。
定义如下：用 setAge()设置人的合法年龄(0~130)，用 getAge()返回人的年龄。
*/
//设置
public class Person {
private int age;
public void setAge(int a){
if(a<0||a>130){
System.out.println("传入的数据非法!");
return;
}
age=a;
}
//获取
public int getAge(){
return age;
}
/*
在 PersonTest 类中实例化 Person 类的对象 b，
调用 setAge()和 getAge()方法，体会 Java 的封装性。
*/
public class PersonTest{
public static void main(String[] args) {
Person p1=new Person();
//p1.age=1; 编译不通过
p1.setAge(12);\
System.out.println("年龄为:"+p1.getAge());
}
}
224 构造器的基本理解
任何一个类都有构造器
类的结构之三：构造器
constructor：建设，建造，建设者
construction
一:构造器的作用
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("人可以学习");
}
}
226 构造器练习：基本使用
/* 2.在前面定义的 Person 类中添加构造器，
* 利用构造器设置所有人的 age 属性初始值都为 18。 * */
public class Person{
private int age;
public Person(){
age=18;
}
public class PersonTest{
public static void main(String[] args){
Person p1=new Person();
System.out.println("年龄为:"+p1.getAge());
}
}
/* 3.修改上题中类和构造器，增加 name 属性, *
使得每次创建 Person 对象的同时初始化对象的 age 属性值和 name 属性值。 */
public class Person{
private int age;
private String name;
public Person(){
age=18;
}
public Person(String n,int a){
name=n;
age=a;
}
\\封装性
public void setName(String n){
name=n;
}
public String getName(){
return name;
}
\\测试层面
public class PersonTest {
public static void main(String[] args){
Person p1=new Person();
p1.setAge(12);
System.out.println("年龄为:"+p1.getAge());
Person p2=new Person("Tom',21);
System.out.println("name="+p2.getName()+",age="+p2.getAge);
}
227 构造器练习三角形
/*
* 编写两个类，TriAngle 和 TriAngleTest，
* 其中 TriAngle 类中声明私有的底边长 base 和高 height，同时声明公共方法访问私有变量。
* 此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。
*
*/
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;
}
\\测试
public class TriAngleTest{
public static void main(String[] args){
TriAngle t1=new TriAngle();
t1.setBase(2.0);
t1.setHeight(2.4);
System.out.println("base:"+t1.getbase()+",height"+t1.getHeight());
TriAngle t2=new TriAngle(5.1,5.6);
System.out.println("base:"+t2.getbase()+",height"+t2.getHeight());
}
}
228 总结属性赋值的过程
//总结属性赋值的先后顺序
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;
}
229 javabean的使用
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;
}
}
230 介绍UML类图
231 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 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;
}
this关键字的使用
1.this可以用来修饰属性，方法，构造器
2.this修饰属性和方法：
this理解为：当前对象 或当前正在创建的对象
2.1在类的方法中可以使用"this.属性"或 "this.方法"的方式，调用当前对象属性或方法，但是，通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用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.age=age;
}
public Person(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;
}
232 this调用构造器
3.this调用构建器
3.1我们在类的构造器中，可以显式的使用this（形参列表）方式，调用本类中指定的其他构造器
构造器中不能通过this形参列表
如果一个类中有n个构造器，则最多有n-1构造器中使用了this形参列表
规定：this形参列表必须声明在当前构造器的首行
构造器内部：最多只能声明一个形参列表，用来调其他的构造器
233 this练习 boy和girl
public class Boy{
private String name;
private int 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(age>=22){
System.out.println("你可以去合法登记结婚了");
}else{
System.out.println("先多谈谈恋爱");
}
}
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);
}
//比较两个对象的大小
//正数：当前对象大；负数：当前对象小；0：当前对象与形参对象相等
public int compare(Girl girl){
if(this.age>girl.age){
return 1;
}else if(this.age<girl.age){
return -1;
}else{
return 0;
}
}
return this.age-girl.age;
//测试
public class BoyGirlTest{
public static void main(String[] args){
Boy boy=new Boy("罗密欧",21);
boy.shout();
Girl girl=new Girl("朱丽叶",18);
girl.marry(boy);
Girl girl1=new Girl("祝英台",19);
int compare=girl.compare(girl1);
if(compare>0){
System.out.println(girl.getName()+"大");
}else if(compare>0){
System.out.println(girl1.getName()+"小");
}else{
System.out.println("一样大");
}
}
}
234 综合练习1 account和customer
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);
}
}
public class Customer{
private String firstname;
private String lastname;
private Account account;
public Customer(String f,String l){
this.firstName=f;
this.lastName=1;
}
public Account getAccount(){
return account;
}
public void setAccount(Account account){
this.account=account;
}
public String getFirstname(){
return firstname;
}
public String getLastName(){
return lastname;
}
//测试
/*
* 写一个测试程序。
* （1）创建一个 Customer，名字叫 Jane Smith, 他有一个账号为 1000，
* 余额为 2000 元，年利率为 1.23％的账户。
* （2）对 Jane Smith 操作。存入 100 元，再取出 960 元。再取出 2000 元。
* 打印出 Jane Smith 的基本信息
*
* 成功存入：100.0
* 成功取出：960.0
* 余额不足，取款失败
* Customer [Smith, Jane] has a account: id is 1000,
* annualInterestRate is 1.23％, balance is 1140.0
*
*/
public class CustomerTest{
public static void main(String[] args){
Customer cust=new Customer("Jane","Smith");
Account acct=new Account(1000,2000,0.0123);
cust.setAccount(acct);
cust.getAccount().deposit(100);
cust.getAccount().withdraw(960);
cust.getAccount().withdraw(2000);
System.out.println("Customer["+cust.getLastname()+","+cust.getFirstName()+"] has a
account:id is"+cust.getAccount().getId()+",annualInterestRate is"+cust.getAccount().getAnnualInterestRate()*100+"%,balance is "+cust.getAccount().getBalance());
}
}
235 综合练习2 对象数组
public class Account{
private double balance;
public Account(double init_balance){
this.balance=init_balance;
}
public double getBalance(){
return 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("余额不足");
}
}
public class Customer{
private String firstName;
private String lastName;
private Account account;
public Customer(String f,String l){
this.firstName=f;
this.lastName=l;
}
public Account getAccount(){
return account;
}
public void setAccount(Account account){
this.account=account;
}
public String getFirstName(){
return firstName;
}
public String getLastName(){
return lastName;
}
}
}
public class Bank{
private Customer[] customers;//存放多个客户的数组
private int numberOfCustomers;//记录客户的个数
public Bank(){
}
//添加客户
public void addCustomer(String f,String l){
Customer cust=new Customer(f,l);
customers[numberOfCustomers]=cust;
numberOfCustomers++;
//customers[numberOfCustomers++]=cust;
}
//获取客户的个数
public int getNumOfCustomers(){
return getNumOfCustomers;
}
//获取指定位置上的客户
public Customer getCustomer(int index){
if(index>=0&&index<numberOfCustomers){
return customers[index];
}
return null;
}
public class BankTest{
public static void main(String[] args){
Bank bank=new Bank();
bank.addCustomer("Jane","Smith");
bank.getCustomer(0).setAccount(new Account(2000));
bank.getCustomer(0).getAccount().withdraw(500);
double balance=bank.getCustomer(0).getAccount.getBalance();
System.out.println("客户："+bank.getCustomer(0).getFirstName()+"的账户余额
为；"+balance);
System.out.println("**********");
bank.addCustomer("万里","杨");
System.out.println("银行客户的个数为："+bank.getNumOfCustomers());
}
}
236 package关键字的使用
一，package关键字的使用
1.为了更好的实现项目中类的管理，提供包的概念
2.使用package声明类或接口所属的包，声明在源文件的首行
3.包，属于标志符，遵循标志符的命名规则，规范，见名知意
4.每"."一次,就代表一层文件目录
补充：同一个包下，不能命名同名的接口，类
不同的包下，可以命令同名的接口，类
1.java.lang----包含一些 Java 语言的核心类，如 String、Math、Integer、System 和 Thread，提供常用功能
2.java.net----包含执行与网络相关的操作的类和接口。
3.java.io----包含能提供多种输入/输出功能的类。
4.java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
5.java.text----包含了一些 java 格式化相关的类
6.java.sql----包含了 java 进行 JDBC 数据库编程的相关类/接口
7.java.awt----包含了构成抽象窗口工具集（abstractwindowtoolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。B/S C/S
237 MVC设计模式的理解
MVC 是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。
238 import关键字的使用
import java.util.*;
import account2.Bank;
/*
* 二、import关键字的使用
* import:导入
* 1.在源文件中显式的使用import结构导入指定包下的类、接口
* 2.声明在包的声明和类的声明之间
* 3.如果需要导入多个结构，则并列写出即可
* 4.可以使用"xxx.*"的方式,表示可以导入xxx包下的所有结构。
* 5.如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
* 6.如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
* 7.如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
* 8.import static组合的使用：调用指定类或接口下的静态的属性或方法.
*
*/
public class PackageImportTest {
public static void main(String[] args) {
String info = Arrays.toString(new int[]{1,2,3});
Bank bank = new Bank();
ArrayList list = new ArrayList();
HashMap map = new HashMap();
Scanner s = null;
System.out.println("hello");
UserTest us = new UserTest();
- 点赞
- 收藏
- 关注作者
评论（0）