java面向对象（上）

面向对象

• java是面向对象的程序设计语言，java提供了定义 类 成员变量 方法的基本功能
• java也支持面向对象的三大特征：封装，继承，多态。
• java提供了 private protected 和 public 三个访问控制修饰符来实现 良好的封装。提供了 extends关键字让子类继承父类，继承之后就可以得到父类成员变量和方法。继承是实现类复用的重要手段。当然也可以通过组合来进行复用。
• 特征：
• 是一种更加符合我们思想习惯的思想
• 可以将复杂的事情简单化
• 将我们从执行者变成指挥者
• 开发：
• 不断创建对象，使用对象，指挥对象。
• 设计：
  • 考虑管理对象之间的关系

类和对象

• .定义类：
• 在面向对象的程序设计过程中有两个重要概念：类（class）和对象（object，或instance）。
  其中类是某一批对象的抽象。可以把类理解成某种概念；对象才是具体的存在。
  类和对象都是核心。

Java语言里定义类的简单语法：
【修饰符】 class 类名
{
零到多个构造器定义：
零到多个成员变量；
零到多个方法；
}
修饰符：public，final ，abstract 或者完全省略。

• 类名：合法标识符，一个或多个有意义单词连缀而成，每个单词首写字母大写，单词之间不用任何间隔符。

• 成员：构造器；成员；方法。
  成员可以相互调用，static修饰的成员不能访问没有static修饰的成员。

  • 定义成员变量：
    【修饰符】 类型 成员变量名 【=默认值】；
    修饰符：public protected private static final
  • 定义方法格式：
    【修饰符】 方法返回值类型 方法名（形参列表）
    {
    //零到多条可执行性语句组成的方法体
    }
    修饰符：public protected private static final abstract。
  • 构造器特点：
    构造器既不能定义返回值类型，也不能使用void声明构造器没有返回值，如果程序员手动添加返回值类型或者void 系统会将其当成方法处理 构造器将不复存在。
    类定义之后，就以使用该类了。java的类大致如下作用：
    **定义变量
    **创建对象
    **调用类的类方法和访问类的类变量

static修饰符：：：：【重点】
作用：为了区别（方法 变量 内部类 初始化模块）这四个成员 是属于类本身还是属于实例，有static修饰的是类本身 木有修饰的是实例。

java语言通过new关键字调用构造器

对象产生和使用

• 创建对象的根本途径是构造器，通过new关键字来调用某个类的构造器即可创建这个类的实例

---

//使用Person类定义一个person类型的变量
Person p；
//通过new关键字调用Person类的构造器，返回一个Person实例
//将该Person类的实例赋给p便量；
p = new Person（）；

---

上面的代码也可以简化：

---

//定义p变量同时并为p变量赋值
Person p = new Person（）；

---

• 创建对象后就可以使用该对象了；Java的对象大致有如下作用：
  ** 访问对象的实例变量：
  **调用对象的方法：
• 当权限允许的时候类里定义的方法 变量 都可以通过类或者实例调用
  类或实例访问方法或成员变量的语法：
  **类.类变量|方法
  **实例.变量|方法
  其中，static修饰的变量和方法既可以通过实例调用 也可以通过类调用。

---

数组练习：引用类型数组初始化

//为了更好的说明引用类型的运行过程 先定义一个person类  所有类都是引用类型
class Person{
         int age; //年龄
         double height; //身高
    //定义一个info方法
    void info(int age,int height)
	{
        System.out.println("我的年龄是:"+ age + ",我的身高是:"+ height);
    }
}
class  ReferenceArrayTest
{
    public static void mian(String[] args)
    {
        //定义一个students类型的数组变量，其类型是person[];
        Person[] students;
        //执行动态初始化
        students = new Person[2];
        //创建一个person实例 并把这个实例赋给zhang变量
        Person zhang = new Person();
        //为zhang赋值
        zhang.age = 16;
        zhang.height = 178;
        //创建一个person实例，并把这个实例赋给lee变量
        Person lee = new Person();
        //为lee赋值
        lee.age = 19;
        lee.height = 180;
        //分别将zhang和lee赋给students
        students[0] = zhang;
        students[1] = lee;
        students[0].info();
        students[1].info();
    }
}

---

一个对象的内存图：

成员变量和局部变量

