看到MVC就想微信
import 导入的是包中的类，接口
先写出方法怎么用再将鼠标放上去点导入类
使用import java.util.*;可以导入这个包下的所有结构 但是没有util.子包.类的结构
如果调用的方法类是一样的只能：包名 变量名 =new 包名（形参）例如 com.atguigu.contact.Account account =new ........();这叫全类名的方式 （原始方法所以才有import）
import static java.lang.Math.*;是调用Math类中的静态结构：属性，方法
那么System.out.println();就可以简化为 out.println();
★同一个类中可以调用private
封装性：就是为了不擅自改变属性 例如.legs=-1很明显不能让它实现，也可以private 方法
eclipse快捷键：
ctrl +1为修复代码的错误 导包也可以的想象 修复代码永远是第一位所以1
shift + enter为切换到下一行想象 切换 + 下一行
alt+左 为返回ctrl 左键之前的页面
ctrl+t（tree）查看继承树（该类的父类和子类）
ctrl +y 反撤销
shift + tab 整体前移
alt shift r 为更改全部变量名字
package com.atguigu.contact;
import java.util.ArrayList;
public class Array { public static void main(String[] arSgs) { ArrayList list = new ArrayList(); int[] a = {1,2,3}; String str="hello"; list.add(str); String str2=new String("world");//这里与BigInteger一样 list.add(str2); list.remove(0);//被去除后world变成了第一个 System.out.println(list); for(int i : a) { System.out.println(i); } String str1 = list.get(0); System.out.println(str);//与a[i]不同这里完全是方法 System.out.println(list.size()); } }
String string ="hello";
if(string=="hello")
{
System.out.println("NO");
}//可行
但是char的时候必须==因为没有.equals可以用
syso中"\t"=='\t'
package com.atguigu.contact;
import java.util.Scanner;
import javax.imageio.stream.ImageInputStream; class Cust { private String name,sex,phone,mail; private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getMail() {
return mail;
}
public void setMail(String mail) {
this.mail = mail;
}
public Cust(String name, String sex, String phone, String mail, int age) {
this.name = name;
this.sex = sex;
this.phone = phone;
this.mail = mail;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
} class CustList//方便了 修改添加客户时的调用 { int num=0; // int num; // private Cust[] cust=new Cust[num];看下面第九行应该怎么写 private Cust[] cust;//用上了前面写的Cust
public CustList(int total)
{
cust=new Cust[total];//这里这么写是为了后面 custList 声明 ,（能用上Cust）
}
public boolean addCust(Cust cus)
{
if(num==cust.length)//这里是this中的cust不是输入的Cust cus
{
System.out.println("添加失败");
return false;
}else
{
cust[num++]=cus;
return true;
}
}
public boolean replaceCustomer(int index,Cust cus)//boolean类型的原因是判断如果是false则让其重新输入一个数据
{
if(index<0||index>=cust.length)
{
return false;
}else
{
cust[index]=cus;
return true;
}
}
public boolean deleteCust(int index)
{
if(index>=0&&index<num)
{
for (int i =index;i<num-1;i++)//★
{
cust[i]=cust[i+1];
}
cust[num-1]=null;//这里最后要-1
num--;//★
return true;
}else
{
System.out.println("请重新输入");
return false;
}
}
public Cust[] getAllCustomers()
{
//return cust;//不能直接返回就行
Cust[] cust1 = new Cust[num];//就像在main里面可以new构造器一样
for (int i =0;i<num;i++)
{
cust1[i]=cust[i];
}
return cust1;
}
public Cust getCustomer(int index)
{
if(index>=0&&index<num)
{
return cust[index];
}else
{
System.out.println("操作失败");
return null;
}
}
public int getNum()
{
return num;
}
} class CustView { CustList custList = new CustList(10);//这里不想CustList一样创造数组 public void addNewCustomer() {
System.out.println("---------------------添加客户---------------------");
System.out.print("姓名：");
String name = CMUtility.readString(4);
System.out.print("年龄：");
int age = CMUtility.readInt();
System.out.print("性别：");
String sex = CMUtility.readString(4);
System.out.print("电话：");
String phone = CMUtility.readString(13);
System.out.print("邮箱：");
String mail = CMUtility.readString(30);
Cust cus = new Cust(name, sex, phone, mail, age);
boolean isSuccess=custList.addCust(cus);//这两部很关键 牛逼 先录入数据再整体输入
if (isSuccess)
{
System.out.println("添加完成");
}else
{
System.out.println("客户已满");
}
}
public void deleteCustomer(int index)
{
custList.deleteCust(index);
}
public void listAllCustomers()
{
System.out.println("---------------------------客户列表---------------------------"); System.out.println("编号 姓名 性别 年龄 电话 邮箱"); if (custList.getNum()==0)//custList 时上面属性声明了 { System.out.println("没有客户记录");//★ }else { Cust[] customers=custList.getAllCustomers();//注意custList在此类声明了★为了调用每一个 for (int i=0;i<custList.getNum();i++)// { System.out.println(i+1+"\t"+customers[i].getName()+ "\t"+customers[i].getSex()+ "\t"+customers[i].getPhone()+ "\t"+customers[i].getMail());//这样好看
}
}
}
public void modifyCustomer()
{
System.out.println("-------------修改客户---------");
System.out.print("请选择编号");
int number;
Cust cust1;
while(true)//记得括号里有true
{
number =CMUtility.readInt();
if(number==-1)
{
return;
}
cust1=custList.getCustomer(number-1);
if(cust1!=null)
{
break;
}else
{
System.out.println("重新输入");
}
}//修改开始
System.out.println("姓名"+cust1.getName());
String name = CMUtility.readString(10, cust1.getName());
System.out.println("性别"+cust1.getSex());
String sex="male";
System.out.println("年龄"+cust1.getAge());//下面懒得写了
int age=19;
System.out.println("电话"+cust1.getPhone());
String phone="dasdsad";
System.out.println("邮箱"+cust1.getMail());
String mail="dassasd";
Cust newcust = new Cust(name, sex, phone, mail, age);
boolean isReplaced=custList.replaceCustomer(number-1, newcust);
if (isReplaced==true)
{
System.out.println("添加成功");
}else
{
System.out.println("添加失败");
}
} public void enterMainMenu() { int number; char menu; boolean flag=true; do { System.out.println("-----------------客户信息管理软件-----------------"); System.out.println(); System.out.println(" 1.添加客户"); System.out.println(" 2.修改客户"); System.out.println(" 3.删除客户"); System.out.println(" 4.客户列表"); System.out.println(" 5.退 出"); System.out.println(); System.out.print(" 请选择(1-5):"); menu=CMUtility.readMenuSelection();//这里是因为里面是static的
switch(menu)
{
case '1':
addNewCustomer();
break;
case '2':
modifyCustomer();
break;
case '3':
deleteCustomer(index);//未写具体，
case '4':
listAllCustomers();
break;
case '5':
System.out.print("是否确认退出");
char ch = CMUtility.readConfirmSelection();
if (ch=='y'||ch=='Y')
{
flag=false;//必须这么做 因为是通过flag来决定是否退出循环
System.out.println("成功退出");
}
}
}while(flag!=false);//保证界面循环
}
} class Test { public static void main(String[] args) { CustView custView = new CustView(); custView.enterMainMenu(); } }
package com.atguigu.contact;
public class Test1 { public static void main(String[] args) { Student student = new Student(); Teacher teacher = new Teacher(); System.out.println(student.age); System.out.println(teacher.age); teacher.eat(); teacher.sleep();
}
} class Student { int age=9; String name; public void sleep() { System.out.println("早点睡");
}
public void eat()
{
System.out.println("多吃长身体");
}
}
class Teacher extends Student//类 第三人称extends 类 { String phone; public void work() { System.out.println("每天都要工作"); }
}
先子类（派生类 subclass）再父类（超类 superclass 基类）（只是子类有相同之处才有）
子类想要扩展时就很方便，也为多态性提供了前提
可以用父类的属性和方法
当有private继承时不能直接调用其属性 只能get set
一个子类只有一个父类：单继承性，多层继承 父-子（父）-子 第一个是第三个的间接父类 第二个是直接父类 （可以丰富功能）
.出来其它的方法就是 java.lang.Object里面的方法 这也是继承 应该不是调用 因为没有Object.方法（）
例如有一个类 Customer 并 Customer cust1 = new Customer(); Customer cust2 = new Customer(); cust1 = cust2 这时候cust1指向堆中地址变为cust2的指向的堆中地址但是不以为着cust1 cust2在栈中空间变为相同的 只是堆中指向的空间相同了
当程序出错时 可以适当添加 syso语句来判断是否正确
命名一定要规范
程序大了就一定要写文档注释 在类，方法前
Object类是根节点（根父类）
Integer.valueOf(str);
javabean 公无似 公共的类 公共的无参构造器 若属性私有化则set get
f5进入方法 f7出来方法 f6下一步 一般都用f6
f8执行到下一个断点
这个操作可以返回方法的首行
用f8让其执行结束
方法的重写：也叫覆盖 重置
在子类
中着方法叫重写的方法 在父类中叫被重写的方法
规定：
1.因为在重载哪里就是方法名和形参列表来区分是否重载所以这里重写时这两个必须一样，返回值类型可以是父类的 的子类 例如父类为Object 子类可以是 String
2.权限修饰符必须不小于父类中的（想象既然你要重写那作为代价你就必须公布于世）
3当父类中的方法为private时 无法进行重写（因为连调用都不行）
但开发的时候不用考虑这么详细直接粘贴复制 声明， 方法体再重新写就行了
★4.当父类方法为static时不能再子类重写（想象静态所以不能被再次动态改写）
当子类重写父类的方法后 子类不能再用父类的 就算这个重写在后面
不同包中的子类可以 调用protected 但是不同包中的不是子类的之后调用public(想公共包即能够跨包使用)
调用this时因为属性与形参重复了(方法名称也可能与形参重复) super时子类的重写方法把父类的覆盖了
super 与this相似理解为父类的。。。。可以调用父类的方法属性和构造器
package com.atguigu.contact;
public class Test1 { public static void main(String[] args) { Student student = new Student(); Teacher teacher = new Teacher();
teacher.work();
teacher.eat();
student.eat();
teacher.sleep();
}
} class Student { private int age=9; String name; public void setAge(int age) { this.age = age; } public int getAge() { return age; } public void sleep() { System.out.println("早点睡"); } public void eat() { System.out.println("多吃长身体"); } }
class Teacher extends Student//类 第三人称extends 类 { String phone;
public void work()
{
System.out.println("每天都要工作");
setAge(10);
System.out.println(getAge());//因为这里age声明了private所以必须要先set 再get，证明继承了age
}
@Override
}
1.子类调用父类时 用父类的属性时也省略了this
子类中定义与父类一样的属性例如id则不会覆盖，则一旦输出id就会自动输出子类的而不是父类的
System.out.println(this.age);//直接age也可以说明时先在自己里面找没有才去父类由1.可知
System.out.println(super.age);//直接在父类找
super.与this.一样一般都省略 除非有重复的
用super。叫显示调用
其实属性和方法都可以重写 只不过要用重写后的可以省略this 用父类就直接super
super()跟this()时一样的 我们在构造器中只能选择一个this（） super（）中一个 因为必须在首行就算不写也会有默认的super（）在子类构造器中（想象父类担心子类无法弄好构造器所以默认super（））所以当父类没有无参构造时而且子类中有默认super（）时就会报未定义隐式超构造函数 Student（）。必须显式调用另一个构造函 数
当然写了this就没有super了 子类中有默认super（出现原因时因为extends了构造器）
正因为加载了构造器所以才有父类的方法属性
new+构造器才能造对象
不同方法中可以定义名称一样的变量 （这是常识）
写一个最基础的类比如Customer Account 都是 private属性 setget 构造器覆盖全部属性
package com.atguigu.contact;
import java.util.Scanner;
/*
-
要求：写一个用户程序测试 CheckAccount 类。在用户程序中，创建一个账号为 1122、余 额为 20000、年利率 4.5%，可透支限额为 5000 元的 CheckAccount 对象。 使用 withdraw 方法提款 5000 元，并打印账户余额和可透支额。 再使用 withdraw 方法提款 18000 元，并打印账户余额和可透支额。 再使用 withdraw 方法提款 3000 元，并打印账户余额和可透支额。 */ public class AccountTest { public static void main(String[] args) { CheckAccount checkAccount = new CheckAccount(1122, 20000,0.045,5000); Scanner scanner = new Scanner(System.in); int money = scanner.nextInt(); while(money!=0) {
checkAccount.withdraw(money); if(checkAccount.overdraft>=0) { System.out.println("您的账户余额:"+checkAccount.getBalance()); System.out.println("您的可透支额："+checkAccount.overdraft); } else { System.out.println("超过可透支限额"); System.out.println("您的账户余额:"+checkAccount.getBalance()); System.out.println("您的可透支额："+checkAccount.overdraft); }}
} } class Account { private int id; private double balance,annualInterestRate;
public Account(int id, double balance, double annualInterestRate) {
this.id = id; this.balance = balance; this.annualInterestRate = annualInterestRate;
} public Account() {
} 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("余额不足"); }else { balance-=amount; } } public void deposit(double amount) { balance+=amount; }
} class CheckAccount extends Account { double overdraft;
public CheckAccount(int id, double balance ,double annualInterestRate,double overdraft)
{
super(id, balance, annualInterestRate);
this.overdraft=overdraft;
}//★
// public CheckAccount(int id, double balance ,double annualInterestRate) // { // account =new Account(id, balance, annualInterestRate); // }//★ public void withdraw(double amount) { if(amount<getBalance()) {
setBalance(getBalance()-amount);
}else if(amount<=getBalance()+overdraft)
{
overdraft-=(amount-getBalance());
setBalance(0);
}else
{
overdraft=-1;
}
}
}
