static
-
一句话来描述就是：**方便在没有创建对象的情况下来进行调用方法/变量。**用：类名.方法/类名.变量来调用
-
static修饰方法
static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，**在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是须依赖具体的对象才能够被调用。**但是在非静态成员方法中是可以访问静态成员方法/变量的。
-
static修饰成员变量
static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
构造器（构造方法/函数）
-
简介：一般用来初始化成员属性和成员方法的，即new对象产生后，就调用了对象的属性和方法。**构造函数是对象一建立就运行，给对象初始化，就包括属性，执行方法中的语句。而一般函数是对象调用才执行，用 “.方法名” 的方式，给对象添加功能。**一个类即使什么都不写，也会存在一个构造方法/函数。
-
特点：
1、函数名与类名相同
2、没有返回值类型，不用写void（不同于void类型返回值，void是没有具体返回值类型；构造函数是连类型都没有）
-
默认构造函数：
当一个类中没有定义构造函数时，系统会给该类中加一个默认的无参构造函数，只是该函数是隐藏不见的。但是当在该类中自定义了构造函数，这个默认构造函数就没有了。（比如在类中定义一个有参构造，那么默认的无参构造函数就被抹除了，如果想保留这个无参构造，就必须显式地定义出来）
-
一键生成构造函数：alt+insert 笔记本是alt+shift+0，然后选择constructor
get和set：
当要访问被private封装的属性时使用，可借此获取该类私有属性的数据。
public class demo01
{
private int num;
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}
public interface test02 {
public static void main(String[] args) {
demo01 s1= new demo01();
//利用get和set来对s1这个对象的私有属性进行操作
s1.setNum(1);
int name=s1.getNum();
}
}
继承
-
所有类都默认继承object类（老祖）
-
ctrl+h快捷键。查看当前类的继承树
-
super和this
this：指向对象本身的一个指针。
super：指向自己父类对象的一个指针
super和this的注意点：
1，super调用父类的构造方法时，必须只能写在子类构造方法的第一行
2，super必须只能出现在子类的方法或者构造方法中
3，super和this不能同时调用构造方法
4，
super(参数)：调用父类中对应的构造函数
this（参数）：调用当前类对应的构造函数
5，示例代码
-
//person类 package L4; public class person { protected String name="person类"; public void print(){ System.out.println("person"); } } //student类 package L4; public class student extends person{ protected String name="student类"; public void print(){ System.out.println("student"); } public void test(String name){ System.out.println(name); //调用对象方法输入的参数 System.out.println(this.name); //student类 System.out.println(super.name); //person类 } } //测试运行类 package L4; public class test { public static void main(String[] args) { student s1=new student(); s1.test("调用对象方法输入的参数"); } }
权限控制符
| 修饰词 | 本类 | 同一个包的类 | 继承类 | 其他类 |
|---|---|---|---|---|
| private | √ | × | × | × |
| 无（默认） | √ | √ | × | × |
| protected | √ | √ | √ | × |
| public | √ | √ | √ | √ |
多态
对于多态，可以总结以下几点：
-
使用父类类型的引用指向子类的对象；
-
该引用只能调用父类中定义的方法和变量；
-
如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）
这也是方法重写的关键之处
-
变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会错。
-
方法重写必须是非静态方法。因为静态方法在类一加载的时候就出来了。
-
类修饰符是private、static、final的话不能重写。
-
多态是方法的多态，跟属性无关
-
instance方法：用来判断继承关系
-
示例代码：（父类引用指向子类）
package 方法重写; public class father { public void func1(){ func2(); } public void func2(){ System.out.println("AAA"); } } package 方法重写; public class child extends father{ //此处重载了父类的func1方法 public void func1(int i){ System.out.println("BBB"); } //此处重写了父类的func2方法 //所以在父类调用func2方法时， //会调用子类这个重写过的func2方法 public void func2(){ System.out.println("CCC"); } } package 方法重写; public class test { public static void main(String[] args) { //父类的引用指向子类，p的类型是father father p=new child(); p.func2(); p.func1(); } }
abstract
-
定义：
1：用abstract修饰的类表示抽象类，抽象类位于继承树的抽象层，抽象类不能被实例化。
2：用abstract修饰的方法表示抽象方法,抽象方法没有方法体 -
规则：
1：抽象类可以没有抽象方法，但是有抽象方法的类必须定义为抽象类，如果一个子类继承一个抽象类，子类没有实现父类的所有抽 象方法，那么子类也要定义为抽象类，否则的话编译会出错的。
2：抽象类没有构造方法，也没有抽象静态方法。但是可以有非抽象的构造方法
3：抽象类不能被实例化，但是可以创建一个引用变量，类型是一个抽象类，并让它引用非抽象类的子类的一个实例
4：不能用final 修饰符修饰
接口
-
概念：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。
-
通俗解释：接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类，既接口中的方法必须全部是抽象方法。
-
接口特点：
1，接口也能够拥有方法和属性，但是在接口中声明的方法默认是抽象的。（即只有方法标识符，而没有方法体）。
2，接口指明了一个类必须要做什么和不能做什么，相当于类的蓝图。
3，接口的作用就是告诉类，你要实现我这种接口代表的功能，你就必须实现某些方法，我才能承认你确实拥有该接口代表的某种能力。
4，如果一个类实现了一个接口中要求的所有的方法，然而没有提供方法体而仅仅只有方法标识，那么这个类一定是一个抽象类。（必须记住：抽象方法只能存在于抽象类或者接口中，但抽象类中却能存在非抽象方法，即有方法体的方法。接口是百分之百的抽象类）
5，接口中的类默认为：public abstract
接口中的属性默认为：public static final
-
为什么使用接口：java不支持多继承，通过接口来弥补这个局限性
-
接口的语法实现
//接口声明，用interface package L4.接口学习; interface TimeService { final int a=10; void display(); } //实现接口，用implements package L4.接口学习; public class UserServiceImpl implements TimeService{ @Override public void display() { System.out.println("实现TimeService接口"); } }
内部类
普通内部类
package L4.内部类;
//外部类
public class outer {
private int id=100;
public void out(){
System.out.println("这是外部类的方法！");
}
//内部类
class inner{
public void in(){
System.out.println("这是内部类的方法！");
}
//内部类可以获取外部类的私有属性、私有方法
public void GetId(){
System.out.println(id);
}
}
}
package L4.内部类;
public class Application {
public static void main(String[] args) {
//先实例化外部类对象p1
outer p1=new outer();
//然后通过这个外部类来实例化内部类对象p2
outer.inner p2=p1.new inner();
p2.in();
p2.GetId();
}
}
静态内部类
包装类
- 概念：包装类（Wrapper Class），将八种基本数据类型封装在八个类中，让他们也拥有面向对象的特性。
基本数据类型、包装类 的相互转换
import org.junit.Test;
public class WrapperTest {
//包装类-->基本数据类型:调用包装类的xxxValue()
@Test
public void test02(){
Integer i2=new Integer(100);
int i02=i2.intValue(); //此时i01就是个int类型
Float f1=new Float("12.3");
float f01=f1.floatValue();
}
//基本数据类型-->包装类:调用包装类的构造器
@Test
public void test01(){
int num1=10;
Integer i1=new Integer(num1);
System.out.println(i1.toString());
Float f1=new Float("12.3");
System.out.println(f1);
Order o1=new Order();
System.out.println(o1.ismale); //false,默认值
System.out.println(o1.isfamale); //null，因为isfamale是一个对象
}
}
class Order{
boolean ismale;
Boolean isfamale;
}
//jdk5.0新特性，自动装箱拆箱：即可以系统可以直接将基本数据类型与包装类进行转换
import org.junit.Test;
public class WrapperTest {
//包装类-->基本数据类型：拆箱
@Test
public void test02(){
Integer i2=new Integer(100);
int i02=i2; //自动拆箱
Float f1=new Float("12.3");
float f01=f1; //自动拆箱
}
//基本数据类型-->包装类:装箱
@Test
public void test01(){
int num1=10;
Integer i1=num1; //自动装箱
Integer i2=100; //自动装箱
System.out.println(i1.toString());
boolean b1=true;
Boolean b2=b1; //自动装箱
}
}
基本数据类型和包装类、String 的相互转换
//基本数据类型和包装类--->String
public void test03(){
int num1=100;
//方式一：连接运算
String str1=num1+"";
//方式二：调用string重载的valueof(xxx xxx)
float f2=12.3f;
String str01=String.valueOf(f2);
}
//String--->基本数据类型和包装类:调用包装类的parsexxx(String s)
public void test04(){
String str03="123";
int in1=Integer.parseInt(str03);
}
扫一扫
664
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
