第一章

1-1面向对象

1.对象的概念

2.类

3.什么是对象的属性

4.什么是对象的方法

5.类与对象的关系/区别

 

 

1. Java中处处是对象

3.类是模子  确定对象将会拥有的特征（属性）和行为（方法）

类的特定  

    类是对象的类型

    具有相同属性和方法的一组对象的集合

4.属性-----对象具有的各种特征

  每个对象的每个属性都拥有特定值

5， 对象能干什么  就是方法

6. 类是抽象的概念 仅仅是模板 比如说：手机

而对象是一个你能够看得见 摸得到的东西

比如

“手机”类

特征（属性）

屏幕

CPU

行为（方法）

打电话

发短信

 对象就是三星 ，苹果，小米6等等

 

1-2 如何定义Java的类

 

定义一个类的步骤

A定义类名.

B编写类的属性

C编写类的方法

代码如下

Public class{

//定义属性部分（成员变量）

属性1的类型   属性1；

。。。

属性n的类型   属性n;

 

 

//定义方法部分  

方法1；

。。。

方法n;

 

}

 

 

Jujuti 具体代码

//定义属性（成员变量）  有什么

float cpu;

Float  screen;

//方法  可以干什么

Void  call（）{

输出（“被擦伤不变的是”）}

Void  send（）；

 

 

 

7-3  Java的对象

使用对象的步骤：

1. 创建对象

  类名  对象名=new 类名；

2. 使用对象

3. 

引用对象的属性：对象名.属性

     如 phone.screen=5;

Q其中 phone是对象名，screen是属性。5是引用对象的属性。

引用对象的方法  ：对象名.方法名（）

Phone.sendMessage();  

 

X现在来一个demo

 

 

7-4  成员变量和局部变量

1.成员变量

在类中定义，用来描述对象有什么

2.局部变量

在类的方法中定义，在方法中暂时保存数据。

成员变量在当前类和其他类都可以使用，局部变量只能在当前方法使用。

区别、

1.作用域不同  

局部变量的作用域仅限于 定义它的方法，

成员变量在整个类内部都是可见的。

用代码已实现   若是贴上来 简直排版太乱 就省略。

2.初始值

 局部变量需要定义  成员变量可以系统默认

3.就近原则

  两类变量同名时，局部变量优先级更高。

4,。在同一个方法  不允许有同名局部变量；

   在不同的方法  可以有同名局部变量。

 

7-5 Java的 构造方法

1.使用 new+构造方法  创建一个新的对象

2.构造方法是定义 在Java类中的一个用来 初始化对象的方法

3.3普通方法和构造方法的不同就是   构造方法 可以创建对象

4.构造方法与类同名 且没有返回值

5.语法格式   public  构造方法名（）{

// 初始化代码

}

可以看到 没有返回值类型。构造方法名与类名同名。（）内可以指定参数。

                                            所以分为无/有参构造方法。

6 无参构造方法的使用

Main（）：

   telephone phone=new telephone();

Class  telephone():

   Public  telephone(){

          System.out.println(“hjj好几遍”);

}

7.带参构造方法

8.当没有指定构造方法时，系统会自动添加无参的构造方法

9.当有构造方法 ，无论是无参，还是有参，系统都不会自动添加无参的构造方法；

10.构造方法的重载  方法名相同，但参数不同的多个方法，调用时 会根据不同的参数选择相应的方法

11.构造方法不但可以给对象的属性赋值，还可以保证给对象的属性赋一个合理的值

 

 

 

 

 

构造方法和主方法的理解

主方法是类的入口点，他定义了程序从何处开始；主方法提供对程序流程的控制，Java编译器通过主方法来执行程序。

主方法具有以下特性：

 

 

 

 

 

1-7  静态变量

我们可以基于一个类创建多个该类的对象，每个对象都有自己的成员，互相独立。

而然某些时候，我们更希望该类所有的对象共享同一个成员，此时就是static 大显身手的 时候了！

Java 被static修饰的成员称为静态变量或类变量。

他属于整个类所有，而不是某个对象所有，即被该类的所有对象共享。

静态成员可以使用类名直接访问，也可以使用对象名进行访问。

当然 ，鉴于他作用的特殊性  推荐用类名访问。

Static 可以修饰 变量，方法，和代码快。

 

实例代码

package imooc02;

 

public class HelloWorld {

static  String   hobby="imooc";

public static void main(String[] args) {

//静态变量可以直接使用类名访问 不用创建类的对象；

 System.out.println("通过类名访问hobby："+method12.hobby);

 

//创建类的对象

 HelloWorld  hello=new HelloWorld();

//使用对象名来访问static 变量

System.out.println("通过对象名访问hobby："+hello.hobby);

//使用对象名的形式修改静态变量的值

hello.hobby="爱慕课";

//

System.out.println("通过对象名访问hobby："+hello.hobby);

//

 

//

 

}

 

}

 

 