出现的位置：
成员变量：类中方法外：
局部变量：方法内或者方法声明上：
内存的位置：
成员变量：堆内存：
局部变量：栈内存；
生命周期：
成员变量：随对象存在而存在 随对象消失而消失
局部变量：随着方法调用而存在，随着方法调用完毕而消失。
初始化值不同：
成员变量：有默认的初始化值
局部变量：没有默认的初始化值 必须先定义 赋值 才能被使用。
注意事项：成员变量和局部变量可以名称相同，在方法中使用就近原则

方法的形参

• 形参有基本类型和引用类型。
  • 基本类型，形参是什么数据类型 实参就传什么类型 这里其实是根据实参 改形参
  • 引用类型，当形参是一个类类型时 这是实参要穿的是这个类的对象。。。。。

例如：
//形式参数是基本类型
class Demo {
	public int sum(int a,int b) {
		return a + b;
	}
}


//形式参数是引用类型
class Student {
	public void show() {
		System.out.println("我爱学习");
	}
}
class StudentDemo {
	//如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
	public void method(Student s) { //调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();
		s.show();
	}
}
class ArgsTest {
	public static void main(String[] args) {
		//形式参数是基本类型的调用
		Demo d = new Demo();
		int result = d.sum(10,20);
		System.out.println("result:"+result);
		System.out.println("--------------");
		
		//形式参数是引用类型的调用
		//需求：我要调用StudentDemo类中的method()方法
		StudentDemo sd = new StudentDemo();

		//创建学生对象
		Student s = new Student();
		sd.method(s); //把s的地址给到了这里


	}
}

• 形参个数可变的方法

  • Java允许在方法的形参里存在且最多存在一个形参个数可变的形参，而且可数可变的形参必须在最后，【在该形参的类型后面加 … 则表明该形参可接受多个参数值，多个参数值被当做数组传入】

例如：
----------------------------------------------------------------------------------------------------------------------
public class Varargs
{
//定义了形参个数可变的方法
public static void test(int a,String... books)
{
//books 被当做数组处理
for (String tmp :books)
{
System.out.println(tmp);
}
//输出整形a变量
System.out.println(a);
}
pubilc static void main(String[] args)
{
//调用方法test
test(5,"疯狂Java讲义","轻量级Java EE 企业应用实战")；
}
}
运行结果：
疯狂Java讲义
轻量级Java EE 企业应用实战
5

方法练习：（不死神兔）
（斐波那楔数列）
class Fibonacci
{
    private long[] f1 ;
    public void Fn()
    {
        int n;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数：");
        n = sc.nextInt();
        f1 = new long[n];
        f1[0] = 1;
        f1[1] = 1;
        for ( int i = 2 ;i < f1.length ; i++)
        {
            f1[i] = f1[i - 1] + f1[i - 2];
        }
    }
    public void Print()
    {
        for (int i = 0;i < f1.length ; i++) {
            System.out.println(f1[i]);
        }
    }
}
class FibonacciTest
{
    public static void main(String[] args)
    {
       Fibonacci F = new Fibonacci();
        F.Fn();
        F.Print();
    }
}

匿名对象

• 定义：没有名字的对象
• 应用场景：
  a。调用方法：当仅仅只调用一次的时候，可以使用，调用完毕后变成垃圾，被回收。
  b。匿名对象可以作为形式参数传递

