java基础知识总结（1）

定义类：

访问修饰符 class 类名{ }

 

访问修饰符如：public 、priate是可选的

class是声明类的关键字

按照命名规范，类名首字母大写

 

例：创建“人”类，关键代码：

public class Person{ }

**********************************************************

定义属性：

访问修饰符 数据类型 属性名；

 

访问修饰符士可选的

除了访问修饰符之外，其他的语法和声明变量是一致的

 

例：创建“人”类，名为“人”类添加相应属性，关键代码：

public class Person{

public String name;

public String gender;

public int age;

}

 

**********************************************************

定义方法：

访问修饰符 返回类型 方法名称（参数类型 参数名1，参数类型 参数名2，……）{ }

 

访问修饰符是可选的

返回类型可以是void，在定义方法时，返回类型为void时，表明没有返回值，方法体中不必使用“return”关键字返回具体数据，但是可以使用“return”关键字退出方法

返回类型不为“void”，那么在方法体中一定要使用“return”关键字返回对应类型的结果，否则程序会有编译错误

小括号中的“参数类型 参数名1，参数类型 参数名2，……”称为参数列表

当需要在方法执行的时候为方法传递参数时才需要参数列表，如果不需要传递参数时就可以省略，不过小括号不可以省略，传递多个参数时，以半角的括号进行分隔

 

例：在“人”类中定义方法，描述人工作的行为，关键代码：