运行结果

通过类名访问hobby：imooc

通过对象名访问hobby：imooc

通过对象名访问hobby：爱慕课

 

1-9 static使用之静态方法

Static 修饰方法，称为静态方法或类方法。

其实之前一直写的main方法  就是静态方法。

静态方法的使用如下代码

package imooc02;

public class HelloWorld {

//用static  关键字声明静态方法

public  static  void  print(){

System.out.println("欢迎您:爱慕课!");

}

public static   void  main (String[]   args){

//直接使用类名调用静态方法

HelloWorld.print();

//也可以通过对象调用 当然更加推荐类名调用

//创建类的对象

//使用对象名来访问static 方法

HelloWorld  hello=new  HelloWorld();

hello.print();

}

}

 

注意：

1.静态方法可以直接调用同类中的静态成员，但是不能直接调用非静态成员，如下：

    package imooc02;

public class HelloWorld {

String  name="爱慕课";

//非  static 变量

static String hobby="imooc";//静态变量hobby；

// 在静态方法调用非静态变量

public  static void print(){

//不能调用非静态变量

System.out.println("欢迎您:"+name+"!");

System.out.println("爱好"+hobby+"!");

}

}

如果希望在静态方法中调用非静态方法，可以通过创建类的对象，然后通过对象来访问非静态变量  如下：

这样子变就行啦

HelloWorld  hello=new  HelloWorld();

System.out.println("欢迎您:"+hello.name+"!");

2.在普通成员方法里面，则可以直接访问同类的静态变量和非静态变量  如下：

package imooc02;

public class HelloWorld {

String  name="爱慕课";

//非  static 变量

static String hobby="imooc";//静态变量hobby；

// 在静态方法调用非静态变量

public  void print(){

//不能调用非静态变量

//通过创建对来访问非静态变量

System.out.println("欢迎您:"+name+"!");

System.out.println("爱好"+hobby+"!");

}

}

 

3.静态方法里面 不能直接调用非静态方法，需要通过 对象来访问静态方法。

package imooc02;

public class HelloWorld {

public  void  show(){

System.out.println("welcome    to  imooc");

}

// 静态方法

public  static  void  print(){

System.out.println("欢迎来到慕课网");

}

public static void main(String[] args) {

}

}

 

 

实例代码  以及感想（已经用注释标出）

package imooc02;

public class HelloWorld {

// 定义静态变量 两个

 static  int   score1=86;

 static  int   score2=92;

 //定义静态方法  计算成绩总分  并返回总分

 public static  int  sum ()

 {  //这里的return 是这样子写的

 //看来我应该再好好理解一下子

 return score1+score2;

}

public static void main(String[] args) {

   //调用静态方法sum  并接收返回值

//用类名 直接 调用 方法   加多练习   加油啊

int allScore=HelloWorld.sum() ;

System.out.println("总分;"+allScore);

}}

 

1-10  static 使用之静态初始化

Java可以通过初始化快 进行数据赋值，如：

Public  class HelloWorld{

String  name；

//定义一个成员变量

//通过初始化块 为 成员变量  赋值

{  name=”爱慕课”;

}

}

 

在类的声明中，可以包含多个初始化快，当创建类的实例时，就会依次执行这些代码快。如果用static修饰代码快，那么就称为静态初始化块。

需要注意的是：静态初始化块 只在加载时执行，而且只执行一次，  同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。

看例子

package imooc02;

public class HelloWorld {

int  num1;

int  num2;

static   int  num3;//

public HelloWorld (){  //构造方法

num1=91;

System.out.println("通过构造方法为变量num1 赋值");

}

{//初始化块

num2=74;

System.out.println("通过构造方法为变量num2 赋值");

}

static{//静态初始化块

num3=83;

System.out.println("通过构造方法为变量num3 赋值");

}

public static void main(String[] args) {

HelloWorld hello=new HelloWorld();

System.out.println("num1"+hello.num1);

System.out.println("num2"+hello.num2);

System.out.println("num3"+hello.num3);

HelloWorld hello2=new HelloWorld();

}}

运行结果如下：

通过构造方法为变量num3 赋值

通过构造方法为变量num2 赋值

通过构造方法为变量num1 赋值

num191

num274

num383

通过构造方法为变量num2 赋值

通过构造方法为变量num1 赋值

 

 

通过运行结果可以看出 ；程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。由于静态初始化块只在类加载时执行一次，所以当再次创建对象hello2 时  并未执行静态初始化块。