课程大纲:
1.面向对象基本概念
2.类与对象
3.类与对象的定义格式
4.对象与内存分析
5.封装性
6.构造方法
7.this关键字
8.值传递与引用传递
9.对象的一对一关系
10.static关键字
11.main方法分析
12.代码块
13.单列设计模式
14.对象数组与管理
1.面向对象基本概念
一.什么是面向对象:
1.面向对象是一种编程思想.
2.面向对象是一种思考问题的思维方式
二.建立面向对象思维方式:
1.先整体,在布局
2.先抽象再具体
3.能做什么,再怎么做
三.如何学习面向对象:
1.掌握一门面向对象语言的语法
2.熟悉面向对象的设计原则
3.熟悉面向对象设计模式
2.类与对象
什么是类?
1.类是:分类,类别
2.通过分类,我们可以区别不同的事物种类,再日常生活中,我们常常这样做
3.所以,类是一种具有相同特性(属性)与行为(方法)的事物集合
类与对象的关系
1.类表示一个共性的产物,是一个综合的特征,而对象,是一个 个性的产物,是一个 个体的特征.
2.类由属性和方法组成:
属性:就相当于一个个的特征
方法:就相当于人的一个个的行为,例如:说话,唱歌,睡觉.
3.类和对象的定义格式
在java中可以使用以下的语句定义一个类
clss 类名称{
属性名称;
返回值类型 方法名称(){}
}
对象的定义:
一个类想要真正的进行操作,则必须依靠对象,对象的定义格式如下:
类名称对象名称 = new 类名称();
按照以上的格式就可以产生对象了。
如果要想访问类中的属性或方法(方法的定义)。
则可以依靠以下的语法形式:
访问类中的属性:
对象.属性;
访问类中的方法:
对象.方法();
在java中对象声明有两种含义
声明对象:Horse horse = null;
//表示声明了一个对象,但是此对象无法使用,horse没有具体的内存指向。
实例化对象:horse = new Horse();
//表示实例化了对象,可以使用
//通过对象调用方法:
hors.eat()
//匿名对象调用方法:
new Horse().eat()
/**
面向过程:以步骤为单位,一步一步完成某一个具体事情
面向对象:以对象为单位,通过调度组合不同的对象来完成某一个事情
*/
public class Test1{
public static void main(String[]args){
Horse h =null; //声明一个类的变量(除了8种基本数据类型以外,都是引用数据类型,包括数组)
//创建一个Horse类型的对象,实例化对象
h = new Horse();
//有了对象,我们就可以调用对象的属性和方法
h.name = "老八";
h.age = "牛逼";
h.run();//调用方法,那么方法就会被执行
h.eat();
//匿名对象:只能使用一次,用完后该对象会被释放
new Horse().eat();
h = null;//把对象释放
//h.eat();//当对象不存在时,调用该对象的属性和方法将报错(空指针)
}
}
//自定一个类(类型)
class Horse{
//在类中定义属性(特征)
String name;
String age;
public void run(){
System.out.println("我是"+name+",我可"+age+"了");
}
public void eat(){
System.out.println("我每天都吃奥里给,一天吃两斤,越吃越牛逼!");
}
}
4.对象内存分析
1.new关键字表示创建一个对象
2.new关键字表示实例化
3.new关键字表示申请内存空间
注意:如果使用一个没有申请内存空间的对象,会报空指针异常;
java.lang.NullPointerException
类与对象小结
1).new关键字,表示向内存申请空间,也表示实例化一个对象,创建一个对象.
2).一个对象在内存中的大小,由该对象的所有属性所占的内存大小的总和.引用类型变量在32位系统上占4个字节,在64位系统上占8个字节.加上而外的对象隐性数据所占的大小.
3).相同的类型猜可以赋值.
4).不同的引用,指向同一个对象,任何一个引用改变对象的值,其他引用都会反映出来.
5).编程时要注意的问题:在确定不使用对象时,要尽早释放对象:引用 = null;
6).当一个堆中的对象没有被任何引用变量所指向时,该对象会被JVM的GC程序认为是垃圾对象,从而被回收.
5.封装性
一.封装性的概念
1.封装性是面对对象思想的三大特点之一.
2.封装就是隐蔽实现细节,仅对外提供访问接口.
封装有:
属性的封装,方法的封装,类的封装,组件的封装,模块化封装,系统级封装...
二.封装的好处
1.模块化
2.信息隐藏
3.代码重用
4.插件化易于调试
5.具有安全性
封装缺点:
会影响执行效率
/**
封装性
如果属性没有封装,那么在本类之外创建对象后,可以直接访问属性
private关键字:访问权限修饰符,public(公开)private(私有的)私有的属性或方法只能在本类中访问;
公有的属性和方法可以被类外部 的其他类访问,想要在类外部访问私有属性,我们需要提供公有的方法来间接访问
通常在一个类中,属性都私有化,并对外提供getter and setter 方法
*/
public class Test2{
public static void main(String[]args){
person p1 = new person();
//p1.name = "菲菲";
//p1.age = 18;
p1.setName("菲菲");
p1.setAge(188);
}
}
//没有封装之前
class person{
//属性的封装
private String name;
private int age;
//getter and setter
//对外提供一个为name属性设值的方法
public void setName(String name){
this.name = name;
}
//对外提供一个获取name属性的方法
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
三.成员变量和局部变量
1.在类中的位置不同
成员变量:在类中定义
局部变量:在方法中定义或者方法的参数
2.在内存中的位置不同
成员变量:在堆内存(成员变量属于对象,对象进对内存)
局部变量:在栈内存(局部变量属于方法,方法进栈内存)
3.生命周期不同
成员变量:随着对象的创建而存在,随着对象的销毁而消失
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
4.初始化值不同
成员变量:有默认初始值,引用类型默认为null
局部变量:没有默认初始值,必须定义,赋值,然后才能使用
注意:
局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则
6.构造方法
什么是构造方法
1.构造方法就是类构造对象时调用的方法,用于对象的初始化工作
2.构造方法是实例化一个类的对象时,也就是new的时候,最先调用的方法
构造方法的定义:
构造方法是在类中定义的,构造方法的定义格式:方法名称与类名称相同,无返回值类型的声明
对象的实例化语法:
Dog dog = new Dog();//new Dog后面有个括号,带括号表示调用了方法,此时调用的方法就是构造方法了
构造方法重载:
无参构造方法:
public Dog(){}
带一个参数的构造方法:
public Dog(String name){
this.name = name;
}
带多个参数的构造方法:
public Dog(String name,int age){
this.name = name;
this.age = age;
}
构造方法小结
1).构造方法名称与类名相同,没有返回值声明(包括void)
2).构造方法用于初始化数据(属性)
2).每一个类中都会有一个默认的无参的构造方法
4).如果类中有显示的构造方法,那么默认的构造方法将无效
5).如果有显示的构造方法,还想保留默认构造方法,需要现实的写出来
6).构造方法可以有多个,单参数不一样,成为构造方法的重载
7).在构造方法中调用另一个构造方法,使用this(...),该句代码必须在第一句
8).构造方法之间的调用,必须要有出口
9).给对象初始化数据,可以使用构造方法或stter方法,通常情况下,两者都会保留
10).一个好的编程习惯是要保留默认的构造方法.(为了方便一些框架代码使用反射来创建对象)
11).private Dog(){},构造方法私有化,当我们的需求是为了保证类只有一个对象时.
什么时候一个类只需要一个对象?比如,工具类(没有属性的类,只有行为)并且该工具对象被频繁使用.权衡只用一个对象与产生多个对象的内存使用,来确定该类是否要定义为只需要一个对象.
7.this关键字
在java基础中,this关键字是一个最重要的概念,使用this关键字可以完成以下的操作:
调用类中的属性
调用类中的方法或者构造方法
表示当前对象
/**
this关键字
调用类中的属性
调用类中的方法或构造方法
表示当前对象:在方法被调用的过程中,哪个对象调用了方法,在方法内的this就表示谁
类名.this
*/
public class Test4{
public static void main(String[]args){
Cat cat = new Cat();
cat.setName("狗蛋");
cat.setAge(9);
cat.eat();
}
}
class Cat{
private String name;
private int age;
public void setName(String name){//name = 狗蛋
this.name = name;//this代表的时当前对象
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
public void eat(){
//在方法中使用this调用类中的其他方法或属性,this可以省略,this前面可以使用当前的类名.this
//在后面的内部类知识点中会涉及到
System.out.println("我是"+this.getName()+"我"+this.age+"岁了,"+"我爱吃粑粑");
//或 System.out.println("我是"+Cat.this.getName()+"我"+this.age+"岁了,"+"我爱吃粑粑");
}
}
8.值传递与引用传递
示例一: 值传递
public calss ValueDemo{
public static void main(String[]args){
int x = 10;
method(x);
System.out.println("x="+x);
}
public static void method(int mx){
mx = 20;
}
}
示例二: 引用传递
public class RefDemo1{
public static void main(String[]args){
Duck d = new Duck();
method(d);
System.out.println("Duck age="+d.age);
}
public static void method(Duck duck){
duck.age = 5;
}
}
class Duck{
int age = 2; //省略封装
}
示例三: String传递
//示例三:String传递
public class RefDemo2{
public static void main(String[]args){
String name = "小飞";
method(name);
System.out.println("name="+name);
}
public static void method(String sname){
sname = "小贝";
}
}
示例四: String传递
//示例四:String传递
public class RefDemo3{
public static void main(String[]args){
Person p = new Person();
method(p);
System.out.println("Person name="+p.name);
}
public static void method(Person per){
per.name = "备备";
}
}
class Person{
String name = "飞飞";//省略封装
}
9.对象的一对一关系
两个对象之间的一对一关系:
比如:
一个英雄(Hero)对一个兵器(Weapon)
代码如何表示?
/**
两个对象之间的一对一关系:
比如:一个英雄(Hero)对一个兵器(Weapon)
双向一对一
单向一对一
*/
public class Test5{
public static void main(String[]args){
Hero hero = new Hero("刘备",300);
Weapon weapon = new Weapon("双股剑",99);
//把两个对象关联起来
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 void setWeapon(Weapon weapon){
this.weapon = weapon;
}
public Weapon getWeapon(){
return 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 name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
//兵器类
class Weapon{
private String name;
private int grade;
private Hero hero;
public void setHero(Hero hero){
this.hero = hero;
}
public Hero getHero(){
return 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;
}
}
10.static关键字
static关键字的作用:
1.使用static关键字修饰一个属性
声明为static的变量实质上就是全局变量
2.使用static关键字修饰一个方法-
通常,在一个类中定义一个方法为static,那就是说,无需本类的对象即可调用此方法
3.使用static关键字修饰一个类(内部类)
/**
static 关键字
1.静态变量或方法不属于对象,依赖类
2.静态变量是全局比变量,生命周期从类被加载后一直到程序结束
3.静态变量只有存一份,在静态方法区中存储0
4.静态变量是本类所有对象共享一份
5.建议不要使用对象名去调用静态数据,直接使用类名调用
6.static修饰一个方法,那么该方法属于类,不属于对象,直接用类名调用
7.静态方法只能访问静态属性和方法
*/
public class Test6{
public static void main(String[]args){
//Role beibei = new Role("刘备","蜀国");
//Role yunchang = new Role("关羽","蜀国");
//Role feifei = new Role("张飞","蜀国");
Role beibei = new Role("刘备");
Role yunchang = new Role("关羽");
Role feifei = new Role("张飞");
System.out.println(beibei.getInfo());
System.out.println(yunchang.getInfo());
System.out.println(feifei.getInfo());
System.out.println(beibei.country);
System.out.println(yunchang.country);
System.out.println(feifei.country);
beibei.country = "秦国";
System.out.println("--------------------------");
System.out.println(beibei.country);
System.out.println(yunchang.country);
System.out.println(feifei.country);
System.out.println("--------------------------");
System.out.println(Role.country);//用类名调用静态变量
}
}
// 角色
class Role{
private String name ;
static String country = "蜀国";//静态变量(全局变量)
public Role(String name,String country){
this.name = name;
this.country = country;
}
public Role(String name){
this.name = name;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
//静态方法只能访问静态的数据
public static void setCountry(String country){
Role.country = country;
}
/**
public void setCountry(String country){
this.country = country;
}
public String getCountry(){
return country;
}
*/
public String getInfo(){
return "name:"+name+",country:"+country;
}
}
声明为static的方法有一下几条限制:
它们仅能调用其他的static方法。
它们只能访问static数据。
它们不能以任何方式引用this或super。
什么时候使用static?
所有对象共用属性或方法,那么我们应该定义为静态的。
11.main方法分析
主方法:
public static void main(String[]args){
//代码块
}
public:公有的,最大的访问权限
static:静态的,无需创建对象
void:表示没有返回值,无需向JVM返回结果
main:方法名,固定的方法名
String[]args:表示参数为字符串数组,可以在调用方法时传入参数
12.代码块
1.普通代码块
直接写在方法中的代码块就是普通代码块
示例:
public class Test7{
public static void main(String[]args){
}
}
class Student{
public void study(){
//限制作用域,生命周期就在括号里
{
int i = 20;
System.out.println(i);
}
}
}
2.构造块是在类中定义的代码块
示例:
/**
代码块:
1.普通代码块,在方法中写的代码块
2.构造块是在类中定义的代码块,在创建对象时被调用,优于构造方法执行
*/
public class Test7{
public static void main(String[]args){
Student s = new Student();
Student s2 = new Student();
Student s3 = new Student();
}
}
class Student{
public Student(){
System.out.println("构造方法");
}
{
System.out.println("我是构造代码块");
}
public void study(){
//限制作用域,生命周期就在括号里
{
int i = 20;
System.out.println("我是普通代码块");
}
}
}
3.在类中使用static声明的代码块成为静态代码块
示例:
/**
代码块:
1.普通代码块,在方法中写的代码块
2.构造块是在类中定义的代码块,在创建对象时被调用,优于构造方法执行
3.在类中使用static声明的代码块成为静态代码块
在第一次使用的时候被调用(创建对象),只会执行一次,优于构造块执行
执行顺序:静态代码块>构造块>构造方法
我们在项目开发中,通常会使用静态代码块来初始化只调用一次的数据.比如说:
*/
public class Test7{
public static void main(String[]args){
Student s = new Student();
Student s2 = new Student();
Student s3 = new Student();
}
}
class Student{
public Student(){
System.out.println("构造方法");
}
{
System.out.println("我是构造代码块");
}
static {
System.out.println("我是静态代码块");
}
public void study(){
//限制作用域,生命周期就在括号里
{
int i = 20;
System.out.println("我是普通代码块");
}
}
}
4.同步代码块(多线程中讲解)
13.单例设计模式
单例设计模式:保证一个类仅有一个实例,并提供一个访问他的全局访问点。
1.构造方法私有化
2.声明一个本类对象
3.给外部提供一个静态方法获取对象实例
两种实现方法:
1.饿汉式
2.懒汉式
/**
1.构造方法私有化
2.声明一个本类对象
3.给外部提供一个静态方法获取对象实例
1.饿汉式:在类被加载后,对象被创建,到程序结束后释放
2.懒汉式:在第一次调用getInstance方法时,对象被创建,到程序结束后释放
*/
public class Test8{
public static void main(String[]args){
//私有化不能new
//Singleton1 s = new Singleton1();
Singleton2 s = Singleton2.getInstance();
s.print();
Singleton2 s2 = Singleton2.getInstance();
s2.print();
System.out.println(s==s2);
}
}
//饿汉式:占用内存的时间长,提高效率
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("测试方法2");
}
}
14.对象数组与管理
1.对象数组就是数组里的每个元素都是类的对象,赋值时先定义对象,然后将对象直接赋给数组。
示例:
/**
对象数组与管理
使用对象数组实现多个Chicken的管理
动态数组:
1.数组是一种线性数据结构
2.数组不适合做删除插入等操作,适合添加,查找,遍历
*/
import java.util.Arrays;
public class Test9{
public static void main(String[]args){
ChickenManager cm = new ChickenManager(5);
//添加
cm.add(new Chicken(1,"小小",10));
cm.add(new Chicken(2,"小二",8));
cm.add(new Chicken(3,"小三",6));
cm.add(new Chicken(4,"小红",4));
cm.add(new Chicken(5,"小奋",2));
cm.add(new Chicken(6,"小斗",1));
System.out.println("数组的长度是:"+cm.length());
System.out.println("-------------printAll-------------");
cm.printAll();
System.out.println("-------------find-------------");
Chicken c = cm.find(6);
c.print();
System.out.println("-------------update-------------");
cm.update(new Chicken(2,"小小鸡",20));
cm.printAll();
}
}
//小鸡管理类
class ChickenManager{
private Chicken[] cs = null;
private int count = 0;//纪录当前数组的元素个数(下标)
// 大小
public ChickenManager(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){//数组已满,需要扩充
//算法一:扩充原来数组大小的一半 cs.length*3/2+1
//算法二:扩充原来数组的一倍 cs.length*2
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++){
cs[i].print();
}
} //输出所有
}
//小鸡类(数据对象) valueobject(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 void print(){
System.out.println("id="+id+",name="+name+",age="+age);
}
}