public class Person{

public String name;

public String gender;

public int age;

public void work( ){

System.out.println(this.name+"的工作理念：为梦想而努力奋斗);

}

}

 

**********************************************************

创建和使用对象：

1、创建对象

类名 对象名 = new 类名（）；

 

new 是关键字

左边的类名为对象的数据类型

右边的类名（）称为类的构造方法

 

例：创建Person类的对象，关键代码：

Person lilei = new Person( );

 

 

2、使用对象

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

对象名 . 方法名         //引用对象的方法

 

例：对象属性赋值并调用方法

public static void main(String[] args){

Person lilei = new Person( );

lilei.name = "李雷"；

lilei.gender = "男"；

lilei.age = 22;

lilei.work( );

}

 

**********************************************************

成员方法：

1、带参数的方法

 

创建work（）方法时定义的参数叫做形式参数，简称形参。调用方法时传入的参数叫做实际参数，简称实参。

 

2、方法重载：

方法名相同，参数列表不同，就形成了方法重载

 

特点：在同一个类中，方法名相同，参数的个数或类型不同

**********************************************************

成员变量：

1、成员变量：类中的属性，直接在类中定义的变量，定义在方法的外部。PS：成员变量可以在声明时赋初始值，如果没有赋值，java会给它一个默认值，基本数据类型的值为0，引用类型的值为null

2、局部变量：定义在方法中的变量，一般情况下，在使用前需要赋值，否则会编译出错

**********************************************************

构造方法：

主要作用是进行一些数据的初始化

访问修饰符 方法名（参数列表）{方法体}

 

构造方法没有返回值

默认构造方法没有参数，因此参数列表可选（默认构造无参方法的快捷键：Alt+/）

构造方法的方法名与类名相同

如果写了带参的构造方法，必须要生成一个无参的构造方法

 

例：为Person类定义一个构造方法，关键代码：

public class Person{

public Person(){

this.name = "李雷";

}

}

 

在一个类中可以定义多个重载的构造方法

 

this关键字是对一个对象的默认引用，每个实例方法内部，都有一个this引用变量，指向调用这个方法的对象

因为this是在对象内部指代自身的引用，所以this只能调用实例变量、实例方法和构造方法。this不能调用类变量和类方法，this也不能调用局部变量。

1）使用this调用成员变量，解决成员变量和局部变量的同名冲突。

2）使用this调用成员方法

3）使用this调用重载的构造方法，只能在构造方法中使用，且必须是构造方法第一条语句

例：

public Penguin(String name,String sex){

this.name = name;

this.sex = sex;

}

public Penguin(String name, int health, int love, String sex){

this(name,sex);

this.health = health;

this.love = love;

}

 

**********************************************************

封装的步骤：

封装：

用OOP方式完成变量的声明、赋值、使用

完成2次（声明、赋值、使用）：1、封装的类 声明 赋值 使用 2、封装类里面属性的声明 赋值 使用

 

1、修改属性的可见性

将Person类中的属性由public修改为private即可。

 

例：请将Person类的属性私有化，关键代码：

public class Person{

private String name;

private String gender;

private int age;

}

 

2、设置setter/getter（）方法

 

例：请为Person类中的私有属性添加setter/getter（）方法，关键代码：

public class PrivatePerson{

private String name;

private String gender;

private int age;

public String getName(){

return name;

}

public void setName(String name){

this.name = name;

}

public String getGender(){

return gender;

}

public void setGender(String gender){

this.gender = gender;

}

public int getAge(){

return age;

}

public void setAge(int age){

this.age = age;

}

}

 

3、设置属性的存取限制

此时，属性仍然没有限制作用，需要进一步利用条件判断语句进行限制

例见myeclipse -->practise-->SetPerson

 

**********************************************************

定义包：

package 包名

 

package是关键字

报的声明必须是java源文件中的第一条非注释性语句，而且一个源文件只能有一个包声明语句，设计的包需要与文件系统结构相对应。因此，在命名包时，要遵守以下编码规范：

a、一个唯一的包名前缀通常是全部小写的ASCII字母，并且是一个顶级域名com、edu、gov、net、及org，通常使用组织的网络域名的逆序。例如，如果域名为javagroup.net，可以声明包名为“pacage net.javagroup.mypackage"

b、包名的后续部分依不同机构各自内部的规范不同而不同。这类命名规范可能以特定目录名的组成来区分部门、项目、机器或注册名，如“package net.javagroup.research.powerproject"

 

**********************************************************

包的使用：

包从大到小写：网址倒过来

1、声明包的含义是声明当前类所处的位置

2、导入包的含义是声明在当前类中要使用到的其他类所处的位置

 

//讲Person类放入pack1包中

package cn.bdqn.pack1;

public class Person{

……省略代码

}

//将PersonTest类放入pack2包中

//使用Person类时，需要使用import将其导入

package cn.bdqn.pack2;

import cn.bdqn.pack1.Person;

public class PersonTest{

public static void main(String[] atgs){

……省略代码

}

}

 

**********************************************************

类成员的访问修饰符：

作用域：　　 同一个类中　　 同一个包中　　 子类　　 任何地方

private 　　　　可以　　　　 不可以　　　 不可以 　　不可以

默认修饰符 　　  可以　　　　 可以　　　　不可以 　　不可以

protected 　　　可以 　　　　可以　　　　 可以 　　  不可以

public　　　　    可以　　　　 可以 　　　　可以 　　　可以

**********************************************************

static关键字的修饰属性：

static修饰的属性称为静态变量或者类变量，没有使用static修饰的属性称为实例变量。

 

例：将Person类的name、gender和age属性保留，新建一个static修饰的属性，并调用 ，关键代码：

public Person{

public String name;

public String gender;

public static int age;

public static int PERSON_LIVE;

//……省略代码

}

//以上为Person类代码，以下为调用代码

//……省略代码

Person hanbing = new Person();

hanbing.name = "韩冰";

hanbing.gender = "女";

hanbing.age = 22;

Person.PERSON_LIVE = 1;

 

实际开发中，static关键字修饰属性的最常用场景就是定义使用final关键字修饰的常量。使用final关键字修饰常量在整个程序运行时都不能被改变，和具体的对象没有关系，因此使用static修饰，

如“static final  int PERSON_LIVE=1"

 

PS:  1、常量名一般由大写字母组成

2、声明常量时一定要赋初值

 

**********************************************************

static关键字的修饰方法：

static修饰的方法称为静态方法或者类方法，不用static关键字修改的方法称为实例方法。

 

例：将Person中的showDetails（）方法使用static关键字修饰，并调用 ，关键代码：

public Person{

public String name;

public String gender;

public static int age;

public static void showDetails(String name,String gender,int age){

System.out.println("姓名是："+name+"，性别为："+gender+"，年龄是："+age)；

}

}

//以上为Person类代码，以下为调用代码

public class PersonTest{

public static void main(String[] args){

Person liudun = new Person();

Person.showDetails("刘顿"，"男"，23);

}

}

 

1、在静态方法中不能直接访问实例变量和实例方法。

2、在实例方法中可以直接调用类中定义的静态变量和静态方法

**********************************************************

4种基本行为：

1）访问修饰符：公共的 私有的 受保护的 默认的

2）返回类型：

有：变量的定义 数据类型 变量名

没有：void

3）方法名：和类名的规范类似

a、方法名首字母小写

b、方法名由多个单词组成，从第二个单词开始，首字母大写

c、方法名要有意义

4）参数：

有：变量的声明部分（boolean flag）

没有：（）

5）方法体：作用域{ }

a、并列：多个方法可以并列

b、嵌套：方法不能嵌套；可以嵌套流程控制 {if ( ) { }}

第一种基本行为：访问修饰符 没有返回类型 方法名（没有）{ }

例：public void add( ){ }

第二种基本行为：访问修饰符 没有返回类型 方法名（有）{ }

例：public void add (int num1,int num2){ }

1、变量声明的过程：形参 形式上的参数

2、变量赋值的过程：实参 实际上的参数

第三种基本行为：访问修饰符 有返回类型 方法名（没有）{ }

例：public int add( ){ }

1、关键字：return 后面写的是变量名，返回类型位置写的是变量的数据类型

2、return后面不能再写代码了

第四种基本行为：访问修饰符 有返回类型 方法名（有）{ }

把第二种和第三种合在一起

例：public int add(int num1,int num2){ }

 

**********************************************************

继承的语法：

访问修饰符 class <SubClass> extends <SuperClass>{ }

 

在java中，继承通过extends关键字实现，其中SubClass称为子类，SuperClass称为父类或基类。

访问修饰符如果是public，那么该类在整个项目可见。

不写访问修饰符，则该类只在当前包可见。

 

在java中，子类可以从父类中继承以下内容：

可以继承public和protected修饰的属性和方法，不论子类和父类是否在同一个包里

可以继承默认访问修饰符修饰的属性和方法，但是子类和父类必须在同一个包里

无法继承父类的构造方法

 

**********************************************************

super使用的语法：

访问父类构造方法：super（参数）

访问父类属性/方法：super.<父类属性/方法>

 

super只能出现在子类（子类的方法和构造方法）中，而不是其他位置

super用于访问父类的成员，如父类的属性、方法、构造方法。

具有访问权限的限制，如无法通过super访问private

**********************************************************

实例化子类对象：

在java中，一个类的构造方法在如下两种情况中总是会执行：

1、创建该类的对象（实例化）

2、创建该类的子类的对象（子类的实例化）

因此，子类在实例化时，会首先执行其父类的构造方法，然后才执行子类的构造方法。

 

子类继承父类时构造方法的调用规则如下：

1、如果子类的构造方法中没有通过super显示调用父类的有参构造方法，也没有通过this显示调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，是否写super（）语句，效果是一样的。

2、如果子类的构造方法中通过super显示调用父类的有参构造方法，那么将执行父类相应的构造方法，而不执行父类无参构造方法。

3、如果子类的构造方法中通过this显示调用自身的其他构造方法，在相应构造方法中应用以上两条规则

如果存在多级继承关系，在创建一个子类对象时，以上规则会多次向更高一级父类应用，一直到执行顶级父类Object类的无参构造方法为止。

**********************************************************

Object类：

Object类是所有类的父类。在java中，所有java类都直接或间接的继承了java.lang.Object类

 

关键代码：

public class Person{

}

//两种写法等价

public class Person extends Object{

}

 

**********************************************************

