你的位置:首页 > Java教程

[Java教程]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();
}
}