面向对象
1.面相对象与面向过程
1.1面向对象：
面向对象 强调的是完成功能的对象 关注的是解决问题需要哪些对象，着眼点在于找到一个能够帮助解决问题的实体，然后委托这个实体解决问题。
1.2面向过程
强调的是功能行为 关注的是解决问题需要哪些步骤 着眼点在于问题是怎样一步步的解决的，然后亲力亲为的解决这个问题。
1.3面向对象与面向过程的优缺点
1.面向对象基于面向过程
2.面向对象与面向过程都是思想
3.面向对象比面向过程高级
4.面向对象更加符合人们的思考习惯
5.面向对象让人们从执法者变成了指挥者
6.面向过程比面向对象更底层，更高级2.类与对象的关系
- 具有特定的功能， 能够解决特定问题的实体， 就是一个对像
- 由若干个具有相同的特征和行为的对象的组成的集合， 就是一个类
- 类是对象的集合，对象是类的个体。
- 从若干个具有相同的特征和行为的对象中， 提取出这些相同的特征和行为， 设计为一个类。 类中定义所有的对象共有的特征和行为， 其中， 特征用属性表示， 行为用方法表示。 所谓属性， 其实就是定义在类中的一个全局变量。
1.JAVA中用类来描述事物
属性：对应类中的成员变量。
行为：对应类中的成员方法。
定义类其实是在定义类中的成员(成员变量和成员方法)
2.分析:
拥有对象:每一个完整的一项都是一个对象(共有六个)
拥有类:因为六个对象都拥有相似的属性,所以可以共同提炼出一个类
注意:对象不一定是存在于现实当中的物体,存在于内存中也叫实实在在的存在.
5.类的语法
- ```java
[访问权限修饰符] class 类名 {
// 类体
// 属性： 描述所有对象共有的特征。
// 方法: 描述所有对象共有的行为。
}
注意：
1.类名： 是一个标识符， 遵循大驼峰命名法。
2.一个java文件中可以写多个类， 但是只有与文件名相同的类， 可以使用public修饰。
3. 每一个类在编译后都会生成一个.class字节码文件， 以类的名字命名。
3.实例化
class Person {
// 使用属性， 描述所有对象的特征
String name;
// 描述所有人的姓名
int age;
// 描述所有人的年龄
// 使用方法， 描述所有对象的行为
public void eat() {
}
public void sleep() {
}
}
class Test{
public static void main(String[] args) {
// 使用new进行对象的实例化,对象内的属性会自动进行初始化,引用类型初始化成 null,int赋值成0,boolean赋值成false Person xiaoming = new Person();
}
}
4.成员变量和局部变量
1.作用域:成员变量是整个对象.局部变量是从定义开始到所在的函数/if/for结束
2.默认值:成员变量会有默认值,局部变量没有默认值,要想使用必须先赋值
3.释放机制:成员变量跟对象保持一致,通过垃圾回收机制回收,局部变量使用完
立即释放
4.存放的位置:成员变量放在堆区中的对象中,局部变量放在栈区中的方法中.
5.多个引用指向同一个对象
-
存储了堆中某个地址的变量就是引用（类似与C语言中的指针）
-
对象和数组都是引用数据类型,都是通过栈区中的引用(变量)保存堆区中的对象地址,所以当我 们让多个引用同时保存一个对象的地址,通过任何一个变量都可以访问这个对象(这就是前面讲 过的址传递的原理)
public class Demo2 { //多引用指向同一个对象 public static void main(String[] args) { Cat c1 = new Cat(); c1.name="波斯猫"; c1.age=40; Cat c2 = new Cat(); c1 = c2; Cat c3 = new Cat(); c2 = c3; Cat c4 = new Cat(); c4.name = c2.name; System.out.println(c1.name);//null System.out.println(c1.age);//0 System.out.println(c2.name);//null System.out.println(c2.age);//0 System.out.println(c3.name);//null System.out.println(c3.age);//0 System.out.println(c4.name);//null System.out.println(c4.age);//0 } } class Cat{ String name; int age; }
6.匿名对象
1.匿名对象就是没有名字的对象
2.,只能在创建对象的这个时刻使用一次.一 旦使用完毕,这个对象我们就再也无法调用,变成了垃圾.系统会通过垃圾回收机制在某个时刻进 行内存回收—(垃圾回收机制在JVM处会讲)
3.作用：
内存很宝贵,使用匿名对象可以更好的使用内存(随用随建,用完更快回收内存),节省内存
4.使用场景
1.用作方法参数
2.用作匿名内部类(在day10_接口和内部类讲)
public class Demo1 {
public static void main(String[] args) {
//匿名对象:没有名字的对象---就是垃圾
Dog dog = new Dog();
dog.name = "拉布拉多";
dog.play(); //play
//匿名对象也可以直接干活儿
new Dog().name = "金毛";
new Dog().play(); //play
System.out.println(dog.name);//拉布拉多
System.out.println(new Dog().name);//null
//匿名对象的作用:简化代码,常用语传参.
//通过匿名对象可以节省内存资源,优化内存的使用.
test(new Dog()); //play
}
public static void test(Dog dog){
dog.play();
}
}
class Dog{
String name;
int age;
public void play(){
System.out.println("play");
}
}
7.static
-
是一个关键字,被static修饰的成员就变成了静态的.
-
具有保值功能
-
温馨提醒 ：
-
如果某些属性是属于不同的对象， 每一个对象的值都不同， 可以设计为非静态。 例如人的名字。 如果某些属性是可以被所有的对象共享的， 每一个对象看到的值都是相同的， 可以设计为静 态。 例如对象的数量。
public class Demo3 { public static void main(String[] args) { Person p = new Person(); p.age = 10; p.show();//引用调用非静态成员 p.play();//引用调用静态成员 //静态成员还可以被类名直接调用 Person.play(); Person.height = 10;//类名调用静态成员 //Person.age = 10;//类名不能调用非静态成员 } } class Person{ //非静态成员变量 String name; int age = 10; //被static修饰的成员就是静态成员-静态成员变量 static int height; //静态成员方法 public static void play(){ //System.out.println(age); 静态方法中不能使用非静态成员 System.out.println(height);//静态方法中可以使用静态成员 } //非静态成员方法 public void show(){ System.out.println(age); //非静态方法中可以使用非静态成员 System.out.println(height); //非静态方法中也可以使用静态成员 } }
8.构造方法
1.构造方法， 其实也是一个方法。 用于实例化对象， 在实例化对象的时候调用
2.和普通的方法的区别 ：
①.构造方法的名字，必须和类名一致。
②.构造方法没有返回值，返回值类型部分不用写。
3.构造方法的意义 ：
一般情况下，使用构造方法，是为了在实例化对象的同时，给一些属性进行初始化赋值。
9.this/super
调用构造方法 this()
调用普通方法 this.普通方法或属性
super代表父类
10.封装
定义:我们可以通过对具体属性的封装实现把对成员变量的访问进行私有化,让他只能在类
内部可见,通过公共的方法间接实现访问
优点:提高了代码的安全性,复用性和可读性
脏数据:我们把程序中出现的不符合逻辑的数据称为脏数据
get()方法和set方法的使用
class Gun{
//成员私有化后,使用范围就是当前的类
private int bulletNumber;
private int age;
private int height;
private int weight;
private String model;
//通过公共方法实现赋值
public void addBulletNumber(int number){
//完成过滤
if (number < 0){
bulletNumber = 0;
}else {
bulletNumber = number;
}
}
//setter方法--赋值
public void setBulletNumber(int bulletNumber ){
//完成过滤
if (bulletNumber < 0){
this.bulletNumber = 0;
}else {
this.bulletNumber = bulletNumber;
}
}
//getter方法--取值
public int getBulletNumber(){
return this.bulletNumber;
}
public void shoot(){
if (bulletNumber > 0){
--bulletNumber;
}
System.out.println(bulletNumber);
}
}package com.qf.moning;
//求两点之间的距离
/*
分析:
1.确认用面向对象的思想解决问题
2.使用名词提炼法,提炼出可以作为对象的名词
点 距离
经过分析:使用点作为对象更合适
实现:
1.先创建点类
我们只写在实现功能时用到的属性和行为
名字:点(Point)
属性:x(double),y(double)
行为:求两点之间的距离
public double getDistance()
2.使用点类创建点对象
3.用点对象调用方法完成求两点间距离的功能
*/
//当一个类通过class定义出来,这个类可以被作为数据类型在任何位置使用,包括自己的内部.
class Point{
//成员变量--全局变量
double x;
double y;
//求两点之间的距离
/*
想办法获取两个点
第一个点:我们可以直接使用一个点的x,y
第二个点:
通过传参的方式,将另一个点传进方法
*/
public double getDistance(Point p){
double temp = (p.x-x)*(p.x-x)+(p.y-y)*(p.y-y);
double dis = Math.sqrt(temp);//开方求距离
return dis;
}
//通过静态方法求两点的距离
/*
获取两个点:
*/
public static double getDistance(Point p1,Point p2){
double temp = (p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y);
double dis = Math.sqrt(temp);//开方求距离
return dis;
}
}
public class Demo2 {
public static void main(String[] args) {
Point point = new Point();
point.x = 1;
point.y = 1;
Point point1 = new Point();
point1.x = 2;
point1.y = 2;
double dis = point.getDistance(point1);
System.out.println("距离:"+dis);
double dis1 = Point.getDistance(point,point1);
System.out.println("距离:"+dis1);
}
}
2560
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