                        Object类的部分方法

方法 说明

toString（） 返回当前对象本身的有关信息，按字符串对象返回

equals（） 比较两个对象是否是同一个对象，若是，返回true

clone（） 生成当前对象的一个副本，并返回

hashCode（） 返回该对象的哈希代码值

getClass（） 获取当前对象所属的类信息，返回Class对象

**********************************************************

方法重写和方法重载的区别：

 

比较项 　　位置 　　方法名 　　参数表 　　　　返回值 　　　　　　访问修饰符

方法重写 　子类　　 相同 　　 　相同 　　　相同或是其子类 　　不能比父类更严格

方法重载 　同类 　　相同 　　　不相同 　　　　　无关 　　　　　　　　无关

**********************************************************

多态：

例：宠物类Pet，有几个子类，宠物类定义了看病的方法toHospital()，子类分别重写看病方法，关键代码：

class Pet{

public void toHospital(){

system.out.println(“宠物看病！”)

}

}

class Dog extends Pet{

public void toHostipal(){

system.out.println(“小鸟看病”)

}

}

public class Test{

public static void main(String[] args){

Pet pet;

pet = new Dog();

pet.toHospital();

pet = new Bird();

pet.toHospital();

}

}

 

示例中，Pet类一般声明为抽象方法，因为其本身实例化没有任何意义，toHopital（）方法声明为抽象类。

 

抽象类不能被实例化

子类如果不是抽象类，则必须重写抽象类中的全部抽象方法

abstract修饰符不能和final修饰符一起使用

abstract修饰的抽象方法没有方法体

private关键字不能修饰抽象方法

**********************************************************

抽象方法：

抽象方法没有方法体

抽象方法必须在抽象类里

抽象方法必须在子类中被实现，除非子类是抽象类

**********************************************************

向上转型的语法：

子类到父类的转换称为向上转型

<父类型><引用变量名> = new <子类型>（）；

 

将一个父类的引用指向一个子类对象，称为向上转型，自动进行类型转换

此时通过父类引用变量调用的方法时子类覆盖或继承父类的方法，不是父类的方法

此时通过父类引用变量无法调用子类特有的方法

 

**********************************************************

向下转型的语法：

<子类型><引用变量名> = （<子类型>）<父类型的引用变量>

**********************************************************

instanceof运算符：

用于判断一个对象是否属于一个类

在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常

 

例：判断宠物类型，关键代码：

public class Test{

public static void main(String[] args){

Pet pet = new Bird();

pet.toHospital();

if(pet instanceof Dog){

Dog dog = (Dog) pet;

dog.catchingFlyDisc();

}else if(pet instanceof Bird){

Bird biird = (Bird) pet;

bird.fly();

}

}

}

 

使用instanceof时，对象的类型必须和instanceof后面的参数所指定的类在继承上有上下级关系，否则会出现编译错误。

**********************************************************

多态的应用：

1、使用父类作为方法的形参

例：一个主人类，在该类中定义控制动物叫的方法。  关键代码：

class Host{

public void letCry(Animal animal){

animal.cry();

}

}

public class Test{

public static void main (String[] args){

Host host = new Host;

Animal animal;

animal = new Dog();

host.letCry(animal);

animal = new Cat();

host.letCry(animal);

animal = new Duck();

host.letCry(animal);

}

}

 

2、使用父类作为方法的返回值

使用父类作为方法的返回值，也是Java中实现和使用多态的主要方式

例：主人送出三种动物，送出的动物可以叫。  关键代码：

class Host{

public Animal donateAnimal(String type){

Animal animal;

if(type=="dog"){

animal = new Dog();

}else if(type=="cat"){

animal = new Cat();

}else{

animal = new Duck();

}

return animal;

}

}

public class Test{

public static void main(String[] args){

Host host = new Host;

Animal animal;

animal = host.donateAnimal("dog");

animal.cry();

animal = host.donateAnimal("cat");

animal.cry();

}

}