文章目录
- 1.面向对象基本概念
- 2.类与对象
- 3.类和对象的定义格式
- 4.对象内存分析
- 5.封装性
- 6.构造方法
- 7.this关键字
- 8.值传递与引用传递
- 9.对象的一对一关系
- 10.static关键字
- 11.main方法分析
- 12.代码块
- 13.单例设计模式
- 14.对象数组与管理
1.面向对象基本概念
2.类与对象
什么是类?
3.类和对象的定义格式
注意:类是类别,分类的意思,所以类不是一个具体的事物,类代表一类事物,类的结果规则需要记住.
在JAVA中可以使用以下的语句定义一个类:
class 类名称{
属性名称;
返回值类型 方法名称(){}
}
/**
2022-2-18
面向过程,以步骤为单位,U一步一步完成某一个具体事情
面向对象,以对象为单位,通过调度组合不同的对象来完成某一个事情
*/
public class Test26{
public static void main(String[] args){
Horse h=null;//声明一个类的变量(除了八种基本数据类型以外,都是引用数据类型,包括数组)
//实例化对象,创建一个Horse类型的对象
h=new Horse();
//有了对象,我们就可以调用对象的属性和方法
h.name="赤兔马";
h.age=13;
h.run();//调用方法那么方法就会被执行
//匿名对象,只能使用一次,用完后,该对象就会被释放
new Horse().run();
h=null;//把对象释放掉
//当对象不存在时,调用该对象的属性和方法就会报错(空指针)
//空指针错误(java.lang.NullPointerException)
h.run();
}
}
//自定义一个类(类型)
class Horse{
//在类中定义属性(特征)
String name;
int age;
public void run(){
System.out.println("我是"+name+"\n年龄:"+age+"\n能力:日行千里!");
}
public void eat(){
System.out.println("吃的食物:优良的马草!");
}
}
4.对象内存分析
类与对象小结
5.封装性
封装的好处
模块化
信息隐藏
代码重用
插件化易于调试
具有安全性
封装缺点:
会影响执行效率
成员变量和局部变量
/**
2022-2-19
封装性
*/
public class Test27{
public static void main(String[] args){
Person p=new Person();
p.setName("萌萌");
System.out.println("名字是:"+p.getName());
}
}
//加上private就是进行封装了
class Person{
//属性的封装
private String name;//成员变量,在类中定义
private int age;//成员变量
//getter和setter
//对外提供一个可以访问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 run(int len){
int i;
int m=len;//m也是局部变量
System.out.println("我跑了"+m+"米");
System.out.println("年龄是"+age);
}
}
6.构造方法
构造方法小结
7.this关键字
/**
2022-2-19
构造方法
*/
public class Test28{
public static void main(String[] args){
Dog dog=new Dog();
Dog dog1=new Dog("汪汪",5);
}
}
class Dog{
//声明变量
private String name;
private int age;
//构造方法
public Dog(){
System.out.println("构造方法执行了");
}
public Dog(String name){
this.name=name;
System.out.println("带一个参数的构造方法被执行了!");
}
public Dog(String name,int age){
this(name);
//调用其他构造方法时,此语句需要在第一句,在构造方法相互调用时必须要有出口
this.age=age;
System.out.println("带两个参数的构造方法被执行了!");
//this(name);错误,必须先写this
}
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;
}
}
8.值传递与引用传递
9.对象的一对一关系
/**
2022-2-19
两个对象之间的一对一关系:
比如:一个英雄对一个兵器
代码如何表示?
双向一对一
单向一对一
*/
public class Test29{
public static void main(String[] args){
Hero hero=new Hero("刘备",200);
Weapon weapon=new Weapon("双锤",4);
//把两个对象关联起来
hero.setWeapon(weapon);
weapon.setHero(hero);
//通过英雄来获取他的信息
String name=hero.getName();
int age=hero.getAge();
Weapon w=hero.getWeapon();
System.out.println("我是"+name+",我是"+age+"岁,我的武器是:"+w.getName()+",排行"+w.getGrade()+"级");
}
}
//英雄类
class Hero{
//声明变量
private String name;
private int age;
private Weapon weapon;
public Hero(){
}
public Hero(String name,int age){
this.name=name;
this.age=age;
}
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 setWeapon(Weapon weapon){
this.weapon=weapon;
}
public Weapon getWeapon(){
return weapon;
}
}
class Weapon{
private String name;
private int grade;
private Hero hero;
public Weapon(){}
public Weapon(String name,int grade){
this.name=name;
this.grade=grade;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setGrade(int grade){
this.grade=grade;
}
public int getGrade(){
return grade;
}
public void setHero(Hero hero){
this.hero=hero;
}
public Hero getHero(){
return hero;
}
}
10.static关键字
static关键字的作用:
static使用总结
/**
2022-2-19
静态变量或方法不属于对象,依赖类
静态变量是全局变量,生命周期从类加载后一直到程序结束
静态变量只有存一份,在静态方法区存储
静态变量是本类所有对象共享一份
建议不要使用对象名去调用静态数据,直接使用类名调用
static修饰一个方法,那么该方法属于类,不属于对象,直接用类名调用
静态方法不能访问非静态属性和方法,只能访问静态
*/
public class Test30{
public static void main(String[] args){
Role liubei=new Role("刘备","蜀国");
Role yunchang=new Role("云长");
Role zhangfei=new Role("张飞");
liubei.getInfo();
yunchang.getInfo();
zhangfei.getInfo();
System.out.println("--------------------");
System.out.println(liubei.country);
System.out.println(yunchang.country);
System.out.println(zhangfei.country);
System.out.println("--------------------");
liubei.country="唐朝";
System.out.println(liubei.country);
System.out.println(yunchang.country);
System.out.println(zhangfei.country);
}
}
class Role{
private String name;
static String country;//静态全局变量
public Role(){}
public Role(String name){
this.name=name;
}
public Role(String name,String country){
this.name=name;
Role.country=country;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
//静态方法不能访问非静态的数据
public static void setCountry(String country){
Role.country=country;
}
public void getInfo(){
System.out.println("我的名字是:"+name+",国家是"+Role.country);
}
}
声明为static的方法有以下几限制:
什么时候使用static?
11.main方法分析
12.代码块
比如说:
13.单例设计模式
单例设计模式:保证一个类仅有一个实例,并提供一个访问它的全局访问点.
两种实现方式:
饿汉式:在第一次调用getInstance方法时,对象被创建,到程序结束后释放
懒汉式:在类被加载后,对象被创建,到程序结束后释放
/**
2022-2-20
*/
public class Test32{
public static void main(String[] args){
//Singleton1 s=new Singleton1();错误
Singleton1 s=Singleton1.getInstance();
s.print();
Singleton1 s1=Singleton1.getInstance();
s1.print();
System.out.println(s==s1);
Singleton2 s2=Singleton2.getInstance();
s2.print();
Singleton2 s3=Singleton2.getInstance();
s3.print();
System.out.println(s2==s3);
}
}
//饿汉式:占用内存的时间长,提高效率
class Singleton1{
private Singleton1(){}
private static Singleton1 s=new Singleton1();
public static Singleton1 getInstance(){
return s;
}
public void print(){
System.out.println("饿汉式测试方法!");
}
}
//懒汉式:占用内存时间短,效率稍低一点
//生命周期短一点
//在多线程访问时会有安全问题
class Singleton2{
private Singleton2(){}
private static Singleton2 s;
public static Singleton2 getInstance(){
if(s==null){
s=new Singleton2();
}
return s;
}
public void print(){
System.out.println("懒汉式测试方法!");
}
}
在项目中为什么要使用单例,单例有什么好处?
能不能使用构造方法私有化+静态方法来替代单例?
/**
2022-2-20
*/
public class Test32{
public static void main(String[] args){
//Singleton1 s=new Singleton1();错误
Singleton1 s=Singleton1.getInstance();
s.print();
Singleton1 s1=Singleton1.getInstance();
s1.print();
System.out.println(s==s1);
Singleton2 s2=Singleton2.getInstance();
s2.print();
Singleton2 s3=Singleton2.getInstance();
s3.print();
System.out.println(s2==s3);
}
}
//使用构造方法私有化,来实现工具类,比如Math
class Tools{
private Tools(){}
public static void print1(){
}
public static void print2(){
}
}
//饿汉式:占用内存的时间长,提高效率
class Singleton1{
private Singleton1(){}
private static Singleton1 s=new Singleton1();
public static Singleton1 getInstance(){
return s;
}
public void print(){
System.out.println("饿汉式测试方法!");
}
}
//懒汉式:占用内存时间短,效率稍低一点
//生命周期短一点
//在多线程访问时会有安全问题
class Singleton2{
private Singleton2(){}
private static Singleton2 s;
public static Singleton2 getInstance(){
if(s==null){
s=new Singleton2();
}
return s;
}
public void print(){
System.out.println("懒汉式测试方法!");
}
}
14.对象数组与管理
/**
2022-2-20
对象数组管理案例
动态数组:
1.数组是一种线性数据结构
2.数组不适合删除插入等操作,适合添加,查找,遍历
*/
import java.util.Arrays;
public class Test33{
public static void main(String[] args){
ChickenManger cm=new ChickenManger(5);
cm.add(new Chicken(1,"小小",10));
cm.add(new Chicken(2,"小二",9));
cm.add(new Chicken(3,"小三",8));
cm.add(new Chicken(4,"小四",7));
cm.add(new Chicken(5,"小五",6));
cm.add(new Chicken(6,"小六",5));
System.out.println("现在数组的长度是:"+cm.length());
System.out.println("-------------printAll------------");
cm.printAll();
System.out.println("------------find----------");
Chicken c=cm.find(6);
System.out.println(c.print());
System.out.println("--------------update----------------");
cm.update(new Chicken(1,"小王八",19));
cm.printAll();
System.out.println("-------------delete------------------");
cm.delete(2);
cm.printAll();
}
}
//小鸡管理类
class ChickenManger{
private Chicken[] cs=null;
private int count=0;//记录当前数组元素的个数(下标)
public ChickenManger(){}
public ChickenManger(int size){
if(size>0){
cs=new Chicken[size];
}
else{
cs=new Chicken[5];
}
}
public int length(){
return cs.length;
}
//添加,实现动态数组
public void add(Chicken c){
if(count>=cs.length){
//数组已满,需要扩充
//算法一:扩充原来的一半
int newLen=cs.length*2;
cs=Arrays.copyOf(cs,newLen);
//算法二:扩充原来的一倍
}
cs[count]=c;
count++;
}
//删除
public void delete(int id){
for(int i=0;i<count;i++){
if(cs[i].getId()==id){
//找到了要删除的对象,把该对象之后的对象向前移动一位
for(int j=i;j<count-1;j++){
cs[j]=cs[j+1];
}
//把最后一个对象赋值为空
cs[count-1]=null;
count--;//下标减一
break;
}
}
}
//更新
public void update(Chicken c){
Chicken temp=find(c.getId());
if(temp!=null){
temp.setName(c.getName());
temp.setAge(c.getAge());
}
}
//查找
public Chicken find(int id){
for(int i=0;i<count;i++){
if(cs[i].getId()==id){
return cs[i];
}
}
return null;
}
//输出所有
public void printAll(){
for(int i=0;i<count;i++){
System.out.println(cs[i].print());
}
}
}
//小鸡类(数据对象)value object(vo)
class Chicken{
private int id;
private String name;
private int age;
public Chicken(){}
public Chicken(int id,String name,int age){
this.id=id;
this.name=name;
this.age=age;
}
public void setId(int id){
this.id=id;
}
public int getId(){
return id;
}
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;
}
public String print(){
return "小鸡ID是"+id+",小鸡的名字是"+name+",月份是"+age;
}
}