心若有阳光 你便会看见这个世界有那么多美好值得期待和向往
2024/4/9
13.static 用于修饰属性和方法 static属性通过类名访问
1)static实现内存共享
bean1和bean2的内存是互相独立的 怎么实现内存共享呢?
共享内存
public class Comm {
public static float money;
}
public class HomeMember {
private String name;
private String sex;
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 void store(float c){
Comm.money=Comm.money+c;
}
public void consumer(float c){
Comm.money=Comm.money-c;
}
}
public class Test {
public static void main(String[] args) {
HomeMember homeMember=new HomeMember();
homeMember.setName("zhangsan");
homeMember.store(3000);
HomeMember homeMember1=new HomeMember();
homeMember1.setName("lisi");
homeMember1.consumer(1000);
System.out.println(Comm.money);
}
}
练习:学校的资金 共享
public class Expend {
public static double money;
}
public class School {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void paid(double d){
Expend.money=Expend.money-d;
}
public void income(double d){
Expend.money=Expend.money+d;
}
}
public class Test1 {
public static void main(String[] args) {
School school=new School();
school.setName("shandong");
school.income(234556);
School school1=new School();
school1.setName("guanli");
school1.paid(2763);
System.out.println(Expend.money);
}
}
2)为静态属性初始化赋值 需要用静态块
3)静态方法:写了static之后 这个方法就不再属于某个对象了 可以直接使用类名.来调用
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateUtils {
//Date yyyy-mm-dd hh:mm:ss mi
//在开发当中 经常要用yyyy-mm-dd 2020-12-12
public static String toYYMMDD(Date date){//Alt+Enter导入类
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
String dt=sdf.format(date);
return dt;
}
//在开发当中 经常要用yyyy-mm-dd 2020-12-12
public String toYYMM(Date date){
SimpleDateFormat sdf=new SimpleDateFormat("YYYY-MM");
String dt=sdf.format(date);
return dt;
}
}
import java.util.Date;
public class Test2 {
public static void main(String[] args) {
// DateUtils dateUtils=new DateUtils();
// String dt=dateUtils.toYYMMDD(new Date());
// System.out.println(dt);
String dt=DateUtils.toYYMMDD(new Date());
System.out.println(dt);
String dt1=DateUtils.toYYMM(new Date());
System.out.println(dt1);
}
}
以前我们调用方法需要创建对象 现在我们可以直接使用类名来调用(static)
14.final
final放到类上 不能被继承
final放到方法上 不能被重写
final放到属性上 不能被更改
15.StringBuffer(String)
执行速度慢 线程安全
执行速度快 线程不安全
public class Test {
public static void main(String[] args) {
String str="xxx";
//方法有synchronized关键字
//同步 先来先调用 后来后调用
StringBuffer stringBuffer=new StringBuffer("aa");
stringBuffer.append("bb");
stringBuffer.append("cc");//动态添加
stringBuffer.append("dd");
System.out.println(stringBuffer);
//方法没有synchronized关键字
StringBuilder stringBuilder=new StringBuilder("aa");
stringBuilder.append("bb");
stringBuilder.append("cc");
stringBuilder.append("dd");
}
}
16.接口(父类的思想 接口相当于父类 )
1)创建接口 右键 Ixxxxx(如IStudentDAO)
2)接口中只放方法的声明
3)创建实现类 实现接口
4)创建接口的原因(好处):松耦合 保证架构的稳定 使我们在维护的时候 改变的代码最少(父类的思想 接口相当于父类 )
为什么不选择父类而选择接口呢?
因为父类中的是通用方法 子类只能调用父类的方法 而接口的类中都有方法的实现 可以调用所有的方法 所以说 开发当中 接口用的比较多
//开发的时候:通过接口 implements就是为声明加{} 实现
public class StudentDao implements IStudentDAO{
//几十个参数
public void addStu(Student stu){
System.out.println(stu.getStuName()+" "+stu.getStuSex()+" "+stu.getStuAge());
}
}
public interface IStudentDAO {
//接口中只放方法的声明
//先声明 在创建DAO类 实现方法
public void addStu(Student stu);
}
2024/4/10
练习:课程 使用接口
1.创建接口 放上方法的声明
import java.util.ArrayList;
public interface ICourseDAO {
public void addCou(Course course);
public void updateCou(Course course);
public ArrayList<Course> findallCous();
}
2.创建实体类 包括 属性 get set 方法
public class Course {
private int cid;
private String cname;
public int getCid() {
return cid;
}
public void setCid(int cid) {
this.cid = cid;
}
public String getCname() {
return cname;
}
public void setCname(String cname) {
this.cname = cname;
}
}
3.写主方法
import java.util.ArrayList;
public class Test2 {
public static void main(String[] args) {
ICourseDAO courseDAO=new CourseDao();
Course c=new Course();
c.setCid(3);
c.setCname("lis");
courseDAO.addCou(c);
Course c1=new Course();
c1.setCid(4);
c1.setCname("maliu");
courseDAO.updateCou(c1);
ArrayList<Course> list=courseDAO.findallCous();
//增强for循环
for (Course course : list) {
System.out.println(course.getCid()+" "+course.getCname());
}
}
}
练习:新闻 使用接口
1.创建实体类
public class New {
private String nsme;
private String content;
public String getNsme() {
return nsme;
}
public void setNsme(String nsme) {
this.nsme = nsme;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
2.创建接口 放上方法的声明
import java.util.ArrayList;
public interface INewDAO {
public void addNew(New n);
public void updateNew(New n);
public ArrayList<New> findallNews();
}
import java.util.ArrayList;
3.创建实现类 为声明添加实现
public class NewDao implements INewDAO{
public void addNew(New n){
System.out.println(n.getNsme()+" "+n.getContent());
}
public void updateNew(New n){
System.out.println(n.getNsme()+" "+n.getContent());
}
public ArrayList<New> findallNews(){
ArrayList<New> list=new ArrayList<>();
New n1=new New();
n1.setNsme("社会");
n1.setContent("外交会见");
list.add(n1);
New n2=new New();
n2.setNsme("天气");
n2.setContent("炎热无比");
list.add(n2);
return list;
}
}
4.创建测试类
import java.util.ArrayList;
public class Test3 {
public static void main(String[] args) {
INewDAO newDAO=new NewDao(); //父类可以接收子类的对象
New n1=new New();
n1.setNsme("政策");
n1.setContent("贷款5000玩");
newDAO.addNew(n1);
New n2=new New();
n2.setNsme("心灵鸡汤");
n2.setContent("勇敢迈出脚步");
newDAO.updateNew(n2);
ArrayList<New> list=newDAO.findallNews();
for (New aNew : list) {
System.out.println(aNew.getNsme()+" "+aNew.getContent());
}
}
}
练习: 教师 使用接口
1.创建实体类
public class Teacher {
private int tid;
private String tname;
public int getTid() {
return tid;
}
public void setTid(int tid) {
this.tid = tid;
}
public String getTname() {
return tname;
}
public void setTname(String tname) {
this.tname = tname;
}
}
import java.util.ArrayList;
2.创建接口 放入方法的声明
public interface ITeacherDAO {
public void addTeacher(Teacher t);
public void updateTeacher(Teacher t);
public ArrayList<Teacher> findallTeachers();
}
3.创建实现类 为声明添加实现
import java.util.ArrayList;
public class TeacherDao implements ITeacherDAO{
@Override
public void addTeacher(Teacher t) {
System.out.println(t.getTid()+" "+t.getTname());
}
@Override
public void updateTeacher(Teacher t) {
System.out.println(t.getTid()+" "+t.getTname());
}
@Override
public ArrayList<Teacher> findallTeachers() {
ArrayList<Teacher> list=new ArrayList<>();
Teacher t1=new Teacher();
t1.setTid(1);
t1.setTname("zhangsan");
list.add(t1);
Teacher t2=new Teacher();
t2.setTid(2);
t2.setTname("lisi");
list.add(t2);
return list;
}
}
4.测试类
import java.util.ArrayList;
public class Test4 {
public static void main(String[] args) {
ITeacherDAO teacherDAO=new TeacherDao();
Teacher t3=new Teacher();
t3.setTid(3);
t3.setTname("wangwu");
teacherDAO.addTeacher(t3);
Teacher t4=new Teacher();
t4.setTid(4);
t4.setTname("maliuu");
teacherDAO.updateTeacher(t4);
ArrayList<Teacher> list=teacherDAO.findallTeachers();
for(int i=0;i<list.size();i++){
Teacher t=list.get(i);
System.out.println(t.getTid()+" "+t.getTname());
}
}
}
相信自己 你能作茧自缚 就能破茧成蝶
雾都不起风
太阳升起时你未曾离开 太阳落下时希望你依然还在.
公众号