例如：
-----------------------------------------------------------------------------------------------------------------
class Student      //类
{
public void show()     //方法
{
System.out.println("我爱学习");
       }
}
class StudentDome   //类
{
public void method(Student s)    //方法  参数是对象
{
   s.show();    //调用方法
}
}
class NonameDome
{
public static void main(String[] args)
{
//带名字的调用
Student s = new Student();   //s就是对象的名字
s.show();   //调用方法
//匿名调用；
new Student();    //对象没有名字
new Student().show     //调用方法
//升级
Student s = new Student();    
StudentDome sd = new StudentDome();
sd.method(s)
//再来
sd.method(new Student());
//再来
new.StudentDome().method(new Student());
}

封装概述：隐藏对象的属性和实现细节，仅提供一个公共访问方式。

• 优点：
  • 隐藏实现细节提供公共访问方式
  • 提高了代码的复用性。
  • 提高安全性。
• 封装原则：
  • 将不需要向外界提供的内容都隐藏起来。
  • 把属性隐藏，提供公共方式进行访问
• 访问控制符：
  • java提供了3个访问控制符：private , protected , public.
    分别代表三个访问控制级别，
    private—》default—》protect—》public。

private(当前类访问权限)：如果一个类的一个成员（成员变量，方法，构造器等）使用private访问控制符来修饰，则这个成员只能在当前类里被访问。很显然，这个访问控制符用于修饰成员变量最合适，使用它来修饰成员变量可以将它隐藏在这个类的内部。【 1 成员变量修饰 2 提供 getXxx和setXxx的方法】
default（包访问权限）：如果一个类里的一个成员（包括成员变量，方法 ，构造器等）或者一个外部类不使用任何访问控制符修饰，就称她是包访问权限的，default访问控制的成员或者外部类可以被相同包下的其他类访问。
protected（子类访问权限）：如果一个类的一个成员（成员变量，方法，构造器等）使用protected访问控制符来修饰，那么这个成员既可以呗同一个包中的其他类访问，也可以被不同包中的子类访问。通常情况下 如果一个方法被这个符修饰，通常是希望其子类来重写这个方法。
public：（公共访问权限）：这是最宽松的访问控制级别，如果一个类里的一个成员（包括成员变量，方法 ，构造器等）或者一个外部类被public访问控制符修饰，则他可以被任何类 访问

static关键字：针对所有对象共享的成员变量值

• 静态的意思。可以修饰成员变量和成员方法。

• 静态的特点：
  A:随着类的加载而加载
  B:优先与对象存在
  C:被类的所有对象共享
  这其实也是我们判断该不该使用静态的依据。
  举例：饮水机和水杯的问题思考
  D:可以通过类名调用
  既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。

• 静态的内存图
  静态的内容在方法区的静态区

• 静态的注意事项
  A:在静态方法中没有this对象
  B:静态只能访问静态(代码测试过)

• 静态变量和成员变量的区别

• 所属不同
  静态变量：属于类，类变量
  成员变量：属于对象，对象变量，实例变量

  • 内存位置不同
    静态变量：方法区的静态区
    成员变量：堆内存
  • 生命周期不同
    静态变量：静态变量是随着类的加载而加载，随着类的消失而消失
    成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失
  • 调用不同
    静态变量：可以通过对象名调用，也可以通过类名调用
    成员变量：只能通过对象名调用

• main方法是静态的

  • public:权限最大
  • static:不用创建对象调用
  • void:返回值给jvm没有意义
  • main:就是一个常见的名称。
  • String[] args:可以接收数据，提供程序的灵活性

格式：java MainDemo hello world java
java MainDemo 10 20 30

包： 文件夹

• java允许将一组功能相关的类放在一个package里 从而组成逻辑上的类库单元，
• 格式：package packageName ；
  注意：package语句必须作为源文件的第一行非注释性语句。一个源文件只能制定一个包。
  一旦使用这个语句，则意味着源文件里定义的类都属于这个包（package）位于包中的每个类的完整类名都应该为：包名和类名的组合，

---

例如：
package lee
public class Hello
{
public static void main（String[] args）4
{

}
}
在包lee下定义了一个简单的Java类
使用如下命令则可以在当前路径下保存这个文件（包）
格式：javac -d . Hello.java
-d 选项用于设置编译生成的class文件的保存位置，这里指定将class保存在当前路径下（. 就是当前路径）

import关键字：

• 作用：可以向某个java文件中导入指定包层次下某个类或者全部类。import应出现在package之后，Java可以包含多个import语句。
• 用法：
  单个类：import package.subpackage…ClassName;
  全部类：import package.subpackage…*;
  *代表类。
  有时候import并不是万能的如果你在导俩个不同包里的某个类 但是这俩个类具有相同的名称 系统就会搞糊涂！！！
  这时候就需要使用类的全名。

深入构造器：
前面说了构造器的用于创建实例时 执行初始化。
如果类里没有构造器 系统就会默认一个空的构造器 简而言之 Java类里至少包含一个构造器 ，你也可以手动自定义构造器用于对成员变量的初始化。（通过new调用） 你也可以创建多个构造器 （构造器重载）

java 面向对象思想一部分如上