面向对象的基础篇_03
来源:互联网 发布:数据库union的用法 编辑:程序博客网 时间:2024/06/06 15:37
基础篇_03的主要内容
- 1丶对象比较
- 2丶static 关键字的作用
- 3、代码块
- 4丶内部类
一丶对象比较
理解:就是判断两个对象的内容是否相等。
核心:就是判断两个对象中的属性是否完全相等。
比较的第一种情况
class Person { private String name ; private int age ; public Person(String name,int age){ this.name = name ; this.age = age ; } public String getName(){ return this.name ; } public int getAge(){ return this.age ; }}public class CompareDemo01 { public static void main(String args[]){ Person per1 = new Person("张三",30) ; Person per2 = new Person("张三",30) ; if(per1.getName().equals(per2.getName()) && per1.getAge() == per2.getAge()){ System.out.println("是同一个人!") ; } else { System.out.println("不是同一个人!") ; } }}
如果按照以上的做法,由主方法进行比较,实际上就相当于增加了一个第三方,由第三方帮你进行比较,肯定不合适,所以最好的做法是在 Person 类中本身就已经具备了一个这样的功能。
class Person { private String name ; private int age ; public Person(String name,int age){ this.name = name ; this.age = age ; } public boolean compare(Person person){ if(this == person){ // 地址相等了 return true ; } if(this.name.equals(person.name) && this.age==person.age){ return true ; } else { return false ; }} public String getName(){ return this.name ; } public int getAge(){ return this.age ; }}public class CompareDemo02 { public static void main(String args[]){ Person per1 = new Person("张三",30) ; Person per2 = new Person("张三",30) ; if(per1.compare(per2)){ System.out.println("是同一个人!") ; } else { System.out.println("不是同一个人!") ; }}
对象比较的操作代码,一定要熟练编写。
二丶static 关键字的作用
static关键字在类中可以声明属性或方法。
声明的属性将称为全局属性。``【全局属性】
声明的方法将成为类方法。``【类方法】
1、声明属性
公共属性就可以使用 static 进行操作。
|- 假使每个对象占用每个对象自己的属性的话,对于每个对象公有的属性而言,肯定会造成内存空间的浪费
- `|- 公共属性,所有的对象可以同时拥有,但是一般而言这些公共属性虽然可以使用普通的对象调用,可一般不这样操作,而是通过所有对象的最大级 —— 类,完成调用。
举例:
| - 比如我们的学校都在石家庄的话,城市country石家庄是全局属性
| - 我们之间不同的属性就有名字name和学号id
我们的程序如下:
class Person { private String name ; private int age ; String country = "石家庄" ; public Person(String name,int age){ this.name = name ; this.age = age ; } public String getInfo(){ return "姓名:" + this.name + ",年龄:" + this.age + ",城市:" + country ; }}public class StaticDemo01{ public static void main(String args[]){ Person per1 = new Person("张三",20) ; Person per2 = new Person("李四",21) ; Person per3 = new Person("王五",22) ; System.out.println(per1.getInfo()) ; System.out.println(per2.getInfo()) ; System.out.println(per3.getInfo()) ; }}
| - 这里没有使用static定义全局变量。
| - 如果需要改变我们的地址为北京,上千人的数据很难一下更改。
| - 按照内存的分配来讲,每一个对象都单独占着各自的 country属性。
我们把程序中的country加上static作为全局变量
class Person { private String name ; private int age ; static String country = "石家庄" ; public Person(String name,int age){ this.name = name ; this.age = age ; } public String getInfo(){ return "姓名:" + this.name + ",年龄:" + this.age + ",城市:" + country ; }}public class StaticDemo02{ public static void main(String args[]){ Person per1 = new Person("张三",20) ; Person per2 = new Person("李四",21) ; Person per3 = new Person("王五",22) ; System.out.println(per1.getInfo()) ; System.out.println(per2.getInfo()) ; System.out.println(per3.getInfo()) ; System.out.println("---------------------") ; per1.country = "北京" ; System.out.println(per1.getInfo()) ; System.out.println(per2.getInfo()) ; System.out.println(per3.getInfo()) ; }}
|-修改了一个对象中的 country属性之后,所有对象的 country属性都发生了变化
|-由于全局属性拥有可以通过类名称直接访问的特点,所以这种属性又称为类属性。
|-类名称直接访问Person.country = “北京” ;
2、声明方法
全局属性可以通过类名称直接访问
static 定义一个“类方法”,也可以通过类名称直接访问。
Person.setCountry("北京") ;
类方法和类属性的作用效果是一样的
class Person { private String name ; private int age ; private static String country = "石家庄" ; public Person(String name,int age){ this.name = name ; this.age = age ; } public static void setCountry(String c){ country = c ; } public String getInfo(){ return "姓名:" + this.name + ",年龄:" + this.age + ",城市:" + country ; }}public class StaticDemo03 { public static void main(String args[]){ Person per1 = new Person("张三",20) ; Person per2 = new Person("李四",21) ; Person per3 = new Person("王五",22) ; System.out.println(per1.getInfo()) ; System.out.println(per2.getInfo()) ; System.out.println(per3.getInfo()) ; System.out.println("---------------------") ; Person.setCountry("北京") ; System.out.println(per1.getInfo()) ; System.out.println(per2.getInfo()) ; System.out.println(per3.getInfo()) ; }}
3、static的使用注意
static 本身声明方法或声明属性,但是在方法的访问上本身也存在着问题。
1、 使用 static 声明的方法,不能访问非 static 的操作(属性或方法)
2、 非 static 声明的方法,可以访问 static 声明的属性或方法当一个实例化对象产生之后,可以调用所有的非 static 的操作,那么肯定也就可以调用所有的 static 操作。
1、 如果说现在一个类中的属性或方法都是非 static 类型的,肯定是要有实例化对象才可以调用。
2、 static 声明的属性或方法可以通过类名称访问,可以在没有实例化对象的情况下调用。一个方法由主方法调用的格式:
public static 返回值类型 方法名称(参数列表){ [return 返回值 ;]}
4、static的应用
- static 的属性是所有对象所共同拥有的,那么就可以利用此特点完成一个自动命名的功能。
class Book { private String name ; private static int count = 0 ; public Book(){ this.name = "无名字 - " + ++count ; } public Book(String name){ this.name = name ; } public String getName(){ return this.name ; }}public class StaticDemo06 { public static void main(String args[]){ System.out.println(new Book("JAVA基础").getName()) ; System.out.println(new Book().getName()) ; System.out.println(new Book().getName()) ; System.out.println(new Book().getName()) ; System.out.println(new Book("Oracle").getName()) ; }}
5、主方法的组成
主方法:是所有调用的起点,定义如下:
- public static void main(String args[])
实际上每一个修饰符或参数都是有意义的:
- public:表示外部都可以访问
- static:方法可以由类直接调用
- void:程序的起点,一旦开始了就没回头路
- main:系统规定好的默认的方法名称
- String args[]:是一个字符串数组,用于接收参数
- 在主方法中,可以在一个程序运行时输入多个参数,每个参数之间使y用空格分隔,所有的参数都靠 String args[]进行接收。
public class Hello { public static void main(String args[]){ for(int x=0;x<args.length;x++){ System.out.println(args[x]) ; } }}
但是,如果现在要想输入的参数中本身就包含了空格呢?通过双引号完成。
| - “hello world” “hello mldn”
- 主方法属于一切操作的起点 。所 以主方法将作为一个程序的客户端存在,那么客户端的操作代码越少越好。
- 在进行程序类的结构划分上,就一个原则:一个类只完成一个类的功能。
三丶代码块
- 在程序中使用“{}”括起来的一段代码就称为代码块,根据代码块出现的位置或声明的关键字的不同,分为四种:
- 普通代码块:在一个方法中定义的代码块,称为普通代码块
- 构造块:在一个类中定义的代码块
- 静态块:使用 static 关键字声明的代码块
- 同步代码块:
// 从实际的开发来看,代码块的使用并不多。
1、普通代码块
public class CodeTest { public static void main(String args[]) { { // 普通代码块 int x = 10 ; System.out.println("x = " + x) ; } int x = 100 ; System.out.println("x = " + x) ; }};
输出的结果是:
x=10;x=100;
2、构造块
构造块是定义在一个类中的代码块。
class Demo { { System.out.println("构造块!!!") ; } public Demo(){ System.out.println("构造方法!!!!") ; }}public class CodeTest01 { public static void main(String args[]) { new Demo() ; }}
构造块会优先于构造方法执行,而且每当一个新的实例化对象产生时,都会调用构造块,会调用多次。
//构造块!!!//构造方法!!!!
3、静态块
使用 static 关键字定义的代码块,而且静态块是定义在类中的。
|- 在主类中定义的静态块将优先于主方法执行。
|- 静态块优先于构造块执行,而且只执行一次。
class Demo { static{ System.out.println("静态块!!") ; } { System.out.println("构造块!!!") ; } public Demo(){ System.out.println("构造方法!!!!") ; }}public class CodeTest02 { static{ System.out.println("主方法中的静态块。") ; } public static void main(String args[]) { System.out.println("--------------") ; new Demo() ; }}
输出的结果是:
//主方法中的静态块。//--------------//静态块!!//构造块!!!//构造方法!!!!
四丶内部类
1、学习内部类,所需要认识的语法
○内部类就是指一个类【外部类】的内部还包含了另外的一个操作类【内部类】。
○被包含的类称为内部类,包含的类称为外部类。
|- 内部类可以方便的访问外部类中的私有成员。
class Outer { // 定义外部类 private String info = "Hello" ; class Inner { // 定 定 义 内 部类 类 public void print(){ System.out.println(info) ; // 输 输出 出 info 属性 } } public void fun(){ new Inner().print() ; }}public class InnerDemo{ public static void main(String args[]){ new Outer().fun() ; }}
|- 外部调用内部类,一定要先产生外部类的实例化对象,再产生内部类的实例化对象。
class Outer { // 定义外部类 private String info = "Hello" ; class Inner { // 定义内部类 public void print(){ System.out.println(info) ; // 输出 info 属性 } }}public class InnerDemo01 { public static void main(String args[]){ Outer.Inner in = null ; // 声明内部类的对象 in = new Outer().new Inner() ; in.print() ; }}
2 、使用static声明内部类
- 使用 static 声明了一个内部类:
- 类将成为外部类。
- 只能访问外部类中的 static 成员。
class Outer { // 定义外部类 private static String info = "Hello" ; static class Inner { // 定义内部类,是 static 变为外部类 public void print(){ System.out.println(info) ; // 输出 info 属性 } }}public class InnerDemo02 { public static void main(String args[]){ Outer.Inner in = new Outer.Inner() ; in.print() ; }}
上述情况会有输出"Hello"
//当我们把方法不用static声明之后private String info = "Hello" ;//会报出下列错误//无法从静态上下文中引用非静态 变量 info
3、在方法中 声明 内 部 类
- 一个内部类可以在任意的位置上声明
|- 在方法中声明内部类的操作出现的是最多的。
|- 在方法中定义的内部类,依然可以访问外部类中的属性,但是对于方法的参数,这个内部类是无法直接访问的,如果要访问,则在参数前面必须使用* final *关键字进行声明。
class Outer { private String info = "hello" ; public void fun(final int x){ final int y = 100 ; class Inner { // 方法中声明内部类 public void print(){ System.out.println(info) ; System.out.println("x = " + x) ; System.out.println("y = " + y) ; } } new Inner().print() ; }}public class InnerDemo03 { public static void main(String args[]){ new Outer().fun(30) ; }}
特此说明: 欢迎大家提出合理的意见。
最后再聊几句:
1、 this 关键字
|- this 关键字可以调用本类中的属性
|- 可以调用本类中的方法,但是如果要调用构造方法的话,则一定要放在构造方法的首行,且至少保留一个构造方法中没有使用 this 调用。
|- this 表示当前对象:当前操作类中方法的对象就是当前对象。
2、 引用传递的问题,可以使用引用表示出一些关系。
3、 链表基本上融合了类的设计、引用传递、构造方法、封装型、this 关键字。
4、 对象比较的时候实际上是将两个对象的每个属性进行比较,是一个类的内部自己所提供的功能。
5、 static 关键字
|- static 关键字声明的属性称为全局属性,为所有对象所共同拥有,可以直接通过类名称进行访问。
|- static 声明的方法可以直接由类名称调用,但是 static 的方法不能调用非 static 的操作,而非 static 的方法可以调用所有的 static 操作。
|- 主方法的组成。
6、 代码块(了解)。
7、 内部类的结构及各个操作必须掌握。
|- 使用 static 声明的内部类就是外部类。
|- 内部类可以在方法中声明,但是此时,要想访问方法中的参数,参数前必须加上final关键字。
- 面向对象的基础篇_03
- Java从基础开始_03面向对象
- 黑马程序员_Java基础_面向对象_03
- C++笔记_03面向对象1,2
- C++笔记_03面向对象3
- C++笔记_03面向对象4
- 黑马程序员_Java基础_03面向对象思想(对象转型注意事项、多态、抽象类、final关键字等)
- 面向对象的基础
- 面向对象的基础
- 面向对象的基础
- 面向对象的基础
- 面向对象的 Javascript 面向对象基础
- 面向对象(基础篇)
- 面向对象的基础篇_01
- 面向对象的基础篇_02
- 面向对象的基础结构设计
- 面向对象的基础结构设计
- c++的面向对象基础
- 从零开始基于S5PV210的嵌入式时钟系统的分析
- linux上安装使用RabbitMQ
- ionic 命令行中指定模拟器版本
- 【ML学习笔记】4:机器学习中的数学基础4(线性变换的矩阵描述)
- 7-1 城市间紧急救援(25 分)
- 面向对象的基础篇_03
- Servlet的访问路径的配置;完全路径匹配;目录匹配;扩展名匹配
- js 比较日期的大小
- PAT 1011. A+B和C (15)
- 计数控制循环
- Less转义字符
- 目前,目标跟踪技术主要应用于以下领域: 以及各种跟踪算法的简介
- Matlab 分类器大全(svm,knn,随机森林等
- 设计模式六大原则之----迪米特、开闭原则(六大原则简单总结)